InstrumentWidgetPickTab.cpp

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#include "MantidQtWidgets/InstrumentView/InstrumentWidgetPickTab.h"
#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
#include "MantidQtWidgets/Common/TSVSerialiser.h"
#endif
#include "MantidQtWidgets/InstrumentView/CollapsiblePanel.h"
#include "MantidQtWidgets/InstrumentView/InstrumentActor.h"
#include "MantidQtWidgets/InstrumentView/InstrumentWidget.h"
#include "MantidQtWidgets/InstrumentView/PeakMarker2D.h"
#include "MantidQtWidgets/InstrumentView/Projection3D.h"
#include "MantidQtWidgets/InstrumentView/ProjectionSurface.h"
#include "MantidQtWidgets/InstrumentView/UnwrappedSurface.h"

#include "MantidAPI/AlgorithmManager.h"
#include "MantidAPI/AnalysisDataService.h"
#include "MantidAPI/Axis.h"
#include "MantidAPI/IPeaksWorkspace.h"
#include "MantidAPI/MatrixWorkspace.h"
#include "MantidAPI/Sample.h"
#include "MantidAPI/WorkspaceFactory.h"
#include "MantidDataObjects/Peak.h"
#include "MantidGeometry/Crystal/OrientedLattice.h"
#include "MantidGeometry/Instrument/ComponentInfo.h"
#include "MantidGeometry/Instrument/DetectorInfo.h"
#include "MantidKernel/Unit.h"
#include "MantidKernel/V3D.h"

#include <QAction>
#include <QActionGroup>
#include <QApplication>
#include <QGridLayout>
#include <QLabel>
#include <QMenu>
#include <QMessageBox>
#include <QPixmap>
#include <QPushButton>
#include <QSettings>
#include <QSignalMapper>
#include <QTextEdit>
#include <QVBoxLayout>

#include <algorithm>
#include <cfloat>
#include <cmath>
#include <numeric>
#include <vector>

#include <boost/math/constants/constants.hpp>

using Mantid::API::AlgorithmManager;

namespace MantidQt {
namespace MantidWidgets {

using namespace boost::math;

namespace {
// Get the phi angle between the detector with reference to the origin
// Makes assumptions about beam direction. Legacy code and not robust.
double getPhi(const Mantid::Kernel::V3D &pos) {
  return std::atan2(pos[1], pos[0]);
}

// Calculate the phi angle between detector and beam, and then offset.
// Makes assumptions about beam direction. Legacy code and not robust.
double getPhiOffset(const Mantid::Kernel::V3D &pos, const double offset) {
  double avgPos = getPhi(pos);
  return avgPos < 0 ? -(offset + avgPos) : offset - avgPos;
}
} // namespace

/**
 * Constructor.
 * @param instrWidget :: Parent InstrumentWidget.
 */
InstrumentWidgetPickTab::InstrumentWidgetPickTab(InstrumentWidget *instrWidget)
    : InstrumentWidgetTab(instrWidget), m_freezePlot(false),
      m_tubeXUnitsCache(0), m_plotTypeCache(0),
      m_addedActions(
          std::vector<std::pair<
              QAction *, std::function<bool(std::map<std::string, bool>)>>>{}) {

  // connect to InstrumentWindow signals
  connect(m_instrWidget, SIGNAL(integrationRangeChanged(double, double)), this,
          SLOT(changedIntegrationRange(double, double)));

  m_plotSum = true;

  QVBoxLayout *layout = new QVBoxLayout(this);

  // set up the selection display
  m_selectionInfoDisplay = new QTextEdit(this);

  // set up the plot widget
  m_plot = new MiniPlot(this);
  connect(m_plot, SIGNAL(showContextMenu()), this, SLOT(plotContextMenu()));

  // Plot context menu actions
  m_sumDetectors = new QAction("Sum", this);
  m_sumDetectors->setCheckable(true);
  m_sumDetectors->setChecked(true);
  m_integrateTimeBins = new QAction("Integrate", this);
  m_integrateTimeBins->setCheckable(true);
  m_summationType = new QActionGroup(this);
  m_summationType->addAction(m_sumDetectors);
  m_summationType->addAction(m_integrateTimeBins);
  m_logY = new QAction("Y log scale", this);
  m_linearY = new QAction("Y linear scale", this);
  m_yScale = new QActionGroup(this);
  m_yScale->addAction(m_linearY);
  m_yScale->addAction(m_logY);
  m_logY->setCheckable(true);
  m_linearY->setCheckable(true);
  m_linearY->setChecked(true);
  connect(m_sumDetectors, SIGNAL(triggered()), this, SLOT(sumDetectors()));
  connect(m_integrateTimeBins, SIGNAL(triggered()), this,
          SLOT(integrateTimeBins()));
  connect(m_logY, SIGNAL(triggered()), m_plot, SLOT(setYLogScale()));
  connect(m_linearY, SIGNAL(triggered()), m_plot, SLOT(setYLinearScale()));

  m_unitsMapper = new QSignalMapper(this);

  m_detidUnits = new QAction("Detector ID", this);
  m_detidUnits->setCheckable(true);
  m_unitsMapper->setMapping(m_detidUnits, DetectorPlotController::DETECTOR_ID);
  connect(m_detidUnits, SIGNAL(triggered()), m_unitsMapper, SLOT(map()));

  m_lengthUnits = new QAction("Tube length", this);
  m_lengthUnits->setCheckable(true);
  m_unitsMapper->setMapping(m_lengthUnits, DetectorPlotController::LENGTH);
  connect(m_lengthUnits, SIGNAL(triggered()), m_unitsMapper, SLOT(map()));

  m_phiUnits = new QAction("Phi", this);
  m_phiUnits->setCheckable(true);
  m_unitsMapper->setMapping(m_phiUnits, DetectorPlotController::PHI);
  connect(m_phiUnits, SIGNAL(triggered()), m_unitsMapper, SLOT(map()));

  m_outOfPlaneAngleUnits = new QAction("Out of plane angle", this);
  m_outOfPlaneAngleUnits->setCheckable(true);
  m_unitsMapper->setMapping(m_outOfPlaneAngleUnits,
                            DetectorPlotController::OUT_OF_PLANE_ANGLE);
  connect(m_outOfPlaneAngleUnits, SIGNAL(triggered()), m_unitsMapper,
          SLOT(map()));

  m_unitsGroup = new QActionGroup(this);
  m_unitsGroup->addAction(m_detidUnits);
  m_unitsGroup->addAction(m_lengthUnits);
  m_unitsGroup->addAction(
      m_phiUnits); // re #4169 disabled until fixed or removed
  m_unitsGroup->addAction(m_outOfPlaneAngleUnits);
  connect(m_unitsMapper, SIGNAL(mapped(int)), this, SLOT(setTubeXUnits(int)));

  // Instrument display context menu actions
  m_storeCurve = new QAction("Store curve", this);
  connect(m_storeCurve, SIGNAL(triggered()), this, SLOT(storeCurve()));
  m_savePlotToWorkspace = new QAction("Save plot to workspace", this);
  connect(m_savePlotToWorkspace, SIGNAL(triggered()), this,
          SLOT(savePlotToWorkspace()));

  CollapsibleStack *panelStack = new CollapsibleStack(this);
  m_infoPanel = panelStack->addPanel("Selection", m_selectionInfoDisplay);
  m_plotPanel = panelStack->addPanel("Name", m_plot);
  collapsePlotPanel();

  m_selectionType = Single;

  m_infoController = nullptr;
  m_plotController = nullptr;

  m_activeTool = new QLabel(this);
  // set up the tool bar

  m_zoom = new QPushButton();
  m_zoom->setCheckable(true);
  m_zoom->setAutoExclusive(true);
  m_zoom->setIcon(QIcon(":/PickTools/zoom.png"));
  m_zoom->setToolTip("Zoom in and out");

  m_one = new QPushButton();
  m_one->setCheckable(true);
  m_one->setAutoExclusive(true);
  m_one->setChecked(true);
  m_one->setToolTip("Select single pixel");
  m_one->setIcon(QIcon(":/PickTools/selection-pointer.png"));

  m_tube = new QPushButton();
  m_tube->setCheckable(true);
  m_tube->setAutoExclusive(true);
  m_tube->setIcon(QIcon(":/PickTools/selection-tube.png"));
  m_tube->setToolTip("Select whole tube");

  m_rectangle = new QPushButton();
  m_rectangle->setCheckable(true);
  m_rectangle->setAutoExclusive(true);
  m_rectangle->setIcon(QIcon(":/PickTools/selection-box.png"));
  m_rectangle->setToolTip("Draw a rectangle");

  m_ellipse = new QPushButton();
  m_ellipse->setCheckable(true);
  m_ellipse->setAutoExclusive(true);
  m_ellipse->setIcon(QIcon(":/PickTools/selection-circle.png"));
  m_ellipse->setToolTip("Draw a ellipse");

  m_ring_ellipse = new QPushButton();
  m_ring_ellipse->setCheckable(true);
  m_ring_ellipse->setAutoExclusive(true);
  m_ring_ellipse->setIcon(QIcon(":/PickTools/selection-circle-ring.png"));
  m_ring_ellipse->setToolTip("Draw an elliptical ring");

  m_ring_rectangle = new QPushButton();
  m_ring_rectangle->setCheckable(true);
  m_ring_rectangle->setAutoExclusive(true);
  m_ring_rectangle->setIcon(QIcon(":/PickTools/selection-box-ring.png"));
  m_ring_rectangle->setToolTip("Draw a rectangular ring");

  m_sector = new QPushButton();
  m_sector->setCheckable(true);
  m_sector->setAutoExclusive(true);
  m_sector->setIcon(QIcon(":/PickTools/selection-sector.png"));
  m_sector->setToolTip("Draw a circular sector");

  m_free_draw = new QPushButton();
  m_free_draw->setCheckable(true);
  m_free_draw->setAutoExclusive(true);
  m_free_draw->setIcon(QIcon(":/PickTools/brush.png"));
  m_free_draw->setToolTip("Draw an arbitrary shape");

  m_edit = new QPushButton();
  m_edit->setCheckable(true);
  m_edit->setAutoExclusive(true);
  m_edit->setIcon(QIcon(":/PickTools/selection-edit.png"));
  m_edit->setToolTip("Edit a shape");

  m_peak = new QPushButton();
  m_peak->setCheckable(true);
  m_peak->setAutoExclusive(true);
  m_peak->setIcon(QIcon(":/PickTools/selection-peak.png"));
  m_peak->setToolTip("Add single crystal peak");

  m_peakSelect = new QPushButton();
  m_peakSelect->setCheckable(true);
  m_peakSelect->setAutoExclusive(true);
  m_peakSelect->setIcon(QIcon(":/PickTools/eraser.png"));
  m_peakSelect->setToolTip("Erase single crystal peak(s)");

  m_peakCompare = new QPushButton();
  m_peakCompare->setCheckable(true);
  m_peakCompare->setAutoExclusive(true);
  m_peakCompare->setIcon(QIcon(":/PickTools/selection-peak-compare.png"));
  m_peakCompare->setToolTip("Compare single crystal peak(s)");

  m_peakAlign = new QPushButton();
  m_peakAlign->setCheckable(true);
  m_peakAlign->setAutoExclusive(true);
  m_peakAlign->setIcon(QIcon(":/PickTools/selection-peak-plane.png"));
  m_peakAlign->setToolTip("Crystal peak alignment tool");

  auto *toolBox = new QGridLayout();
  toolBox->addWidget(m_zoom, 0, 0);
  toolBox->addWidget(m_edit, 0, 1);
  toolBox->addWidget(m_ellipse, 0, 2);
  toolBox->addWidget(m_rectangle, 0, 3);
  toolBox->addWidget(m_ring_ellipse, 0, 4);
  toolBox->addWidget(m_ring_rectangle, 0, 5);
  toolBox->addWidget(m_sector, 0, 6);
  toolBox->addWidget(m_free_draw, 0, 7);
  toolBox->addWidget(m_one, 1, 0);
  toolBox->addWidget(m_tube, 1, 1);
  toolBox->addWidget(m_peak, 1, 2);
  toolBox->addWidget(m_peakSelect, 1, 3);
  toolBox->addWidget(m_peakCompare, 1, 4);
  toolBox->addWidget(m_peakAlign, 1, 5);
  toolBox->setColumnStretch(8, 1);
  toolBox->setSpacing(2);
  connect(m_zoom, SIGNAL(clicked()), this, SLOT(setSelectionType()));
  connect(m_one, SIGNAL(clicked()), this, SLOT(setSelectionType()));
  connect(m_tube, SIGNAL(clicked()), this, SLOT(setSelectionType()));
  connect(m_peak, SIGNAL(clicked()), this, SLOT(setSelectionType()));
  connect(m_peakSelect, SIGNAL(clicked()), this, SLOT(setSelectionType()));
  connect(m_peakCompare, SIGNAL(clicked()), this, SLOT(setSelectionType()));
  connect(m_peakAlign, SIGNAL(clicked()), this, SLOT(setSelectionType()));
  connect(m_rectangle, SIGNAL(clicked()), this, SLOT(setSelectionType()));
  connect(m_ellipse, SIGNAL(clicked()), this, SLOT(setSelectionType()));
  connect(m_ring_ellipse, SIGNAL(clicked()), this, SLOT(setSelectionType()));
  connect(m_ring_rectangle, SIGNAL(clicked()), this, SLOT(setSelectionType()));
  connect(m_sector, SIGNAL(clicked()), this, SLOT(setSelectionType()));
  connect(m_free_draw, SIGNAL(clicked()), this, SLOT(setSelectionType()));
  connect(m_edit, SIGNAL(clicked()), this, SLOT(setSelectionType()));

  // lay out the widgets
  layout->addWidget(m_activeTool);
  layout->addLayout(toolBox);
  layout->addWidget(panelStack);
}

/**
 * If the workspace is monochromatic, the plot panel is useless and should be
 * collapsed
 */
void InstrumentWidgetPickTab::collapsePlotPanel() {
  if (!m_instrWidget->isIntegrable()) {
    m_plotPanel->collapseCaption();
  } else
    m_plotPanel->expandCaption();
}

/**
 * Returns true if the plot can be updated when the mouse moves over detectors
 */
bool InstrumentWidgetPickTab::canUpdateTouchedDetector() const {
  return !m_peak->isChecked();
}

/**
 * Display the miniplot's context menu.
 */
void InstrumentWidgetPickTab::plotContextMenu() {
  QMenu context(m_plot);

  auto plotType = m_plotController->getPlotType();

  if (plotType == DetectorPlotController::TubeSum ||
      plotType == DetectorPlotController::TubeIntegral) {
    // only for multiple detector selectors
    context.addActions(m_summationType->actions());
    m_sumDetectors->setChecked(plotType == DetectorPlotController::TubeSum);
    m_integrateTimeBins->setChecked(plotType !=
                                    DetectorPlotController::TubeSum);
    m_integrateTimeBins->setEnabled(true);
    context.addSeparator();
  }

  if (m_plot->hasStored()) {
    // the remove menu
    QMenu *removeCurves = new QMenu("Remove", this);
    QSignalMapper *signalMapper = new QSignalMapper(this);
    QStringList labels = m_plot->getLabels();
    foreach (QString label, labels) {
      QColor c = m_plot->getCurveColor(label);
      QPixmap pixmap(16, 2);
      pixmap.fill(c);
      QAction *remove = new QAction(QIcon(pixmap), label, removeCurves);
      removeCurves->addAction(remove);
      connect(remove, SIGNAL(triggered()), signalMapper, SLOT(map()));
      signalMapper->setMapping(remove, label);
    }
    connect(signalMapper, SIGNAL(mapped(const QString &)), this,
            SLOT(removeCurve(const QString &)));
    context.addMenu(removeCurves);
  }

  // the axes menu
  QMenu *axes = new QMenu("Axes", this);
  axes->addActions(m_yScale->actions());
  if (m_plot->isYLogScale()) {
    m_logY->setChecked(true);
  } else {
    m_linearY->setChecked(true);
  }

  // Tube x units menu options
  if (plotType == DetectorPlotController::TubeIntegral) {
    axes->addSeparator();
    axes->addActions(m_unitsGroup->actions());
    auto tubeXUnits = m_plotController->getTubeXUnits();
    switch (tubeXUnits) {
    case DetectorPlotController::DETECTOR_ID:
      m_detidUnits->setChecked(true);
      break;
    case DetectorPlotController::LENGTH:
      m_lengthUnits->setChecked(true);
      break;
    case DetectorPlotController::PHI:
      m_phiUnits->setChecked(true);
      break;
    case DetectorPlotController::OUT_OF_PLANE_ANGLE:
      m_outOfPlaneAngleUnits->setChecked(true);
      break;
    default:
      m_detidUnits->setChecked(true);
    }
  }
  context.addMenu(axes);

  // save plot to workspace
  if (m_plot->hasStored() || m_plot->hasCurve()) {
    context.addAction(m_savePlotToWorkspace);
  }

  // show menu
  context.exec(QCursor::pos());
}

/**
 * Update the plot caption. The captions shows the selection type.
 */
void InstrumentWidgetPickTab::setPlotCaption() {
  m_plotPanel->setCaption(m_plotController->getPlotCaption());
}

/**
 * Switch to the detectors summing regime.
 */
void InstrumentWidgetPickTab::sumDetectors() {
  m_plotController->setPlotType(DetectorPlotController::TubeSum);
  m_plotController->updatePlot();
  setPlotCaption();
}

/**
 * Switch to the time bin integration regime.
 */
void InstrumentWidgetPickTab::integrateTimeBins() {
  m_plotController->setPlotType(DetectorPlotController::TubeIntegral);
  m_plotController->updatePlot();
  setPlotCaption();
}

/**
 * Set the selection type according to which tool button is checked.
 */
void InstrumentWidgetPickTab::setSelectionType() {
  ProjectionSurface::InteractionMode surfaceMode =
      ProjectionSurface::PickSingleMode;
  auto plotType = m_plotController->getPlotType();
  if (m_zoom->isChecked()) {
    m_selectionType = Single;
    m_activeTool->setText("Tool: Navigation");
    surfaceMode = ProjectionSurface::MoveMode;
  } else if (m_one->isChecked()) {
    m_selectionType = Single;
    m_activeTool->setText("Tool: Pixel selection");
    surfaceMode = ProjectionSurface::PickSingleMode;
    plotType = DetectorPlotController::Single;
  } else if (m_tube->isChecked()) {
    m_selectionType = Tube;
    m_activeTool->setText("Tool: Tube/bank selection");
    surfaceMode = ProjectionSurface::PickTubeMode;
    if (plotType < DetectorPlotController::TubeSum) {
      plotType = DetectorPlotController::TubeSum;
    }
  } else if (m_peak->isChecked()) {
    m_selectionType = AddPeak;
    m_activeTool->setText("Tool: Add a single crystal peak");
    surfaceMode = ProjectionSurface::AddPeakMode;
    plotType = DetectorPlotController::Single;
  } else if (m_peakSelect->isChecked()) {
    m_selectionType = ErasePeak;
    m_activeTool->setText("Tool: Erase crystal peak(s)");
    surfaceMode = ProjectionSurface::ErasePeakMode;
  } else if (m_peakCompare->isChecked()) {
    m_selectionType = ComparePeak;
    m_activeTool->setText("Tool: Compare crystal peak(s)");
    surfaceMode = ProjectionSurface::ComparePeakMode;
  } else if (m_peakAlign->isChecked()) {
    m_selectionType = AlignPeak;
    m_activeTool->setText("Tool: Align crystal peak(s)");
    surfaceMode = ProjectionSurface::AlignPeakMode;
  } else if (m_rectangle->isChecked()) {
    m_selectionType = Draw;
    m_activeTool->setText("Tool: Rectangle");
    surfaceMode = ProjectionSurface::DrawRegularMode;
    plotType = DetectorPlotController::Single;
    m_instrWidget->getSurface()->startCreatingShape2D(
        "rectangle", Qt::green, QColor(255, 255, 255, 80));
  } else if (m_ellipse->isChecked()) {
    m_selectionType = Draw;
    m_activeTool->setText("Tool: Ellipse");
    surfaceMode = ProjectionSurface::DrawRegularMode;
    plotType = DetectorPlotController::Single;
    m_instrWidget->getSurface()->startCreatingShape2D(
        "ellipse", Qt::green, QColor(255, 255, 255, 80));
  } else if (m_ring_ellipse->isChecked()) {
    m_selectionType = Draw;
    m_activeTool->setText("Tool: Elliptical ring");
    surfaceMode = ProjectionSurface::DrawRegularMode;
    plotType = DetectorPlotController::Single;
    m_instrWidget->getSurface()->startCreatingShape2D(
        "ring ellipse", Qt::green, QColor(255, 255, 255, 80));
  } else if (m_ring_rectangle->isChecked()) {
    m_selectionType = Draw;
    m_activeTool->setText("Tool: Rectangular ring");
    surfaceMode = ProjectionSurface::DrawRegularMode;
    plotType = DetectorPlotController::Single;
    m_instrWidget->getSurface()->startCreatingShape2D(
        "ring rectangle", Qt::green, QColor(255, 255, 255, 80));
  } else if (m_sector->isChecked()) {
    m_selectionType = Draw;
    m_activeTool->setText("Tool: Circular sector");
    surfaceMode = ProjectionSurface::DrawRegularMode;
    plotType = DetectorPlotController::Single;
    m_instrWidget->getSurface()->startCreatingShape2D(
        "sector", Qt::green, QColor(255, 255, 255, 80));
  } else if (m_free_draw->isChecked()) {
    m_selectionType = Draw;
    m_activeTool->setText("Tool: Arbitrary shape");
    surfaceMode = ProjectionSurface::DrawFreeMode;
    plotType = DetectorPlotController::Single;
    m_instrWidget->getSurface()->startCreatingFreeShape(
        Qt::green, QColor(255, 255, 255, 80));
  } else if (m_edit->isChecked()) {
    m_selectionType = Draw;
    m_activeTool->setText("Tool: Shape editing");
    surfaceMode = ProjectionSurface::DrawRegularMode;
    plotType = DetectorPlotController::Single;
  }
  m_plotController->setPlotType(plotType);
  auto surface = m_instrWidget->getSurface();
  if (surface) {
    surface->setInteractionMode(surfaceMode);
    auto interactionMode = surface->getInteractionMode();
    if (interactionMode == ProjectionSurface::DrawRegularMode ||
        interactionMode == ProjectionSurface::MoveMode) {
      updatePlotMultipleDetectors();
    } else {
      m_plot->clearAll();
      m_plot->replot();
    }
    setPlotCaption();
  }
  m_instrWidget->updateInfoText();
}

/**
 * Respond to the show event.
 */
void InstrumentWidgetPickTab::showEvent(QShowEvent * /*unused*/) {
  // Make the state of the display view consistent with the current selection
  // type
  setSelectionType();
  // make sure picking updated
  m_instrWidget->updateInstrumentView(true);
  m_instrWidget->getSurface()->changeBorderColor(getShapeBorderColor());
}

/**
 * Keep current curve permanently displayed on the plot.
 */
void InstrumentWidgetPickTab::storeCurve() { m_plot->store(); }

/**
 * Remove a stored curve.
 * @param label :: The label of the curve to remove
 */
void InstrumentWidgetPickTab::removeCurve(const QString &label) {
  m_plot->removeCurve(label);
  m_plot->replot();
}

/**
 * Set the x units for the integrated tube plot.
 * @param units :: The x units in terms of TubeXUnits.
 */
void InstrumentWidgetPickTab::setTubeXUnits(int units) {
  if (units < 0 || units >= DetectorPlotController::NUMBER_OF_UNITS)
    return;
  auto tubeXUnits = static_cast<DetectorPlotController::TubeXUnits>(units);
  m_plotController->setTubeXUnits(tubeXUnits);
  m_plotController->updatePlot();
}

/**
 * Get the color of the overlay shapes in this tab.
 * @return
 */
QColor InstrumentWidgetPickTab::getShapeBorderColor() const {
  return QColor(Qt::green);
}

/**
 * Do something when the time bin integration range has changed.
 */
void InstrumentWidgetPickTab::changedIntegrationRange(double /*unused*/,
                                                      double /*unused*/) {
  m_plotController->updatePlot();
  auto surface = m_instrWidget->getSurface();
  if (surface) {
    auto interactionMode = surface->getInteractionMode();
    if (interactionMode == ProjectionSurface::DrawRegularMode ||
        interactionMode == ProjectionSurface::MoveMode) {
      updatePlotMultipleDetectors();
    }
  }
}

void InstrumentWidgetPickTab::initSurface() {
  ProjectionSurface *surface = getSurface().get();
  connect(surface, SIGNAL(singleComponentTouched(size_t)), this,
          SLOT(singleComponentTouched(size_t)));
  connect(surface, SIGNAL(singleComponentPicked(size_t)), this,
          SLOT(singleComponentPicked(size_t)));
  connect(surface,
          SIGNAL(comparePeaks(
              const std::pair<std::vector<Mantid::Geometry::IPeak *>,
                              std::vector<Mantid::Geometry::IPeak *>> &)),
          this,
          SLOT(comparePeaks(
              const std::pair<std::vector<Mantid::Geometry::IPeak *>,
                              std::vector<Mantid::Geometry::IPeak *>> &)));
  connect(surface,
          SIGNAL(alignPeaks(const std::vector<Mantid::Kernel::V3D> &,
                            const Mantid::Geometry::IPeak *)),
          this,
          SLOT(alignPeaks(const std::vector<Mantid::Kernel::V3D>,
                          const Mantid::Geometry::IPeak *)));
  connect(surface, SIGNAL(peaksWorkspaceAdded()), this,
          SLOT(updateSelectionInfoDisplay()));
  connect(surface, SIGNAL(peaksWorkspaceDeleted()), this,
          SLOT(updateSelectionInfoDisplay()));
  connect(surface, SIGNAL(shapeCreated()), this, SLOT(shapeCreated()));
  connect(surface, SIGNAL(shapeChangeFinished()), this,
          SLOT(updatePlotMultipleDetectors()));
  connect(surface, SIGNAL(shapesCleared()), this,
          SLOT(updatePlotMultipleDetectors()));
  connect(surface, SIGNAL(shapesRemoved()), this,
          SLOT(updatePlotMultipleDetectors()));
  auto *p3d = dynamic_cast<Projection3D *>(surface);
  if (p3d) {
    connect(p3d, SIGNAL(finishedMove()), this,
            SLOT(updatePlotMultipleDetectors()));
  }
  m_infoController =
      new ComponentInfoController(this, m_instrWidget, m_selectionInfoDisplay);
  m_plotController = new DetectorPlotController(this, m_instrWidget, m_plot);
  m_plotController->setTubeXUnits(
      static_cast<DetectorPlotController::TubeXUnits>(m_tubeXUnitsCache));
  m_plotController->setPlotType(
      static_cast<DetectorPlotController::PlotType>(m_plotTypeCache));
  // miniplot X unit
  const auto &actor = m_instrWidget->getInstrumentActor();
  // default X axis label
  m_plot->setXLabel(QString::fromStdString(
      actor.getWorkspace()->getAxis(0)->unit()->unitID()));
}

/**
 * Return current ProjectionSurface.
 */
std::shared_ptr<ProjectionSurface> InstrumentWidgetPickTab::getSurface() const {
  return m_instrWidget->getSurface();
}

const InstrumentWidget *InstrumentWidgetPickTab::getInstrumentWidget() const {
  return m_instrWidget;
}

/**
 * Save tab's persistent settings to the provided QSettings instance
 */
void InstrumentWidgetPickTab::saveSettings(QSettings &settings) const {
  settings.setValue("TubeXUnits", m_plotController->getTubeXUnits());
  settings.setValue("PlotType", m_plotController->getPlotType());
}

/**
 * Restore (read and apply) tab's persistent settings from the provided
 * QSettings instance
 */
void InstrumentWidgetPickTab::loadSettings(const QSettings &settings) {
  // loadSettings is called when m_plotController is not created yet.
  // Cache the settings and apply them later
  m_tubeXUnitsCache = settings.value("TubeXUnits", 0).toInt();
  m_plotTypeCache =
      settings.value("PlotType", DetectorPlotController::Single).toInt();
}
void InstrumentWidgetPickTab::addToContextMenu(
    QAction *action,
    std::function<bool(std::map<std::string, bool>)> &actionCondition) {
  auto pair = std::make_pair(action, actionCondition);
  m_addedActions.emplace_back(pair);
}
/**
 * Fill in the context menu.
 * @param context :: A menu to fill.
 */
bool InstrumentWidgetPickTab::addToDisplayContextMenu(QMenu &context) const {
  m_freezePlot = true;
  bool res = false;
  if (m_plot->hasCurve()) {
    context.addAction(m_storeCurve);
    res = true;
  }
  if (m_plot->hasStored() || m_plot->hasCurve()) {
    context.addAction(m_savePlotToWorkspace);
    res = true;
  }
  std::map<std::string, bool> tabBools = {};
  tabBools.insert(std::make_pair("plotStored", m_plot->hasStored()));
  tabBools.insert(std::make_pair("hasCurve", m_plot->hasCurve()));
  tabBools.insert(std::make_pair("isTube", m_tube->isChecked()));
  for (auto actionPair : m_addedActions) {
    if (actionPair.second && actionPair.second(tabBools)) {
      context.addAction(actionPair.first);
    }
  }
  return res;
}

/**
 * Select a tool on the tab
 * @param tool One of the enumerated tool types, @see ToolType
 */
void InstrumentWidgetPickTab::selectTool(const ToolType tool) {
  switch (tool) {
  case Zoom:
    m_zoom->setChecked(true);
    break;
  case PixelSelect:
    m_one->setChecked(true);
    break;
  case TubeSelect:
    m_tube->setChecked(true);
    break;
  case PeakSelect:
    m_peak->setChecked(true);
    break;
  case PeakCompare:
    m_peakCompare->setChecked(true);
  case PeakErase:
    m_peakSelect->setChecked(true);
    break;
  case DrawRectangle:
    m_rectangle->setChecked(true);
    break;
  case DrawEllipse:
    m_ellipse->setChecked(true);
    break;
  case DrawFree:
    m_free_draw->setChecked(true);
    break;
  case EditShape:
    m_edit->setChecked(true);
    break;
  default:
    throw std::invalid_argument("Invalid tool type.");
  }
  setSelectionType();
}

void InstrumentWidgetPickTab::singleComponentTouched(size_t pickID) {
  if (canUpdateTouchedDetector()) {
    m_infoController->displayInfo(pickID);
    m_plotController->setPlotData(pickID);
    m_plotController->updatePlot();
  }
}

void InstrumentWidgetPickTab::singleComponentPicked(size_t pickID) {
  m_infoController->displayInfo(pickID);
  m_plotController->setPlotData(pickID);
  m_plotController->zoomOutOnPlot();
  m_plotController->updatePlot();
}

void InstrumentWidgetPickTab::comparePeaks(
    const std::pair<std::vector<Mantid::Geometry::IPeak *>,
                    std::vector<Mantid::Geometry::IPeak *>> &peaks) {
  m_infoController->displayComparePeaksInfo(peaks);
}

void InstrumentWidgetPickTab::alignPeaks(
    const std::vector<Mantid::Kernel::V3D> &planePeaks,
    const Mantid::Geometry::IPeak *peak) {
  m_infoController->displayAlignPeaksInfo(planePeaks, peak);
}

/**
 * Update the selection display using currently selected detector.
 * Updates non-detector information on it.
 */
void InstrumentWidgetPickTab::updateSelectionInfoDisplay() {
  // updateSelectionInfo(m_currentDetID);
}

/**
 * Respond to the shapeCreated signal from the surface.
 */
void InstrumentWidgetPickTab::shapeCreated() {
  if (!isVisible())
    return;
  if (!m_free_draw->isChecked()) {
    selectTool(EditShape);
  }
}

/**
 * Update the mini-plot with information from multiple detector
 * selected with drawn shapes.
 */
void InstrumentWidgetPickTab::updatePlotMultipleDetectors() {
  if (!isVisible())
    return;
  ProjectionSurface &surface = *getSurface();
  if (surface.hasMasks()) {
    std::vector<size_t> dets;
    surface.getMaskedDetectors(dets);
    m_plotController->setPlotData(dets);
  } else {
    m_plotController->clear();
  }
  m_plot->replot();
}

/**
 * Clear all the tab's widgets.
 */
void InstrumentWidgetPickTab::clearWidgets() {
  m_plotController->clear();
  m_infoController->clear();
  selectTool(ToolType::PixelSelect);
  collapsePlotPanel();
}

/**
 * Save data plotted on the miniplot into a MatrixWorkspace.
 */
void InstrumentWidgetPickTab::savePlotToWorkspace() {
  m_plotController->savePlotToWorkspace();
}

/** Load pick tab state from a Mantid project file
 * @param lines :: lines from the project file to load state from
 */
void InstrumentWidgetPickTab::loadFromProject(const std::string &lines) {
#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
  API::TSVSerialiser tsv(lines);

  if (!tsv.selectSection("picktab"))
    return;

  std::string tabLines;
  tsv >> tabLines;
  API::TSVSerialiser tab(tabLines);

  // load active push button
  std::vector<QPushButton *> buttons{
      m_zoom,         m_edit,           m_ellipse,   m_rectangle,
      m_ring_ellipse, m_ring_rectangle, m_free_draw, m_one,
      m_tube,         m_peak,           m_peakSelect};

  tab.selectLine("ActiveTools");
  for (auto button : buttons) {
    bool value;
    tab >> value;
    button->setChecked(value);
  }
#else
  Q_UNUSED(lines);
  throw std::runtime_error(
      "MaskBinsData::loadFromProject() not implemented for Qt >= 5");
#endif
}

/** Save the state of the pick tab to a Mantid project file
 * @return a string representing the state of the pick tab
 */
std::string InstrumentWidgetPickTab::saveToProject() const {
#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
  API::TSVSerialiser tsv, tab;

  // save active push button
  std::vector<QPushButton *> buttons{
      m_zoom,         m_edit,           m_ellipse,   m_rectangle,
      m_ring_ellipse, m_ring_rectangle, m_free_draw, m_one,
      m_tube,         m_peak,           m_peakSelect};

  tab.writeLine("ActiveTools");
  for (auto button : buttons) {
    tab << button->isChecked();
  }

  tsv.writeSection("picktab", tab.outputLines());
  return tsv.outputLines();
#else
  throw std::runtime_error(
      "MaskBinsData::saveToProject() not implemented for Qt >= 5");
#endif
}

//=====================================================================================//

/**
 * Create and setup iteself.
 * @param tab :: QObject parent - the tab.
 * @param instrWidget :: A pointer to an InstrumentWidget instance.
 * @param infoDisplay :: Widget on which to display the information.
 */
ComponentInfoController::ComponentInfoController(
    InstrumentWidgetPickTab *tab, const InstrumentWidget *instrWidget,
    QTextEdit *infoDisplay)
    : QObject(tab), m_tab(tab), m_instrWidget(instrWidget),
      m_selectionInfoDisplay(infoDisplay), m_freezePlot(false),
      m_instrWidgetBlocked(false),
      m_currentPickID(std::numeric_limits<size_t>::max()) {}

/**
 * Display info on a component refered to by a pick ID.
 * @param pickID :: A pick ID of a component.
 */
void ComponentInfoController::displayInfo(size_t pickID) {
  if (m_freezePlot) { // freeze the plot for one update
    m_freezePlot = false;
    pickID = m_currentPickID;
  }

  const auto &actor = m_instrWidget->getInstrumentActor();
  const auto &componentInfo = actor.componentInfo();
  QString text = "";
  if (componentInfo.isDetector(pickID)) {
    text += displayDetectorInfo(pickID);
  } else if (auto componentID = actor.getComponentID(pickID)) {
    text += displayNonDetectorInfo(componentID);
  } else {
    clear();
  }
  // display info about peak overlays
  text += getPeakOverlayInfo();

  if (!text.isEmpty()) {
    m_selectionInfoDisplay->setText(text);
  } else {
    clear();
  }
}

/**
 * Return string with info on a detector.
 * @param index :: A detector Index.
 */
QString ComponentInfoController::displayDetectorInfo(size_t index) {
  if (m_instrWidgetBlocked) {
    clear();
    return "";
  }

  QString text;

  // collect info about selected detector and add it to text
  const auto &actor = m_instrWidget->getInstrumentActor();
  const auto &componentInfo = actor.componentInfo();
  auto detid = actor.getDetID(index);

  text = "Selected detector: " +
         QString::fromStdString(componentInfo.name(index)) + "\n";
  text += "Detector ID: " + QString::number(detid) + '\n';
  QString wsIndex;
  auto ws = actor.getWorkspaceIndex(index);
  wsIndex = ws == InstrumentActor::INVALID_INDEX ? "None" : QString::number(ws);
  text += "Workspace index: " + wsIndex + '\n';
  Mantid::Kernel::V3D pos = componentInfo.position(index);
  text += "xyz: " + QString::number(pos.X()) + "," + QString::number(pos.Y()) +
          "," + QString::number(pos.Z()) + '\n';
  double r, t, p;
  pos.getSpherical(r, t, p);
  text += "rtp: " + QString::number(r) + "," + QString::number(t) + "," +
          QString::number(p) + '\n';
  if (componentInfo.hasParent(index)) {
    QString textpath;
    auto parent = index;
    while (componentInfo.hasParent(parent)) {
      parent = componentInfo.parent(parent);
      textpath =
          "/" + QString::fromStdString(componentInfo.name(parent)) + textpath;
    }
    text += "Component path:" + textpath + "/" +
            QString::fromStdString(componentInfo.name(index)) + '\n';

    const double integrated = actor.getIntegratedCounts(index);
    const QString counts = integrated == InstrumentActor::INVALID_VALUE
                               ? "N/A"
                               : QString::number(integrated);
    text += "Counts: " + counts + '\n';
    // display info about peak overlays
    text += actor.getParameterInfo(index);
  }
  return text;
}

/**
 * string with information about a selected non-detector component (such as
 * choppers, etc).
 * @param compID :: A component ID for a component to display.
 */
QString ComponentInfoController::displayNonDetectorInfo(
    Mantid::Geometry::ComponentID compID) {
  const auto &actor = m_instrWidget->getInstrumentActor();
  const auto &componentInfo = actor.componentInfo();
  auto component = componentInfo.indexOf(compID);
  QString text = "Selected component: ";
  text += QString::fromStdString(componentInfo.name(component)) + '\n';
  Mantid::Kernel::V3D pos = componentInfo.position(component);
  text += "xyz: " + QString::number(pos.X()) + "," + QString::number(pos.Y()) +
          "," + QString::number(pos.Z()) + '\n';
  double r, t, p;
  pos.getSpherical(r, t, p);