MosaicAreaTool.cpp

#include "MosaicAreaTool.h"

#include <cmath>
#include <float.h>

#include <QDialog>
#include <QDoubleValidator>
#include <QGraphicsEllipseItem>
#include <QGraphicsScene>
#include <QGridLayout>
#include <QLabel>
#include <QLineEdit>
#include <QMenu>
#include <QMessageBox>
#include <QPushButton>

#include "Angle.h"
#include "Distance.h"
#include "iString.h"
#include "FindSpotGraphicsItem.h"
#include "MosaicGraphicsView.h"
#include "MosaicSceneWidget.h"
#include "Projection.h"

namespace Isis {
  MosaicAreaTool::MosaicAreaTool(MosaicSceneWidget *scene) :
      MosaicTool(scene) {
    m_box = NULL;
    m_drawBox = NULL;
    m_latLineEdit = NULL;
    m_lonLineEdit = NULL;
    m_areaLineEdit = NULL;

    connect(scene, SIGNAL(projectionChanged(Projection *)),
            this, SLOT(userChangedBox()));
  }


  void MosaicAreaTool::userChangedBox() {
    bool latValid = false;
    bool lonValid = false;
    bool areaValid = false;

    if(!m_latLineEdit || !m_lonLineEdit || !m_areaLineEdit) {
      clearBox();
      return;
    }

    QString latitude = m_latLineEdit->text();

    if(latitude != "Null" && latitude != "") {
      int cursorPos = 0;
      QValidator::State validLat =
        m_latLineEdit->validator()->validate(latitude, cursorPos);
      if(validLat != QValidator::Acceptable) {
        QMessageBox::warning(getWidget(), "Error",
                            "Latitude value must be in the range -90 to 90",
                            QMessageBox::Ok, QMessageBox::NoButton,
                            QMessageBox::NoButton);
      }
      else {
        latValid = true;
      }
    }

    //Validate longitude value
    QString longitude = m_lonLineEdit->text();
    if(longitude != "Null" && longitude != "" && latValid) {
      int cursorPos = 0;
      QValidator::State validLon =
        m_lonLineEdit->validator()->validate(longitude, cursorPos);
      if(validLon != QValidator::Acceptable) {
        QMessageBox::warning(getWidget(), "Error",
                            "Longitude value invalid",
                            QMessageBox::Ok, QMessageBox::NoButton,
                            QMessageBox::NoButton);
      }
      else {
        lonValid = true;
      }
    }

    QString areaString = m_areaLineEdit->text();
    if(areaString != "Null" && areaString != "" && latValid && lonValid) {
      int cursorPos = 0;
      QValidator::State validArea =
        m_areaLineEdit->validator()->validate(areaString, cursorPos);
      if(validArea != QValidator::Acceptable) {
        QMessageBox::warning(getWidget(), "Error",
                            "Area value invalid",
                            QMessageBox::Ok, QMessageBox::NoButton,
                            QMessageBox::NoButton);
      }
      else {
        areaValid = true;
      }
    }


    if(latValid && lonValid && areaValid) {
      double lat = iString(latitude.toStdString()).ToDouble();
      double lon = iString(longitude.toStdString()).ToDouble();
      double area = iString(areaString.toStdString()).ToDouble();

      Projection *projection = getWidget()->getProjection();

      if(projection && projection->SetGround(lat, lon)) {
        QPointF scenePos(projection->XCoord(), -1 * projection->YCoord());
        QRectF sceneRect(getWidget()->getView()->sceneRect());

        if(sceneRect.contains(scenePos)) {
          if(m_box != NULL) {
            clearBox();
          }

          Distance distance(area, Distance::Meters);

          QPolygonF boxPoly;
          QRectF latLonRange = calcLatLonRange(QPointF(lon, lat), distance);

          double xStep = latLonRange.width() / 100.0;
          double yStep = latLonRange.height() / 100.0;

          bool hasPole = (latLonRange.top() == -90 ||
                          latLonRange.bottom() == 90);

          double yPos = latLonRange.top();
          if(yPos != -90) {
            for(double xPos = latLonRange.left();
                xPos <= latLonRange.right();
                xPos += xStep) {
              if(projection->SetGround(yPos, xPos)) {
                QPointF pos(projection->XCoord(), -1 * projection->YCoord());
                boxPoly << pos;
              }
            }
          }

          double xPos = latLonRange.right();
          for(double yPos = latLonRange.top();
              !hasPole && yPos <= latLonRange.bottom();
              yPos += yStep) {
            if(projection->SetGround(yPos, xPos)) {
              QPointF pos(projection->XCoord(), -1 * projection->YCoord());
              boxPoly << pos;
            }
          }

          yPos = latLonRange.bottom();
          if(yPos != 90) {
            for(double xPos = latLonRange.right();
                xPos >= latLonRange.left();
                xPos -= xStep) {
              if(projection->SetGround(yPos, xPos)) {
                QPointF pos(projection->XCoord(), -1 * projection->YCoord());
                boxPoly << pos;
              }
            }
          }

          xPos = latLonRange.left();
          for(double yPos = latLonRange.bottom();
              !hasPole && yPos >= latLonRange.top();
              yPos -= yStep) {
            if(projection->SetGround(yPos, xPos)) {
              QPointF pos(projection->XCoord(), -1 * projection->YCoord());
              boxPoly << pos;
            }
          }

          if(boxPoly.size() > 0) {
            boxPoly << boxPoly[0];

            m_box = new QGraphicsPolygonItem(boxPoly);
            m_box->setZValue(DBL_MAX);

            getWidget()->getScene()->addItem(m_box);
            getWidget()->getView()->centerOn(scenePos);
          }
        }
        else {
          QString message = "Lat/Lon not within this view.";
          QMessageBox::information(getWidget(), "Cannot Calculate Box",
                                  message, QMessageBox::Ok);
        }
      }
    }
  }


  QAction *MosaicAreaTool::getPrimaryAction() {
    m_action = new QAction(this);
    m_action->setIcon(getIcon("qmos_area.png"));
    m_action->setToolTip("Show Area (a)");
    m_action->setShortcut(Qt::Key_A);
    QString text  =
      "<b>Function:</b>  Draw a box given a distance centered on a "
      "latitude/longitude.<br><br>"
      "This tool draws a black square, given an edge length in meters, "
      "centered on a latitude/longitude point. This box would be a square on "
      "the surface of the target, and is designed to be modified and warped by "
      "the current projection."
      "<p><b>Shortcut:</b>  a</p> ";
    m_action->setWhatsThis(text);
    return m_action;
  }


  QWidget *MosaicAreaTool::getToolBarWidget() {
    m_latLineEdit = new QLineEdit();
    m_latLineEdit->setValidator(new QDoubleValidator(-90.0, 90.0, 99, this));

    m_lonLineEdit = new QLineEdit();
    m_lonLineEdit->setValidator(new QDoubleValidator(this));

    m_areaLineEdit = new QLineEdit();
    m_areaLineEdit->setValidator(new QDoubleValidator(this));
    m_areaLineEdit->setText("10000");

    QLabel *latLabel = new QLabel("Latitude");
    QLabel *lonLabel = new QLabel("Longitude");
    QLabel *areaLabel = new QLabel("Size (meters)");
    areaLabel->setToolTip("This is the width and the height of the box");

    // Create the action buttons
    QPushButton *okButton = new QPushButton("Update Box");
    connect(okButton, SIGNAL(clicked()), this, SLOT(userChangedBox()));

    QPushButton *clearButton = new QPushButton("Clear Box");
    connect(clearButton, SIGNAL(clicked()), this, SLOT(clearBox()));

    // Put the buttons in a horizontal orientation
    QHBoxLayout *actionLayout = new QHBoxLayout();
    actionLayout->addWidget(latLabel);
    actionLayout->addWidget(m_latLineEdit);
    actionLayout->addWidget(lonLabel);
    actionLayout->addWidget(m_lonLineEdit);
    actionLayout->addWidget(areaLabel);
    actionLayout->addWidget(m_areaLineEdit);
    actionLayout->addWidget(okButton);
    actionLayout->addWidget(clearButton);
    actionLayout->addStretch(1);
    actionLayout->setMargin(0);

    QWidget *toolBarWidget = new QWidget;
    toolBarWidget->setLayout(actionLayout);

    return toolBarWidget;
  }


  void MosaicAreaTool::addToMenu(QMenu *menu) {

  }


  PvlObject MosaicAreaTool::toPvl() const {
    PvlObject obj(projectPvlObjectName());

    if(m_box) {
      obj += PvlKeyword("Latitude", m_latLineEdit->text());
      obj += PvlKeyword("Longitude", m_lonLineEdit->text());
      obj += PvlKeyword("Area", m_areaLineEdit->text());
      obj += PvlKeyword("Visible", (m_box != NULL));
    }

    return obj;
  }


  void MosaicAreaTool::fromPvl(const PvlObject &obj) {
    if(obj.HasKeyword("Visible")) {
      if(obj.HasKeyword("Latitude") && obj["Latitude"][0] != "Null")
        m_latLineEdit->setText(obj["Latitude"][0]);

      if(obj.HasKeyword("Longitude") && obj["Longitude"][0] != "Null")
        m_lonLineEdit->setText(obj["Longitude"][0]);

      if(obj.HasKeyword("Area") && obj["Area"][0] != "Null")
        m_areaLineEdit->setText(obj["Area"][0]);

      if((int)obj["Visible"][0] != 0) {
        userChangedBox();
      }
    }
  }


  iString MosaicAreaTool::projectPvlObjectName() const {
    return "MosaicAreaTool";
  }


  QWidget *MosaicAreaTool::createToolBarWidget() {
    QWidget *widget = new QWidget();
    return widget;
  }


  void MosaicAreaTool::mouseButtonRelease(QPointF mouseLoc, Qt::MouseButton s) {
    if(!isActive())
      return;

    if(s == Qt::LeftButton) {
      Projection *proj = getWidget()->getProjection();

      if(proj && getWidget()->getView()->sceneRect().contains(mouseLoc)) {
        if(proj->SetCoordinate(mouseLoc.x(), -1 * mouseLoc.y())) {
          if(m_drawBox != NULL) {
            clearBox();
          }

          m_latLineEdit->setText(QString::number(proj->Latitude(), 'g', 10));
          m_lonLineEdit->setText(QString::number(proj->Longitude(), 'g', 10));

          userChangedBox();
        }
      }
    }
  }


  void MosaicAreaTool::clearBox() {
    if(m_box != NULL) {
      getWidget()->getScene()->removeItem(m_box);

      delete m_box;
      m_box = NULL;
    }
  }


  QRectF MosaicAreaTool::calcLatLonRange(QPointF centerLatLon,
      Distance size) {
    Distance distanceFromCenter = size / 2.0;
    QRectF latLonBoundingBox;

    Angle centerLat(centerLatLon.y(), Angle::Degrees);
    Angle centerLon(centerLatLon.x(), Angle::Degrees);

    Projection *proj = getWidget()->getProjection();

    if(proj) {
      bool longitudeWraps = false;
      Distance radius(proj->LocalRadius(centerLat.GetDegrees()),
          Distance::Meters);

      // First we can get the angle between the latitudes...
      // d = arcsin ( movementDistance / radiusDistance )
      Angle deltaLat(asin( distanceFromCenter / radius ), Angle::Radians);

      latLonBoundingBox.setTop( (centerLat - deltaLat).GetDegrees() );

      if(latLonBoundingBox.top() < -90 && centerLatLon.y() != -90) {

        // Block infinite recursion
        if(centerLatLon.y() != 90) {
          qWarning("The pole is included in the area but not centered");
          centerLatLon.setY(-90);
          return calcLatLonRange(centerLatLon, size);
        }
        else
          return QRectF();
      }
      else if(centerLatLon.y() == -90) {
        longitudeWraps = true;
      }

      latLonBoundingBox.setBottom( (centerLat + deltaLat).GetDegrees() );

      if(latLonBoundingBox.bottom() > 90 && centerLatLon.y() != 90) {

        // Block infinite recursion
        if(centerLatLon.y() != -90) {
          qWarning("The pole is included in the area but not centered");
          centerLatLon.setY(90);
          return calcLatLonRange(centerLatLon, size);
        }
        else
          return QRectF();
      }
      else if(centerLatLon.y() == 90) {
        longitudeWraps = true;
      }

      // Now let's do lons...
      Angle widestLat(
          asin( sin(centerLat.GetRadians()) /
                cos( distanceFromCenter / radius ) ),
          Angle::Radians);

      double valueToASin = sin(distanceFromCenter / radius) /
          cos(widestLat.GetRadians());

      if(valueToASin < -1 || valueToASin > 1)
        longitudeWraps = true;

      // Longitude wraps
      if(longitudeWraps) {
        if(proj->Has360Domain()) {
          latLonBoundingBox.setLeft( 0 );
          latLonBoundingBox.setRight( 360 );
        }
        else {
          latLonBoundingBox.setLeft( -180 );
          latLonBoundingBox.setRight( 180 );
        }
      }
      else {
        Angle deltaLon(
            asin( sin(distanceFromCenter / radius) /
                  cos(widestLat.GetRadians())),
            Angle::Radians);
        latLonBoundingBox.setLeft( (centerLon - deltaLon).GetDegrees() );
        latLonBoundingBox.setRight( (centerLon + deltaLon).GetDegrees() );
      }
    }

    return latLonBoundingBox;
  }
}