DefaultFeatureInfoMaker.cpp

Go to the documentation of this file.

#include "DefaultFeatureInfoMaker.h"

//TerraLib
#include "../../../../geometry/Envelope.h"
#include "../../../widgets/canvas/MapDisplay.h"
#include "../../../../common/STLUtils.h"
#include "../../../../dataaccess/dataset/DataSet.h"
#include "../../../../dataaccess/dataset/DataSetType.h"
#include "../../../../dataaccess/utils/Utils.h"
#include "../../../../geometry/Coord2D.h"
#include "../../../../geometry/Envelope.h"
#include "../../../../geometry/Geometry.h"
#include "../../../../geometry/GeometryProperty.h"
#include "../../../../geometry/Point.h"
#include "../../../..//geometry/Utils.h"
#include "../../../../maptools/MarkRendererManager.h"
#include "../../../../raster/Raster.h"
#include "../../../../raster/RasterProperty.h"
#include "../../../../raster/Utils.h"
#include "../../../../se/Fill.h"
#include "../../../../se/Stroke.h"
#include "../../../../se/Mark.h"
#include "../../../../se/Utils.h"
#include "../../../../srs/Config.h"
#include "../../canvas/Canvas.h"
#include "../../canvas/MapDisplay.h"
#include "../../Utils.h"

// Qt
#include <QtCore/QPointF>
#include <QtCore/QString>
#include <QtCore/QStringList>
#include <QMessageBox>
#include <QMouseEvent>
#include <QObject>

// STL
#include <cassert>
#include <memory>

te::qt::widgets::DefaultFeatureInfoMaker::DefaultFeatureInfoMaker() = default;

te::qt::widgets::DefaultFeatureInfoMaker::~DefaultFeatureInfoMaker() = default;

void te::qt::widgets::DefaultFeatureInfoMaker::getInfo(QTreeWidgetItem* layerItem, MapDisplay* display,
                                                       const te::map::AbstractLayerPtr& layer, const te::gm::Envelope& e)
{
  if(layer->getVisibility() != te::map::VISIBLE)
    return;

  bool needRemap = false;
  te::gm::Envelope reprojectedEnvelope(e);

  if((layer->getSRID() != TE_UNKNOWN_SRS) &&
     (display->getSRID() != TE_UNKNOWN_SRS) &&
     (layer->getSRID() != display->getSRID()))
  {
    needRemap = true;
    reprojectedEnvelope.transform(display->getSRID(), layer->getSRID());
  }

  if(!reprojectedEnvelope.intersects(layer->getExtent()))
    return;

  try
  {
    // Gets the Layer Schema
    std::unique_ptr<const te::map::LayerSchema> ls(layer->getSchema());

    // Gets the name of the referenced spatial property
    std::string spatialPropertyName = layer->getGeomPropertyName();

    if(ls->hasGeom())
    {
      te::gm::GeometryProperty* gp = nullptr;

      if(spatialPropertyName.empty())
        gp = te::da::GetFirstGeomProperty(ls.get());
      else
        gp = dynamic_cast<te::gm::GeometryProperty*>(
            ls->getProperty(spatialPropertyName));

      assert(gp);

      // Retrieves the data from layer
      std::unique_ptr<te::da::DataSet> dataset(
          layer->getData(gp->getName(), &reprojectedEnvelope,
                         te::gm::INTERSECTS).release());

      getGeometryInfo(layerItem, display, dataset.get(), layer->getGeomPropertyName(),
                      reprojectedEnvelope, layer->getSRID(), needRemap);
    }

    if(ls->hasRaster())
    {
      te::rst::RasterProperty* rp = nullptr;

      if(spatialPropertyName.empty())
        rp = te::da::GetFirstRasterProperty(ls.get());
      else
        rp = dynamic_cast<te::rst::RasterProperty*>(
            ls->getProperty(spatialPropertyName));

      assert(rp);

      // Retrieves the data from layer
      std::unique_ptr<te::da::DataSet> dataset(
          layer->getData(rp->getName(), &reprojectedEnvelope,
                         te::gm::INTERSECTS).release());

      if(!dataset->moveNext())
        return;

      std::unique_ptr<te::rst::Raster> raster(dataset->getRaster(rp->getName()));
      assert(raster.get());

      getRasterInfo(layerItem, display, raster.get(), reprojectedEnvelope,
                    layer->getSRID(), needRemap);
    }
  }
  catch(...)
  {
    delete layerItem;
    // TODO: catch the exceptions...
  }
}

void te::qt::widgets::DefaultFeatureInfoMaker::getGeometryInfo(QTreeWidgetItem* layerItem,
                                                               MapDisplay* display,
                                                               te::da::DataSet* dataset,
                                                               const std::string& geomPropertyName,
                                                               const te::gm::Envelope& e, int srid,
                                                               bool needRemap)
{
  // Generates a geometry from the given extent. It will be used to refine the
  // results
  std::unique_ptr<te::gm::Geometry> geometryFromEnvelope(
      te::gm::GetGeomFromEnvelope(&e, srid));

  // The restriction point. It will be used to refine the results
  te::gm::Coord2D center = e.getCenter();
  te::gm::Point point(center.x, center.y, srid);

  std::size_t gpos = std::string::npos;
  geomPropertyName.empty()
      ? gpos = te::da::GetFirstPropertyPos(dataset, te::dt::GEOMETRY_TYPE)
      : gpos = te::da::GetPropertyPos(dataset, geomPropertyName);

  while(dataset->moveNext())
  {
    std::unique_ptr<te::gm::Geometry> g(dataset->getGeometry(gpos));

    if(g.get() == nullptr)
      continue;

    te::gm::TopologyValidationError err;
    bool isValid = te::gm::CheckValidity(g.get(), err);
    if(!isValid)
    {
      QString message = QObject::tr("Invalid geometry: ") + err.m_message.c_str();
      QMessageBox::warning(display, QObject::tr("Information"), message);
      return;
    }

    g->setSRID(srid);

    if(g->contains(&point) || g->crosses(geometryFromEnvelope.get()) ||
       geometryFromEnvelope->contains(g.get()))
    {
      // Feature found! Building the list of property values...
      for(std::size_t i = 0; i < dataset->getNumProperties(); ++i)
      {
        if(dataset->getPropertyDataType(i) == te::dt::RASTER_TYPE)
          continue;

        QTreeWidgetItem* propertyItem = new QTreeWidgetItem(layerItem);
        propertyItem->setText(0, dataset->getPropertyName(i).c_str());

        if(dataset->getPropertyDataType(i) == te::dt::GEOMETRY_TYPE)
          propertyItem->setIcon(0, QIcon::fromTheme("geometry"));

        if(!dataset->isNull(i))
        {
          QString qvalue;

          if(dataset->getPropertyDataType(i) == te::dt::STRING_TYPE)
          {
            std::string value = dataset->getString(i);
            qvalue = QString::fromUtf8(value.c_str());
          }
          else
          {
            if (dataset->getPropertyDataType(i) == te::dt::GEOMETRY_TYPE)
            {
              qvalue = (dataset->getAsString(i)).c_str();
            }
            else
              qvalue = dataset->getAsString(i, 3).c_str();
          }

          propertyItem->setText(1, qvalue);
        }
        else // property null value!
          propertyItem->setText(1, "");
      }

      if(needRemap)
      {
        g->setSRID(srid);
        g->transform(display->getSRID());
      }

      drawGeometry(display, g.get()); // to show feedback!

      break;
    }
  }
}

void te::qt::widgets::DefaultFeatureInfoMaker::getRasterInfo(
    QTreeWidgetItem* layerItem, MapDisplay* /*display*/,
    te::rst::Raster* raster, const te::gm::Envelope& e, int /*srid*/,
    bool /*needRemap*/)
{
  te::gm::Coord2D center = e.getCenter();
  te::gm::Coord2D coord = raster->getGrid()->geoToGrid(center.x, center.y);

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

  if((x < 0 || x >= static_cast<int>(raster->getNumberOfColumns())) ||
     (y < 0 || y >= static_cast<int>(raster->getNumberOfRows())))
     return;

  // Raster location informations
  QTreeWidgetItem* lineItem = new QTreeWidgetItem(layerItem);
  lineItem->setText(0, QObject::tr("Line"));
  lineItem->setText(1, QString::number(y));

  QTreeWidgetItem* columnItem = new QTreeWidgetItem(layerItem);
  columnItem->setText(0, QObject::tr("Column"));
  columnItem->setText(1, QString::number(x));

  QTreeWidgetItem* coordXItem = new QTreeWidgetItem(layerItem);
  coordXItem->setText(0, QObject::tr("Coordinate X"));
  coordXItem->setText(1, QString::number(center.x));

  QTreeWidgetItem* coordYItem = new QTreeWidgetItem(layerItem);
  coordYItem->setText(0, QObject::tr("Coordinate Y"));
  coordYItem->setText(1, QString::number(center.y));

  // Raster value informations for each band
  double value = 0.0;
  for(std::size_t b = 0; b < raster->getNumberOfBands(); ++b)
  {
    raster->getValue(x, y, value, b);

    QTreeWidgetItem* bandValueItem = new QTreeWidgetItem(layerItem);
    bandValueItem->setIcon(0, QIcon::fromTheme("channel-gray"));
    bandValueItem->setText(0, QObject::tr("Band") + " " + QString::number(b));
    bandValueItem->setText(1, QString::number(value));
  }
}

void te::qt::widgets::DefaultFeatureInfoMaker::drawGeometry(MapDisplay* display, te::gm::Geometry* g)
{
  QPixmap* draft = display->getDraftPixmap();

  const te::gm::Envelope& displayExtent = display->getExtent();

  Canvas canvas(draft);
  canvas.setWindow(displayExtent.m_llx, displayExtent.m_lly, displayExtent.m_urx, displayExtent.m_ury);
  canvas.setRenderHint(QPainter::Antialiasing, true);

  switch(g->getGeomTypeId())
  {
    case te::gm::PolygonType:
    case te::gm::PolygonZType:
    case te::gm::PolygonMType:
    case te::gm::PolygonZMType:
    case te::gm::MultiPolygonType:
    case te::gm::MultiPolygonZType:
    case te::gm::MultiPolygonMType:
    case te::gm::MultiPolygonZMType:
    {
      canvas.setPolygonContourWidth(2);
      canvas.setPolygonContourColor(te::color::RGBAColor(255, 0, 0, 128));
      canvas.setPolygonFillColor(te::color::RGBAColor(255, 255, 255, 128));
    }
    break;

    case te::gm::LineStringType:
    case te::gm::LineStringZType:
    case te::gm::LineStringMType:
    case te::gm::LineStringZMType:
    case te::gm::MultiLineStringType:
    case te::gm::MultiLineStringZType:
    case te::gm::MultiLineStringMType:
    case te::gm::MultiLineStringZMType:
    {
      canvas.setLineColor(te::color::RGBAColor(255, 0, 0, 128));
      canvas.setLineWidth(6);
    }
    break;

    case te::gm::PointType:
    case te::gm::PointZType:
    case te::gm::PointMType:
    case te::gm::PointZMType:
    case te::gm::MultiPointType:
    case te::gm::MultiPointZType:
    case te::gm::MultiPointMType:
    case te::gm::MultiPointZMType:
    {
      std::size_t size = 24;

      te::se::Stroke* stroke = te::se::CreateStroke("#FF0000", "2","0.5");
      te::se::Fill* fill = te::se::CreateFill("#FFFFFF", "0.5");
      te::se::Mark* mark = te::se::CreateMark("square", stroke, fill);

      te::color::RGBAColor** rgba= te::map::MarkRendererManager::getInstance().render(mark, size);

      canvas.setPointColor(te::color::RGBAColor(0, 0, 0, TE_TRANSPARENT));
      canvas.setPointPattern(rgba, static_cast<int>(size), static_cast<int>(size));

      te::common::Free(rgba, size);
      delete mark;
    }
    break;

    default:
      return;
  }

  canvas.draw(g);
}