MixtureModelWizardPage.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/qt/widgets/rp/MixtureModelWizardPage.cpp

  \brief This file defines a class for a Mixture Model Wizard page.
*/

// TerraLib
#include "../../af/ApplicationController.h"
#include "../../../common/Exception.h"
#include "../../../common/STLUtils.h"
#include "../../../dataaccess/dataset/DataSet.h"
#include "../../../dataaccess/utils/Utils.h"
#include "../../../geometry/CurvePolygon.h"
#include "../../../geometry/Enums.h"
#include "../../../geometry/Point.h"
#include "../../../geometry/Polygon.h"
#include "../../../geometry/Utils.h"
#include "../../../maptools/MarkRendererManager.h"
#include "../../../maptools/Utils.h"
#include "../../../raster/PositionIterator.h"
#include "../../../raster/Raster.h"
#include "../../../rp/MixtureModel.h"
#include "../../../rp/MixtureModelLinearStrategy.h"
#include "../../../rp/MixtureModelPCAStrategy.h"
#include "../../../se/Fill.h"
#include "../../../se/Mark.h"
#include "../../../se/Stroke.h"
#include "../../../se/Utils.h"
#include "../canvas/Canvas.h"
#include "../canvas/MapDisplay.h"
#include "MixtureModelWizardPage.h"
#include "RpToolsWidget.h"
#include "RpToolsDialog.h"
#include "SensorManagerDialog.h"

#include "../../widgets/tools/PointPicker.h"

#include "ui_MixtureModelWizardPageForm.h"

// Qt
#include <QAbstractItemModel>
#include <QPushButton>
#include <QColorDialog>
#include <QFileDialog>
#include <QGridLayout>
#include <QMessageBox>

// Boost
#include <boost/lexical_cast.hpp>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/json_parser.hpp>
#include <boost/uuid/random_generator.hpp>
#include <boost/uuid/uuid_io.hpp>

//STL
#include <fstream>
#include <memory>

//QWT
#include <qwt_symbol.h>
#include <qwt_text.h>

#define PATTERN_SIZE 12

te::qt::widgets::MixtureModelWizardPage::MixtureModelWizardPage(QWidget* parent)
  : QWizardPage(parent),
    m_ui(new Ui::MixtureModelWizardPageForm),
    m_countComponents(0),
    m_layers(0),
    m_mapDisplay(0)
{
//setup controls
  m_ui->setupUi(this);

  m_ui->m_loadToolButton->setIcon(QIcon::fromTheme("document-open"));
  m_ui->m_saveToolButton->setIcon(QIcon::fromTheme("document-save"));

  fillMixtureModelTypes();

//define mark
  te::se::Stroke* stroke = te::se::CreateStroke("#000000", "2");
  te::se::Fill* fill = te::se::CreateFill("#FF0000", "1.0");
  m_mark = te::se::CreateMark("cross", stroke, fill);

  m_rgbaMark = te::map::MarkRendererManager::getInstance().render(m_mark, PATTERN_SIZE);

//connects
  QObject::connect(m_ui->m_typeComboBox, SIGNAL(currentIndexChanged(const QString &)), this, SLOT(onMixturetypeChanged()));

  m_ui->m_noDataValueLineEdit->setValidator(new QDoubleValidator(this));


  QObject::connect(m_ui->m_mixturetabWidget, SIGNAL(currentChanged(int)), this, SLOT(onMixturetabChanged(int)));
  QObject::connect(m_ui->m_componentTreeWidget, SIGNAL(itemClicked(QTreeWidgetItem*, int)), this, SLOT(onComponentItemClicked(QTreeWidgetItem*, int)));

  connect(m_ui->m_removeToolButton, SIGNAL(clicked()), this, SLOT(onRemoveToolButtonClicked()));
  connect(m_ui->m_loadToolButton, SIGNAL(clicked()), this, SLOT(onLoadToolButtonClicked()));
  connect(m_ui->m_saveToolButton, SIGNAL(clicked()), this, SLOT(onSaveToolButtonClicked()));

  connect(m_ui->m_componentLineEdit, SIGNAL(editingFinished()), this, SLOT(oncomponentChanged()));
  connect(m_ui->m_colorToolButton, SIGNAL(clicked()), this, SLOT(oncolorToolButtonClicked()));
  connect(m_ui->m_selectedRadioButton, SIGNAL(toggled(bool)), this, SLOT(onselectedEnabled(bool)));
  connect(m_ui->m_allRadioButton, SIGNAL(toggled(bool)), this, SLOT(onallEnabled(bool)));

//configure raster navigator
  QGridLayout* layout = new QGridLayout(m_ui->m_navigatorWidget);
  m_navigator.reset(new te::qt::widgets::RpToolsWidget(m_ui->m_navigatorWidget));
  layout->addWidget(m_navigator.get(), 0, 0);
  layout->setContentsMargins(0, 0, 0, 0);
  layout->setSizeConstraint(QLayout::SetMinimumSize);

//connects
  connect(m_navigator.get(), SIGNAL(pointPicked(double, double)), this, SLOT(onPointPicked(double, double)));
  connect(m_navigator.get(), SIGNAL(geomAquired(te::gm::Polygon*)), this, SLOT(onGeomAquired(te::gm::Polygon*)));
  connect(m_navigator.get(), SIGNAL(envelopeAcquired(te::gm::Envelope)), this, SLOT(onEnvelopeAcquired(te::gm::Envelope)));

  //configure page
  this->setTitle(tr("Mixture Model"));
  this->setSubTitle(tr("Select the type of mixture model and set their specific parameters."));

  m_ui->m_removeToolButton->setIcon(QIcon::fromTheme("edit-deletetool"));

  te::qt::widgets::ChartStyle *m_chartStyle = new te::qt::widgets::ChartStyle();
  te::qt::widgets::ChartDisplay* m_chartDisplay;
  QwtPlotCurve *m_graphic;

  //Adjusting the chart Display's style.
  m_chartStyle->setTitle(tr("Spectral Curves"));
  m_chartStyle->setAxisX(tr("Wave Lenght"));
  m_chartStyle->setAxisY(tr("Answer"));
  m_chartStyle->setGridChecked(true);

  //Creating and adjusting the chart Display
  m_chartDisplay = new te::qt::widgets::ChartDisplay(m_ui->m_graphicFrame, "", m_chartStyle);
 
  m_graphic = new QwtPlotCurve();
  m_graphic->setOrientation(Qt::Horizontal);
  m_graphic->attach(m_chartDisplay);
  m_displayWidget = new te::qt::widgets::ChartDisplayWidget(m_graphic, m_graphic->rtti(), m_chartDisplay, m_ui->m_graphicFrame);

  m_layoutg = new QGridLayout(m_ui->m_graphicFrame);
  m_layoutg->addWidget(m_displayWidget);
  m_chartDisplay->adjustDisplay();

  QPixmap px(16, 16);
  px.fill(m_color);
  m_ui->m_colorToolButton->setIcon(px);

  m_sensorManagerDialog = new  te::qt::widgets::SensorManagerDialog(this);
  m_sensorManagerDialog->setWindowTitle(tr("Choose the Spectral Sensor"));
}

te::qt::widgets::MixtureModelWizardPage::~MixtureModelWizardPage()
{
  clearComponents();

  te::common::Free(m_rgbaMark, PATTERN_SIZE);

  delete m_mark;
  delete m_sensorManagerDialog;
 }

void te::qt::widgets::MixtureModelWizardPage::clearComponents()
{
  std::map<std::string, MixModelComponent>::iterator it = m_components.begin();
  while (it != m_components.end())
  {
    delete (*it).second.m_geomGeo;
    delete (*it).second.m_geomGrid;
    (*it).second.m_values.clear();
    m_components.erase(it);
    it = m_components.begin();
  }
}

bool te::qt::widgets::MixtureModelWizardPage::isComplete() const
{
  if(m_ui->m_componentTreeWidget->selectedItems().size() == 0)
    return false;

  int nBands = m_ui->m_bandTableWidget->rowCount();

  bool isChecked = false;

  std::size_t count = 0;
  for(int i = 0; i < nBands; ++i)
  {
    QCheckBox* checkBox = (QCheckBox*)m_ui->m_bandTableWidget->cellWidget(i, 0);
    
    if(checkBox->isChecked())
    {
      isChecked = true;
      ++count;
    }
  }

  if(!isChecked)
    return false;

  if(count != m_components.size())
    return false;

  return true;
}

void te::qt::widgets::MixtureModelWizardPage::set(std::list<te::map::AbstractLayerPtr> layers)
{
  m_layers = layers;

   while (m_ui->m_bandTableWidget->rowCount())
   m_ui->m_bandTableWidget->removeRow(0);

  listBands();
}

void te::qt::widgets::MixtureModelWizardPage::setMapDisplay(te::qt::widgets::MapDisplay* mapDisplay)
{
  m_mapDisplay = mapDisplay;
  m_navigator->setMapDisplay(mapDisplay);
}

void te::qt::widgets::MixtureModelWizardPage::setActionGroup(QActionGroup* actionGroup)
{
  //configure tools
  m_navigator->setActionGroup(actionGroup);
  m_navigator->enablePickerAction();
  m_navigator->enableGeomAction();
  m_navigator->enableBoxAction();
}

std::list<te::map::AbstractLayerPtr> te::qt::widgets::MixtureModelWizardPage::get()
{
  return m_layers;
}

te::rp::MixtureModel::InputParameters te::qt::widgets::MixtureModelWizardPage::getInputParams()
{
  int idx = m_ui->m_typeComboBox->currentIndex();
  int type = m_ui->m_typeComboBox->itemData(idx).toInt();

  te::rp::MixtureModel::InputParameters algoInputParams;

  if(type == MIXMODEL_LINEAR)
  {
    algoInputParams.m_strategyName = "linear";
    te::rp::MixtureModelLinearStrategy::Parameters specificParameters;
    algoInputParams.setMixtureModelStrategyParams(specificParameters);
  }
  else if(type == MIXMODEL_PCA)
  {
    algoInputParams.m_strategyName = "pca";
    te::rp::MixtureModelPCAStrategy::Parameters specificParameters;
    algoInputParams.setMixtureModelStrategyParams(specificParameters);
  }

// insert selected bands
  unsigned selectedBands = 0;
  std::vector<bool> selectedBandsVector;

  for (int i = 0; i < m_ui->m_bandTableWidget->rowCount(); ++i)
  {
    QCheckBox* bandCheckBox = (QCheckBox*) m_ui->m_bandTableWidget->cellWidget(i, 0);

    if (bandCheckBox->isChecked())
    {
      selectedBandsVector.push_back(true);
      selectedBands++;

      algoInputParams.m_inputRasterBands.push_back(i);

      QComboBox *sensorComboBox = (QComboBox*) m_ui->m_bandTableWidget->cellWidget(i, 1);
      algoInputParams.m_inputSensorBands.push_back(std::string(sensorComboBox->currentText().toUtf8().data()));
    }
    else
      selectedBandsVector.push_back(false);
  }

// insert mixture components
  std::map<std::string, MixModelComponent>::iterator it = m_components.begin();
  std::vector<double> components;

  while(it != m_components.end())
  {
    components.clear();

    for (unsigned int i = 0; i < selectedBandsVector.size(); i++)
      if (selectedBandsVector[i])
        components.push_back(it->second.m_values[i]);

    algoInputParams.m_components[it->second.m_name] = components;

    ++it;
  }

  if (m_ui->m_noDataValueCheckBox->isChecked() && !m_ui->m_noDataValueLineEdit->text().isEmpty())
  {
    algoInputParams.m_inputRasterNoDataValues.push_back(m_ui->m_noDataValueLineEdit->text().toDouble());
  }


  return algoInputParams;
}

bool te::qt::widgets::MixtureModelWizardPage::isDecompose()
{
  return m_ui->m_decomposeCheckBox->isChecked();
}

te::rp::MixtureModel::OutputParameters te::qt::widgets::MixtureModelWizardPage::getOutputParams()
{
  te::rp::MixtureModel::OutputParameters algoOutputParams;

  algoOutputParams.m_createErrorRaster = m_ui->m_createErrorRasterCheckBox->isChecked();
  algoOutputParams.m_normalizeOutput = m_ui->m_normalizeOutputCheckBox->isChecked();
  algoOutputParams.m_normalMin = 0;
  algoOutputParams.m_normalMax = 255;

  return algoOutputParams;
}

void te::qt::widgets::MixtureModelWizardPage::saveMixtureModelComponents()
{
  boost::property_tree::ptree pt;
  std::map<std::string, MixModelComponent >::iterator it = m_components.begin();
  boost::property_tree::ptree children;
  boost::property_tree::ptree bands;
  boost::property_tree::ptree srid;

  for (int b = 0; b < m_ui->m_bandTableWidget->rowCount(); b++)
  {
    QCheckBox* bandCheckBox = (QCheckBox*)m_ui->m_bandTableWidget->cellWidget(b, 0);
    QComboBox *sensorComboBox = (QComboBox*)m_ui->m_bandTableWidget->cellWidget(b, 1);

    boost::property_tree::ptree band;

    band.put("band", boost::lexical_cast<std::string>(b));
    band.put("use", bandCheckBox->isChecked() ? "true" : "false");
    band.put("sensor", sensorComboBox->currentText().toUtf8().data());

    bands.push_back(std::make_pair("Band", band));
  }

  pt.add_child("Band_Sensors", bands);

  std::unique_ptr<te::rst::Raster> inputRst(te::map::GetRaster(m_layers.begin()->get()));

  pt.put("SRID", inputRst->getSRID());

  while(it != m_components.end())
  {
    boost::property_tree::ptree child;

    child.put("name", it->second.m_name);

   boost::property_tree::ptree coordGrid;
   boost::property_tree::ptree coordGeo;
   std::string type = it->second.m_geomGeo->getGeometryType();
    if (type == "Point")
    {
      te::gm::Point *pgrid = dynamic_cast<te::gm::Point*>(it->second.m_geomGrid);
      coordGrid.put("xGrid", pgrid->getX());
      coordGrid.put("yGrid", pgrid->getY());
      child.push_back(std::make_pair("coordGrid", coordGrid));

      te::gm::Point *pgeo = dynamic_cast<te::gm::Point*>(it->second.m_geomGeo);
      coordGeo.put("xGeo", pgeo->getX());
      coordGeo.put("yGeo", pgeo->getY());
      child.push_back(std::make_pair("coordGeo", coordGeo));
    }
    else
    {
      te::gm::CurvePolygon *pgrid = dynamic_cast<te::gm::CurvePolygon*>(it->second.m_geomGrid);
      te::gm::LinearRing* lgrid = static_cast<te::gm::LinearRing*>(pgrid->getExteriorRing());
      std::size_t npts = lgrid->getNPoints();
      boost::property_tree::ptree ptgrid, ptgeo;

      for (size_t pt = 0; pt < npts; pt++)
      {
        boost::property_tree::ptree val;
        val.put("xGrid", lgrid->getPointN(pt)->getX());
        val.put("yGrid", lgrid->getPointN(pt)->getY());
        ptgrid.push_back(std::make_pair("", val));
      }
      child.add_child("geomGrid", ptgrid);

      te::gm::CurvePolygon *pgeo = dynamic_cast<te::gm::CurvePolygon*>(it->second.m_geomGeo);
      te::gm::LinearRing* lgeo = static_cast<te::gm::LinearRing*>(pgeo->getExteriorRing());

      for (size_t pt = 0; pt < npts; pt++)
      {
        boost::property_tree::ptree val;
        val.put("xGeo", lgeo->getPointN(pt)->getX());
        val.put("yGeo", lgeo->getPointN(pt)->getY());
        ptgeo.push_back(std::make_pair("", val));
      }
      child.add_child("geomCoord", ptgeo);
    }

    child.put("Color", it->second.m_color.getColor());
    children.push_back(std::make_pair("Component", child));

    ++it;
  }

  pt.add_child("MixModel_Components", children);

  te::rp::MixtureModel::InputParameters algoInputParams = getInputParams();
  if (algoInputParams.m_inputRasterBands.size() != algoInputParams.m_components.size())
    return;

  algoInputParams.m_inputRasterPtr = inputRst.get();

  te::rp::MixtureModel algorithmInstance;
  if (algorithmInstance.initialize(algoInputParams))
  {
   
    if (algorithmInstance.generateTransformMatrix(m_transfMatrix))
    {
      boost::property_tree::ptree matrix_node;
      for (size_t j = 0; j < m_transfMatrix.size1(); j++) // nrow
      {
        boost::property_tree::ptree row;
        for (size_t i = 0; i < m_transfMatrix.size2(); i++) // ncol
        {
          boost::property_tree::ptree cell;
          cell.put_value((m_transfMatrix)(j, i));
          row.push_back(std::make_pair("", cell));
        }
        matrix_node.push_back(std::make_pair("", row));
      }

      boost::property_tree::ptree child;
      child.put("Method", algoInputParams.m_strategyName);
      pt.add_child("Mixture Model", child);
      pt.add_child("Transform Matrix", matrix_node);
    }
  }

  boost::property_tree::json_parser::write_json(m_json_out, pt);
}

void te::qt::widgets::MixtureModelWizardPage::loadMixtureModelComponents(const std::string & fileName)
{
 clearComponents();

 try
 {
    boost::property_tree::ptree pt;
    boost::property_tree::json_parser::read_json(fileName, pt);

    int nBands = m_ui->m_bandTableWidget->rowCount();

    try 
    {
      for(boost::property_tree::ptree::value_type &v: pt.get_child("Band_Sensors"))
      {
        std::string band = v.second.get<std::string>("band");
        std::string used = v.second.get<std::string>("use");
        std::string sensor = v.second.get<std::string>("sensor");

        int row = std::atoi(band.c_str());

        if (row < nBands)
        {
          QCheckBox* bandCheckBox = (QCheckBox*)m_ui->m_bandTableWidget->cellWidget(row, 0);
          QComboBox *sensorComboBox = (QComboBox*)m_ui->m_bandTableWidget->cellWidget(row, 1);

          bandCheckBox->setChecked(used.compare("true") == 0);
          int index = sensorComboBox->findText(sensor.c_str());
          if (index != -1)
            sensorComboBox->setCurrentIndex(index);
        }
      }
    }
    catch (const std::exception&)
    {
      std::cout << std::endl << "Old mixture file" << std::endl;
    }

    int srid = pt.get("SRID", 0);
    if (srid == 0)
    {
      std::unique_ptr<te::rst::Raster> inputRst(te::map::GetRaster(m_layers.begin()->get()));
      srid = inputRst->getSRID();
    }
 
    for(boost::property_tree::ptree::value_type &v: pt.get_child("MixModel_Components"))
    {
      std::string name = v.second.get<std::string>("name");
      std::vector<te::gm::Point*> pointsVecg, pointsVecc;
      bool ispoint;

      m_ui->m_componentLineEdit->setText(name.c_str());

      if (v.second.find("geomCoord") != v.second.not_found())
      {
        for(boost::property_tree::ptree::value_type &c: v.second.get_child("geomCoord"))
        {
          double x = c.second.get<double>("xGeo");
          double y = c.second.get<double>("yGeo");
          pointsVecc.push_back(new te::gm::Point(x, y));
        }
        te::gm::LinearRing *l = new te::gm::LinearRing(pointsVecg.size(), te::gm::LineStringType);
        for (std::size_t i = 0; i < pointsVecc.size(); i++)
          l->setPointN(i, *pointsVecc[i]);
        te::gm::Polygon* pol = new te::gm::Polygon(1, te::gm::PolygonType, srid);
        pol->setRingN(0, l);
        m_geom = dynamic_cast<te::gm::Geometry*>(pol);
        ispoint = false;
      }

      if (v.second.find("coordGeo") != v.second.not_found())
      {
        double xGeo = v.second.get<double>("coordGeo.xGeo");
        double yGeo = v.second.get<double>("coordGeo.yGeo");
        m_geom = new te::gm::Point(xGeo, yGeo, srid);
        ispoint = true;
      }

      //Test point
      if (m_geom)
      {
        te::gm::Envelope box_cmp(*m_geom->getMBR());
        std::list<te::map::AbstractLayerPtr>::iterator it = m_layers.begin();
        while (it != m_layers.end())
        {
          te::gm::Envelope box = it->get()->getExtent();
          if (!box.contains(box_cmp))
          {
            throw te::common::Exception(tr("Invalid Componet Coordinate.").toUtf8().data());
          }
          ++it;
        }
      }

      std::string color = v.second.get<std::string>("Color");
      te::color::RGBAColor c_color(color);
      m_color = QColor(c_color.getRed(), c_color.getGreen(), c_color.getBlue(), c_color.getAlpha());

      if (ispoint)
      {
        addPointComponent();
      }
      else
      {
        addGeometryComponent();
      }
    }

    if (m_components.size())
      m_ui->m_componentLineEdit->setText(m_components.begin()->first.c_str());

    updateComponents();

    int idx = m_ui->m_typeComboBox->currentIndex();
    m_type = m_ui->m_typeComboBox->itemData(idx).toInt();

    try{
      for(boost::property_tree::ptree::value_type &v: pt.get_child("Mixture Model"))
      {
        std::string method = v.second.data();
        if ((method == "linear" && m_type == MIXMODEL_LINEAR) ||
          (method == "pca" && m_type == MIXMODEL_PCA))
        {
          size_t matrix_size = m_components.size();
          if (m_type == MIXMODEL_LINEAR)
            matrix_size++;
          boost::numeric::ublas::matrix<double> matrix = boost::numeric::ublas::matrix<double>(matrix_size, matrix_size);
          int x = 0;
          for(boost::property_tree::ptree::value_type &v: pt.get_child("Transform Matrix"))
          {
            int y = 0;
            for (boost::property_tree::ptree::value_type &cell : v.second)
            {
              matrix(x,y) = cell.second.get_value<double>();
              y++;
            }
            x++;

          }
          m_transfMatrix = matrix;
        }
      }
    }
    catch (const std::exception&)
    {
      std::cout << std::endl << "Old mixture file" << std::endl;
    }

  }
  catch(boost::property_tree::json_parser::json_parser_error &je)
  {
    QString errmsg = tr("Error parsing: ") + je.filename().c_str() + ": " + je.message().c_str();
    QMessageBox::warning(this, tr("Warning"), errmsg);
    return;
  }
  catch (te::common::Exception const& e)
  {
    QString errmsg = e.what();
    QMessageBox::warning(this, tr("Warning"), errmsg);
    m_ui->m_componentTreeWidget->clear();
  }

}

void te::qt::widgets::MixtureModelWizardPage::onSaveToolButtonClicked()
{
  m_json_out = QFileDialog::getSaveFileName(this, tr("Save MixModel Components"), "", "JSON File (*.json)").toUtf8().data();

  if(!m_json_out.empty())
    saveMixtureModelComponents();
}

void te::qt::widgets::MixtureModelWizardPage::onLoadToolButtonClicked()
{
  std::string fileName = QFileDialog::getOpenFileName(this, tr("Load MixModel Components"), "", "JSON File (*.json)").toUtf8().data();

  if(!fileName.empty())
    loadMixtureModelComponents(fileName);
}

void te::qt::widgets::MixtureModelWizardPage::onMapDisplayExtentChanged()
{
  if(m_components.empty() == false)
    drawMarks();
}

void te::qt::widgets::MixtureModelWizardPage::onPointPicked(double x, double y)
{
  m_geom = new te::gm::Point(x, y, m_mapDisplay->getSRID());

  addPointComponent();
}


void te::qt::widgets::MixtureModelWizardPage::addPointComponent()
{
  assert(m_layers.size());
  assert(m_geom);
  te::gm::Point *pt = dynamic_cast<te::gm::Point*>(m_geom);  
  double x = pt->getX();
  double y = pt->getY();

  QString comp(m_ui->m_componentLineEdit->text());

  if (comp.isEmpty())
  {
    QMessageBox::warning(this, tr("Mixture Model"), tr("First edit component name"));
    return;
  }

  //get input raster
  std::list<te::map::AbstractLayerPtr>::iterator it = m_layers.begin();
  while (it != m_layers.end())
  {
    std::unique_ptr<te::da::DataSet> ds =it->get()->getData();
    if(ds.get())
    {
      std::size_t rpos = te::da::GetFirstPropertyPos(ds.get(), te::dt::RASTER_TYPE);
      std::unique_ptr<te::rst::Raster> inputRst = ds->getRaster(rpos);

      int srid = inputRst->getSRID();

      if(inputRst.get())
      {
        if (m_mapDisplay->getSRID() != srid)
        {
          te::gm::Point pt(x, y, m_mapDisplay->getSRID());
          pt.transform(srid);
          x = pt.getX();
          y = pt.getY();
        }

        te::gm::Coord2D pixelLocation = inputRst->getGrid()->geoToGrid(x, y);

        int currentColumn = te::rst::Round(pixelLocation.x);
        int currentRow = te::rst::Round(pixelLocation.y);

        if (currentColumn < 0 || currentColumn >= (int) inputRst->getNumberOfColumns())
          return;
        if (currentRow < 0 || currentRow >= (int) inputRst->getNumberOfRows())
          return;

        //component name
          QString className = comp;

        //component values
        std::vector<double> componentsVector;

        double value;
        for(unsigned b = 0 ; b < inputRst->getNumberOfBands(); b++)
        {
          inputRst->getValue(currentColumn, currentRow, value, b);
          QString bName(it->get()->getTitle().c_str());
          bName.append(tr(" Band "));
          bName.append(QString::number(b));
          componentsVector.push_back(value);
        }
      
        //component coordinate
        MixModelComponent mmc;
        mmc.m_name = className.toUtf8().data();
        mmc.m_values = componentsVector;
        mmc.m_geomGrid =  new te::gm::Point(currentColumn, currentRow);
        mmc.m_geomGeo = new te::gm::Point(x, y, srid);

        te::color::RGBAColor newcolor(m_color.red(), m_color.green(), m_color.blue(), 255);
        mmc.m_color.setColor(newcolor.getColor());

        std::map<std::string, MixModelComponent > ::iterator it = m_components.find(className.toUtf8().data());

        if (it != m_components.end())
          it->second = mmc;
        else
          m_components.insert(std::map<std::string, MixModelComponent >::value_type(className.toUtf8().data(), mmc));
      
        updateComponents();

      } //if (inputRst.get())
    } //if (ds.get())
   ++it;
  }
}

void te::qt::widgets::MixtureModelWizardPage::onEnvelopeAcquired(te::gm::Envelope env)
{
  assert(m_layers.size());

  std::list<te::map::AbstractLayerPtr>::iterator it = m_layers.begin();
  if (m_mapDisplay->getSRID() != it->get()->getSRID())
   env.transform(m_mapDisplay->getSRID(), it->get()->getSRID());

  if (!env.isValid())
    return;

  m_geom = te::gm::GetGeomFromEnvelope(&env, it->get()->getSRID());
 
  addGeometryComponent();
}

void te::qt::widgets::MixtureModelWizardPage::onGeomAquired(te::gm::Polygon* poly)
{
  assert(m_layers.size());

  std::list<te::map::AbstractLayerPtr>::iterator it = m_layers.begin();
  if (m_mapDisplay->getSRID() != it->get()->getSRID())
    poly->transform(it->get()->getSRID());

  if (!poly->isValid())
    return;
  
  m_geom = poly;
  addGeometryComponent();
}

void te::qt::widgets::MixtureModelWizardPage::onRemoveToolButtonClicked()
{
  if(m_ui->m_componentLineEdit->text().isEmpty())
    return;

  std::string comp = m_ui->m_componentLineEdit->text().toUtf8().data();
  std::map<std::string, MixModelComponent>::iterator it = m_components.find(comp);
  if (it == m_components.end())
    return;

  QTreeWidgetItemIterator itqt(m_ui->m_componentTreeWidget);
  while (*itqt) {
    if (comp.compare((*itqt)->text(0).toUtf8().data()) == 0)
    {
      QTreeWidgetItem* item = *itqt;
      int x = m_ui->m_componentTreeWidget->indexOfTopLevelItem(item);
      if (x >= 0 && x < m_ui->m_componentTreeWidget->topLevelItemCount())
      {
        item = m_ui->m_componentTreeWidget->takeTopLevelItem(x);
        if (item)delete item;
      }
      delete (*it).second.m_geomGeo;
      delete (*it).second.m_geomGrid;
      (*it).second.m_values.clear();
      m_components.erase(comp);
      break;
    }
    ++itqt;
  }

  //Set first as current
  if (m_components.size())
    m_ui->m_componentLineEdit->setText(m_components.begin()->first.c_str());

  updateComponents();
}

void te::qt::widgets::MixtureModelWizardPage::drawGeom()
{
  drawMarks();
}

void te::qt::widgets::MixtureModelWizardPage::clearCanvas()
{
  te::qt::widgets::Canvas canvasInstance(m_mapDisplay->getDraftPixmap());

  canvasInstance.clear();

  m_mapDisplay->repaint();
}

void te::qt::widgets::MixtureModelWizardPage::fillMixtureModelTypes()
{
  m_ui->m_typeComboBox->clear();

  m_ui->m_typeComboBox->addItem(tr("Linear"), MIXMODEL_LINEAR);
  m_ui->m_typeComboBox->addItem(tr("PCA - Principal Component Analysis"), MIXMODEL_PCA);
}

void te::qt::widgets::MixtureModelWizardPage::listBands()
{
  assert(m_layers.size());

  m_maxValue.clear();

  m_SensorParams = te::rp::getSensorParams();

  std::map<std::string, te::rp::SpectralSensorParams > ::iterator it_sen;
  QStringList sensorNames;

  for(it_sen = m_SensorParams.begin(); it_sen != m_SensorParams.end(); it_sen++)
    sensorNames.append((it_sen->first).c_str());

  //get input raster
  std::list<te::map::AbstractLayerPtr>::iterator it = m_layers.begin();
  int newrow = 0;

  while (it != m_layers.end())
  {
    std::unique_ptr<te::da::DataSet> ds = it->get()->getData();
    if(ds.get())
    {
      std::size_t rpos = te::da::GetFirstPropertyPos(ds.get(), te::dt::RASTER_TYPE);
      std::unique_ptr<te::rst::Raster> inputRst = ds->getRaster(rpos);

      if(inputRst.get())
      {
        m_ui->m_bandTableWidget->setRowCount(newrow);
        connect(&m_ButtonSignalMapper, SIGNAL(mapped(int)), this, SLOT(onSensorToolButtonClicked(int)));

        // initializing the list of bands
        for(unsigned b = 0 ; b < inputRst->getNumberOfBands(); b++)
        {
          m_ui->m_bandTableWidget->insertRow(newrow);

          QString bName(it->get()->getTitle().c_str());
          bName.append(tr(" Band "));

          bName.append(QString::number(b));

          QCheckBox* bandCheckBox = new QCheckBox(bName, this);

          connect(bandCheckBox, SIGNAL(stateChanged(int)), this, SIGNAL(completeChanged()));

          QComboBox* sensorDescriptionComboBox = new QComboBox(this);
          sensorDescriptionComboBox->addItems(sensorNames);
          QToolButton *sensorFindButton = new  QToolButton(this);
          sensorFindButton->setFixedSize(20, 20);
          sensorFindButton->setText("...");

          m_ui->m_bandTableWidget->setCellWidget(newrow, 0, bandCheckBox);
          m_ui->m_bandTableWidget->setCellWidget(newrow, 1, sensorDescriptionComboBox);
          m_ui->m_bandTableWidget->setCellWidget(newrow, 2, sensorFindButton);
#if (QT_VERSION >= 0x050000)
          m_ui->m_bandTableWidget->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
#else
          m_ui->m_bandTableWidget->horizontalHeader()->setResizeMode(QHeaderView::ResizeToContents);
#endif

          m_ButtonSignalMapper.setMapping(sensorFindButton, newrow);
          connect(sensorFindButton, SIGNAL(clicked()), &m_ButtonSignalMapper, SLOT(map()));
          connect(bandCheckBox, SIGNAL(clicked()), this, SLOT(onBandItemClicked()));
          connect(sensorDescriptionComboBox, SIGNAL(currentIndexChanged(const QString &)), this, SLOT(onBandItemClicked()));
          newrow++;

          bandCheckBox->setChecked(true);
          double max = inputRst->getBand(b)->getMaxValue(true).real();
          m_maxValue.push_back(max);
        } // initializing the list of bands - end
      } //if(inputRst.get())
    } //  if(ds.get())
    ++it;
  } //while (it != m_layers.end())
  

}

void te::qt::widgets::MixtureModelWizardPage::drawMarks()
{
  m_mapDisplay->getDraftPixmap()->fill(Qt::transparent);

  const te::gm::Envelope& mapExt = m_mapDisplay->getExtent();
  
  te::qt::widgets::Canvas canvasInstance(m_mapDisplay->getDraftPixmap());
  canvasInstance.setWindow(mapExt.m_llx, mapExt.m_lly, mapExt.m_urx, mapExt.m_ury);

  std::map<std::string, MixModelComponent>::iterator it = m_components.begin();

  try
  {
    while (it != m_components.end())
    {
      std::string type = it->second.m_geomGeo->getGeometryType();
      if (type == "Point")
      {
        canvasInstance.setPointPattern(m_rgbaMark, PATTERN_SIZE, PATTERN_SIZE);
        te::gm::Point *cGeo = dynamic_cast<te::gm::Point*>(it->second.m_geomGeo);

        te::gm::Point point(*cGeo);
        if (m_mapDisplay->getSRID() != cGeo->getSRID())
          point.transform(m_mapDisplay->getSRID());

        canvasInstance.setPointColor(it->second.m_color);

        if (it->first == m_comp)
        {
          canvasInstance.setPointWidth(30);
        }

        canvasInstance.draw(&point);
      }
      else
      {
        te::gm::Polygon *cGeo = dynamic_cast<te::gm::Polygon*>(it->second.m_geomGeo);
        te::gm::Polygon pol(*cGeo);

        if (m_mapDisplay->getSRID() != it->second.m_geomGeo->getSRID())
         pol.transform(m_mapDisplay->getSRID());

        te::color::RGBAColor black(0, 0, 0, 255);
        te::color::RGBAColor red(255, 0, 0, 255);
        short opacity = 127;
        if (it->first == m_comp)
        {
          opacity = 255;
          canvasInstance.setPolygonContourColor(red);
        }
        else
          canvasInstance.setPolygonContourColor(black);

        te::color::RGBAColor polcolor(it->second.m_color.getRed(), it->second.m_color.getGreen(), it->second.m_color.getBlue(), opacity);
        canvasInstance.setPolygonFillColor(polcolor);
        canvasInstance.setPolygonContourWidth(1);

        canvasInstance.draw(&pol);
      }

      ++it;
    }
  }
  catch (const std::exception&)
  {
    std::cout << std::endl << "Points out" << std::endl;
  }

  m_mapDisplay->repaint();
}

void te::qt::widgets::MixtureModelWizardPage::updateComponents()
{
  m_ui->m_componentTreeWidget->clear();

  std::map<std::string, MixModelComponent>::iterator it;
 
  unsigned int nBands = m_ui->m_bandTableWidget->rowCount();

  for (it = m_components.begin(); it != m_components.end(); ++it)
  {
    QBrush brush(QColor(it->second.m_color.getRed(), it->second.m_color.getGreen(), it->second.m_color.getBlue(), 255));
    QTreeWidgetItem* compItem = new QTreeWidgetItem;
    compItem->setText(0, it->first.c_str());
    compItem->setForeground(0, brush);
    m_ui->m_componentTreeWidget->addTopLevelItem(compItem);
    m_ui->m_componentTreeWidget->setCurrentItem(compItem);

    for (unsigned int i = 0; i < nBands; ++i)
    {
      QCheckBox* checkBox = (QCheckBox*)m_ui->m_bandTableWidget->cellWidget(i, 0);
      if (checkBox && checkBox->isChecked())
      {
        QComboBox* comboBox = (QComboBox*)m_ui->m_bandTableWidget->cellWidget(i, 1);
        QTreeWidgetItem* item = new QTreeWidgetItem(compItem);
        item->setText(0, comboBox->currentText());
        if (i < it->second.m_values.size())
          item->setText(1, QString::number(it->second.m_values[i] / m_maxValue[i]));
        else
          item->setText(1, QString::number(0.0));
        item->setForeground(0, brush);
        item->setForeground(1, brush);
        m_ui->m_componentTreeWidget->setCurrentItem(item);
        m_ui->m_componentTreeWidget->resizeColumnToContents(0);
        m_ui->m_componentTreeWidget->resizeColumnToContents(1);
      }
    }
  }

  m_transfMatrix.resize(0,0,false);

  drawMarks();

  PlotSpectralSignature();

  emit completeChanged();
}

void te::qt::widgets::MixtureModelWizardPage::onComponentItemClicked(QTreeWidgetItem * item, int column)
{
  assert(item);

  m_comp = "";

  if (!item->childCount())
  {
    QTreeWidgetItem* parent = item->parent();
    if (!parent)
      return;
    item = parent;
  }  

  m_ui->m_componentLineEdit->setText(item->text(0));

  std::map<std::string, MixModelComponent>::iterator it = m_components.find(item->text(0).toStdString());
  if (it != m_components.end())
  {
    m_color = QColor(it->second.m_color.getRed(), it->second.m_color.getGreen(), it->second.m_color.getBlue(), it->second.m_color.getAlpha());
    QPixmap px(16, 16);
    px.fill(m_color);
    m_ui->m_colorToolButton->setIcon(px);
    m_comp = it->first;
  }

  drawMarks();

  PlotSpectralSignature();
}

void te::qt::widgets::MixtureModelWizardPage::PlotSpectralSignature()
{
  te::qt::widgets::ChartStyle *m_chartStyle = new te::qt::widgets::ChartStyle();
  te::qt::widgets::ChartDisplay* m_chartDisplay;
  if (m_displayWidget)
  {
    m_layoutg->removeWidget(m_displayWidget);
    delete m_displayWidget;
    m_displayWidget = 0;
  }

  if (m_ui->m_selectedRadioButton->isChecked())
  {
    m_chartStyle->setTitle(m_ui->m_componentLineEdit->text());
  }
  else
    m_chartStyle->setTitle(tr("Spectral Curves"));
 
  m_chartStyle->setAxisX(tr("Wave Lenght"));
  m_chartStyle->setAxisY(tr("Answer"));
  m_chartStyle->setGridChecked(true);

  //Creating and adjusting the chart Display
  m_chartDisplay = new te::qt::widgets::ChartDisplay(m_ui->m_graphicFrame, "", m_chartStyle);
  m_chartDisplay->adjustDisplay();

  bool first = true;
  for (std::map<std::string, MixModelComponent > ::iterator it = m_components.begin(); it != m_components.end(); it++)
  {
    if (m_ui->m_selectedRadioButton->isChecked())
    {
      if (it->first.compare(m_ui->m_componentLineEdit->text().toStdString()) != 0)
        continue;
    }
    QwtPlotCurve *graphic = new QwtPlotCurve();
    graphic->setOrientation(Qt::Horizontal);
    QVector<QPointF> values;
    double wave = 0;
    for (unsigned int ii = 0; ii < it->second.m_values.size(); ++ii)
    {
      QCheckBox* bandCheckBox = (QCheckBox*)m_ui->m_bandTableWidget->cellWidget(ii, 0);
      if (bandCheckBox->isChecked())
      {
        QComboBox* sensor = (QComboBox*)m_ui->m_bandTableWidget->cellWidget(ii, 1);
        wave = GetMediumWavelength(sensor->currentText().toStdString());
        bool insert = false;
        for (int iv = 0; iv < values.size(); ++iv)
        {
          if (values[iv].x() > wave)
          {
            values.insert(iv, QPointF(wave, it->second.m_values[ii]/m_maxValue[ii]));
            insert = true;
            break;
          }
        }
        if (!insert)
          values.push_back(QPointF(wave, it->second.m_values[ii]/m_maxValue[ii]));
      }
    }

    graphic->setSamples(values);

    QPen CurvePen;
    CurvePen.setColor(QColor(it->second.m_color.getRed(), it->second.m_color.getGreen(), it->second.m_color.getBlue()));
    CurvePen.setStyle(Qt::SolidLine);
    CurvePen.setWidth(0);
    graphic->setPen(CurvePen);

    graphic->attach(m_chartDisplay);

    if (first)
    {
      m_displayWidget = new te::qt::widgets::ChartDisplayWidget(graphic, graphic->rtti(), m_chartDisplay, m_ui->m_graphicFrame);
      first = false;
    }
  }

  if (!m_displayWidget)
    return;

  m_layoutg->addWidget(m_displayWidget);
  m_chartDisplay->adjustDisplay();
  m_displayWidget->show();

}

double te::qt::widgets::MixtureModelWizardPage::GetMediumWavelength(std::string sensor)
{
  te::rp::SpectralSensorParams val = m_SensorParams[sensor];
  return ((val.m_lower + val.m_upper)/2.);
}

void te::qt::widgets::MixtureModelWizardPage::oncomponentChanged()
{
  updateComponents();
}

void te::qt::widgets::MixtureModelWizardPage::oncolorToolButtonClicked()
{
 // m_rgbaMark
  QString comp(m_ui->m_componentLineEdit->text());
  
  std::map<std::string, MixModelComponent>::iterator itc = m_components.find(comp.toUtf8().data());
  if (itc != m_components.end())
    m_color = QColor(itc->second.m_color.getRed(), itc->second.m_color.getGreen(),itc->second.m_color.getBlue(),itc->second.m_color.getAlpha());

  m_color = QColorDialog::getColor(m_color, this);
  if (itc != m_components.end())
  {
    te::color::RGBAColor newcolor(m_color.red(), m_color.green(), m_color.blue(),255);
    itc->second.m_color.setColor(newcolor.getColor());
  }

  QPixmap px(16, 16);
  px.fill(m_color);
  m_ui->m_colorToolButton->setIcon(px);

  updateComponents();
}

void te::qt::widgets::MixtureModelWizardPage::onselectedEnabled(bool status)
{
  if (status)
    PlotSpectralSignature();
}

void te::qt::widgets::MixtureModelWizardPage::onallEnabled(bool status)
{
  if (status)
    PlotSpectralSignature();
}

void te::qt::widgets::MixtureModelWizardPage::onMixturetypeChanged()
{
  m_transfMatrix.clear();
  m_transfMatrix.resize(0, 0, false);

}

void te::qt::widgets::MixtureModelWizardPage::onMixturetabChanged(int page)
{
  if (page == 1)
    updateComponents();
}

void te::qt::widgets::MixtureModelWizardPage::addGeometryComponent()
{
  assert(m_layers.size());

  m_comp = m_ui->m_componentLineEdit->text().toStdString();

  if (m_comp.length() == 0)
  {
    QMessageBox::warning(this, tr("Mixture Model"), tr("First edit component name"));
    return;
  }

  te::gm::Polygon* pol = dynamic_cast<te::gm::Polygon*>(m_geom->clone());

  std::vector<double> allvalues;

  //get input raster
  std::list<te::map::AbstractLayerPtr>::iterator it = m_layers.begin();
  while (it != m_layers.end())
  {
    std::unique_ptr<te::da::DataSet> ds = it->get()->getData();
    if (ds.get())
    {
      std::size_t rpos = te::da::GetFirstPropertyPos(ds.get(), te::dt::RASTER_TYPE);
      std::unique_ptr<te::rst::Raster> inputRst = ds->getRaster(rpos);

      if (inputRst.get())
      {
        if (inputRst->getSRID() != it->get()->getSRID())
          inputRst->getGrid()->setSRID(it->get()->getSRID());

        //component name
        std::string className(m_comp);
        //component values
        std::vector<double> componentsVector;

        te::rst::PolygonIterator<double> itRasterEnd = te::rst::PolygonIterator<double>::end(inputRst.get(), pol);

        //iterate polygon
        int npixels = 0;
        for (std::size_t nb = 0; nb < inputRst->getNumberOfBands(); nb++)
          allvalues.push_back(0);

        std::vector<double>::iterator itv, ita;
        for (te::rst::PolygonIterator<double> itRaster = te::rst::PolygonIterator<double>::begin(inputRst.get(), pol); itRaster != itRasterEnd; ++itRaster)
        {
          std::vector<double> values;
          int currentColumn = itRaster.getColumn();
          int currentRow = itRaster.getRow();

          if (currentColumn < 0 || currentColumn >= (int)inputRst->getNumberOfColumns())
            continue;
          if (currentRow < 0 || currentRow >= (int)inputRst->getNumberOfRows())
            continue;

          inputRst->getValues(currentColumn, currentRow, values);
          for (itv = values.begin(), ita = allvalues.begin(); itv != values.end(), ita != allvalues.end(); itv++, ita++)
            (*ita) += *itv;
          npixels++;
        }

        for (ita = allvalues.begin(); ita != allvalues.end(); ita++)
          (*ita) /= npixels;

        for (unsigned b = 0; b < inputRst->getNumberOfBands(); b++)
        {
          QString bName(it->get()->getTitle().c_str());
          bName.append(tr(" Band "));
          bName.append(QString::number(b));
          componentsVector.push_back(allvalues[b]);
        }

        //component coordinate
        te::gm::Polygon *pgrid = new te::gm::Polygon(*pol);
        te::gm::LinearRing *lr = dynamic_cast<te::gm::LinearRing*>(pol->getExteriorRing());
        te::gm::LinearRing *lrg = dynamic_cast<te::gm::LinearRing*>(pgrid->getExteriorRing());
        for (std::size_t i = 0; i < lr->getNPoints(); i++)
        {
          te::gm::Coord2D pixelLocation = inputRst->getGrid()->geoToGrid(lr->getPointN(i)->getX(), lr->getPointN(i)->getY());
          int currentColumn = te::rst::Round(pixelLocation.x);
          int currentRow = te::rst::Round(pixelLocation.y);
          lrg->setX(i, currentColumn);
          lrg->setY(i, currentRow);
        }

        delete pol;

        MixModelComponent mmc;
        mmc.m_name = className;
        mmc.m_values = componentsVector;
        mmc.m_geomGrid = dynamic_cast<te::gm::Geometry*>(pgrid);
        mmc.m_geomGeo = m_geom;
        mmc.m_color.setColor(m_color.red(), m_color.green(), m_color.blue(), 255);

        std::map<std::string, MixModelComponent > ::iterator it = m_components.find(className);
        if (it != m_components.end())
          it->second = mmc;
        else
          m_components.insert(std::map<std::string, MixModelComponent >::value_type(className, mmc));

        updateComponents();
      } //if (inputRst.get())
    } //if (ds.get())
    ++it;
  }
}

void te::qt::widgets::MixtureModelWizardPage::onSensorToolButtonClicked(int row)
{
  if (m_sensorManagerDialog->exec() == QDialog::Rejected)
    return;

  QString sensor = m_sensorManagerDialog->getSelectedSensor();

  if(!sensor.size())
    return;

    QComboBox *sensorComboBox = (QComboBox*)m_ui->m_bandTableWidget->cellWidget(row, 1);

  if (m_sensorManagerDialog->isModified())
  {
    sensorComboBox->clear();

    m_SensorParams = te::rp::getSensorParams();

    std::map<std::string, te::rp::SpectralSensorParams > ::iterator it_sen;
    QStringList sensorNames;

    for (it_sen = m_SensorParams.begin(); it_sen != m_SensorParams.end(); it_sen++)
      sensorNames.append((it_sen->first).c_str());

    sensorComboBox->addItems(sensorNames);
  }

  int index = sensorComboBox->findText(sensor);
  sensorComboBox->setCurrentIndex(index);

}

void te::qt::widgets::MixtureModelWizardPage::onBandItemClicked()
{
  updateComponents();
}