ControlPointGraphicsItem.cpp

#include "ControlPointGraphicsItem.h"
 
#include <float.h>
#include <iostream>
 
#include <QDebug>
#include <QEvent>
#include <QGraphicsScene>
#include <QGraphicsSceneContextMenuEvent>
#include <QMenu>
#include <QMessageBox>
#include <QBrush>
#include <QPainterPath>
#include <QPen>
 
#include "Constants.h"
#include "ControlMeasure.h"
#include "ControlPoint.h"
#include "Directory.h"
#include "FileName.h"
#include "MosaicGraphicsView.h"
#include "MosaicSceneWidget.h"
#include "SerialNumberList.h"
#include "Statistics.h"
 
using namespace std;
 
namespace Isis {
  ControlPointGraphicsItem::ControlPointGraphicsItem(QPointF center,
      QPointF apriori, ControlPoint *cp, SerialNumberList *snList,
      MosaicSceneWidget *boundingRectSrc, QGraphicsItem *parent) :
      QGraphicsRectItem(parent) {
    m_centerPoint = new QPointF(center);
    m_mosaicScene = boundingRectSrc;
    m_controlPoint = cp;
    m_showArrow = false;
    m_colorByMeasureCount = false;
    m_colorByResidualMagnitude = false;
 
    m_measureCount = -1;
    m_residualMagnitude = Null;
 
    setZValue(DBL_MAX);
 
    m_origPoint = new QPointF(apriori);
 
    // Providing a width of 0 makes pens cosmetic (i.e. always appear as 1 pixel on screen)
    if (cp->IsIgnored()) {
      setPen(QPen(Qt::yellow, 0.0));
    }
    else if ( (cp->GetType() == ControlPoint::Fixed)
      || (cp->GetType() == ControlPoint::Constrained) ) {
      setPen(QPen(Qt::magenta, 0.0));
    }
    else { // Free and editLocked
      setPen(QPen(Qt::darkGreen, 0.0));
    }
 
    setBrush(Qt::NoBrush);
 
    setToolTip(makeToolTip(snList));
 
    setRect(calcRect());
 
    setFlag(QGraphicsItem::ItemIsSelectable, true);
    setFlag(QGraphicsItem::ItemIsFocusable, true);
 
//  setFiltersChildEvents(true);
//  installEventFilter(this);
  }
 
 
  ControlPointGraphicsItem::~ControlPointGraphicsItem() {
    if (m_centerPoint) {
      delete m_centerPoint;
      m_centerPoint = NULL;
    }
 
    if (m_origPoint) {
      delete m_origPoint;
      m_origPoint = NULL;
    }
 
    m_mosaicScene = NULL;
  }
 
 
  void ControlPointGraphicsItem::paint(QPainter *painter,
      const QStyleOptionGraphicsItem *style,  QWidget * widget) {
 
    QRectF fullRect = calcRect();
    QRectF crosshairRect = calcCrosshairRect();
 
    if (crosshairRect.isNull()) {
      return;
    }
 
    if (rect() != fullRect) {
      setRect(fullRect);
    }
    else {
      painter->setPen(pen());
      painter->setBrush(brush());
 
      QPointF center = crosshairRect.center();
 
      QPointF centerLeft(crosshairRect.left(), center.y());
      QPointF centerRight(crosshairRect.right(), center.y());
      QPointF centerTop(center.x(), crosshairRect.top());
      QPointF centerBottom(center.x(), crosshairRect.bottom());
 
      if (m_mosaicScene->directory() &&
          m_mosaicScene->directory()->editPointId() == m_controlPoint->GetId()) {
        QPainterPath path;
        //  Draw circle, then crosshair inside circle
        path.addEllipse(crosshairRect);
        path.moveTo(centerTop);
        path.lineTo(centerBottom);
        path.moveTo(centerLeft);
        path.lineTo(centerRight);
 
        painter->setPen(QPen(Qt::red, 0.0));
        painter->drawPath(path);
      }
      else {
        painter->drawLine(centerLeft, centerRight);
        painter->drawLine(centerTop, centerBottom);
      }
 
      if (!m_origPoint->isNull() && *m_origPoint != *m_centerPoint
         && m_showArrow) {
 
        if (!m_colorByMeasureCount && !m_colorByResidualMagnitude) {
          painter->setPen(Qt::black);
          painter->setBrush(Qt::black);
        }
        else {
          QColor zeroColor(Qt::black);
          QColor fullColor(Qt::green);
 
          bool isColored = false;
 
          if (m_colorByMeasureCount) {
            int fullColorMeasureCount = qMax(1, m_measureCount);
            int measureCount = m_controlPoint->getMeasures(true).count();
            isColored = (measureCount >= fullColorMeasureCount);
          }
          else {
            fullColor = QColor(Qt::red);
 
            double fullColorErrorMag = 0.0;
 
            if (!IsSpecial(m_residualMagnitude)) {
              fullColorErrorMag = m_residualMagnitude;
            }
 
            Statistics residualStats;
            foreach (ControlMeasure *cm, m_controlPoint->getMeasures(true)) {
              residualStats.AddData(cm->GetResidualMagnitude());
            }
 
            if (residualStats.Average() != Null) {
              double errorMag = residualStats.Maximum();
              if (errorMag >= fullColorErrorMag) {
                isColored = true;
              }
            }
          }
 
          QColor finalColor = isColored? fullColor : zeroColor;
 
          painter->setPen(finalColor);
          painter->setBrush(finalColor);
        }
        painter->drawLine(*m_origPoint, *m_centerPoint);
 
        QPolygonF arrowHead = calcArrowHead();
        painter->drawPolygon(arrowHead);
      }
    }
  }
 
 
  ControlPoint *ControlPointGraphicsItem::controlPoint() {
    return m_controlPoint;
  }
 
  void ControlPointGraphicsItem::setArrowVisible(bool visible,
                                                 bool colorByMeasureCount,
                                                 int measureCount,
                                                 bool colorByResidualMagnitude,
                                                 double residualMagnitude) {
    m_showArrow = visible;
    m_colorByMeasureCount = colorByMeasureCount;
    m_measureCount = measureCount;
    m_colorByResidualMagnitude = colorByResidualMagnitude;
    m_residualMagnitude = residualMagnitude;
    setRect(calcRect());
    update();
  }
 
 
  void ControlPointGraphicsItem::contextMenuEvent(
      QGraphicsSceneContextMenuEvent * event) {
    QMenu menu;
 
    QAction *title = menu.addAction(
        m_controlPoint->GetId());
    title->setEnabled(false);
    menu.addSeparator();
 
    QAction *infoAction = menu.addAction("Show Point Info");
 
    QAction *selected = menu.exec(event->screenPos());
 
    if (selected == infoAction) {
      QMessageBox::information(m_mosaicScene, "Control Point Information",
          toolTip());
    }
  }
 
 
  QRectF ControlPointGraphicsItem::calcRect() const {
    QRectF pointRect(calcCrosshairRect());
 
    if (!m_origPoint->isNull() && pointRect.isValid()) {
      // Make the rect contain the orig point
      if (pointRect.left() > m_origPoint->x()) {
        pointRect.setLeft(m_origPoint->x());
      }
      else if (pointRect.right() < m_origPoint->x()) {
        pointRect.setRight(m_origPoint->x());
      }
 
      if (pointRect.top() > m_origPoint->y()) {
        pointRect.setTop(m_origPoint->y());
      }
      else if (pointRect.bottom() < m_origPoint->y()) {
        pointRect.setBottom(m_origPoint->y());
      }
    }
 
    QPolygonF arrowHead = calcArrowHead();
 
    if (arrowHead.size() > 2) {
      pointRect = pointRect.united(arrowHead.boundingRect());
    }
 
    return pointRect;
  }
 
 
  QRectF ControlPointGraphicsItem::calcCrosshairRect() const {
    QRectF pointRect;
 
    if (m_centerPoint && !m_centerPoint->isNull() && m_mosaicScene) {
      static const int size = 12;
      QPoint findSpotScreen =
          m_mosaicScene->getView()->mapFromScene(*m_centerPoint);
      QPoint findSpotTopLeftScreen =
          findSpotScreen - QPoint(size / 2, size / 2);
 
      QRect pointRectScreen(findSpotTopLeftScreen, QSize(size, size));
 
      pointRect =
          m_mosaicScene->getView()->mapToScene(pointRectScreen).boundingRect();
    }
 
    return pointRect;
  }
 
 
  QPolygonF ControlPointGraphicsItem::calcArrowHead() const {
    QPolygonF arrowHead;
 
    if (m_showArrow && !m_origPoint->isNull() &&
       *m_origPoint != *m_centerPoint) {
      QRectF crosshairRect = calcCrosshairRect();
      double headSize = crosshairRect.width() * 4.0 / 5.0;
 
      double crosshairSize = headSize;
 
      // Draw arrow
      QPointF lineVector = *m_centerPoint - *m_origPoint;
      double lineVectorMag = sqrt(lineVector.x() * lineVector.x() +
                                  lineVector.y() * lineVector.y());
      double thetaPointOnLine = crosshairSize / (2 * (tanf(PI / 6) / 2) *
                            lineVectorMag);
      QPointF pointOnLine = *m_centerPoint - thetaPointOnLine * lineVector;
 
      QPointF normalVector = QPointF(-lineVector.y(), lineVector.x());
      double thetaNormal = crosshairSize / (2 * lineVectorMag);
 
      QPointF leftPoint = pointOnLine + thetaNormal * normalVector;
      QPointF rightPoint = pointOnLine - thetaNormal * normalVector;
 
      arrowHead << leftPoint << crosshairRect.center() << rightPoint;
    }
 
    return arrowHead;
  }
 
 
  QString ControlPointGraphicsItem::makeToolTip(SerialNumberList *snList) {
    QString toolTip = "<div>Point ID: " +
        m_controlPoint->GetId();
    toolTip += "<br />Point Type: " +
        m_controlPoint->GetPointTypeString();
    toolTip += "<br />Number of Measures: ";
    toolTip += toString(m_controlPoint->GetNumMeasures());
    toolTip += "<br />Ignored: ";
    toolTip += m_controlPoint->IsIgnored() ? "Yes" : "No";
    toolTip += "<br />Edit Locked: ";
    toolTip += m_controlPoint->IsEditLocked() ? "Yes" : "No";
 
    toolTip += "<br />";
 
    if (snList == NULL) {
      toolTip += QStringList(m_controlPoint->getCubeSerialNumbers()).join("\n");
    }
    else {
      QStringList serialNums(m_controlPoint->getCubeSerialNumbers());
 
      for(int snIndex = 0; snIndex < serialNums.size(); snIndex ++) {
        QString serialNum = serialNums[snIndex];
 
        if (snIndex > 0) {
          toolTip += "<br />";
        }
 
        if (snList->hasSerialNumber(serialNum)) {
          toolTip +=
              FileName(snList->fileName(serialNum)).name();
          toolTip += " (" + serialNum + ")";
        }
        else {
          toolTip += serialNum;
        }
 
        double residMag = m_controlPoint->GetMeasure(serialNum)->GetResidualMagnitude();
        if (residMag != Null) {
          toolTip += " [residual: <font color='red'>" + toString(residMag) + "</font>]";
        }
      }
    }
 
    toolTip += "</div>";
 
    return toolTip;
  }
 
 
//bool MosaicSceneWidget::
//(QObject *obj, QEvent *event) {
//
//  switch(event->type()) {
//    case QMouseEvent::GraphicsSceneMousePress: {
 
 
}