MatrixOptions.cpp

#include "MatrixOptions.h"
 
#include <QColor>
#include <QString>
#include <QList>
 
#include "CorrelationMatrix.h"
#include "MatrixSceneWidget.h"
#include "MatrixOptionsDialog.h"
 
namespace Isis {
  MatrixOptions::MatrixOptions(CorrelationMatrix parent, MatrixSceneWidget *scene) { // give parent? MatrixSceneWidget
      m_parentMatrix = new CorrelationMatrix(parent);
      //Color Options
      m_tolerance = false; // if tolerance is false then we use gradient
      m_goodColor = Qt::cyan;
      m_badColor = Qt::magenta;
      m_colorTolerance = 0.2;
 
      // Focus Options
      m_focusOption = MatrixOptions::Tolerance;
 
      // Specific Parameters
      m_image1 = "Specific Img1";
      m_parameter1 = "Specific Param1";
      m_image2 = "Specific Img2";
      m_parameter2 = "Specific Param2";
//       m_imagesAndParameters = parentMatrix->imagesAndParameters(); // pointer the the one in correlation matrix?
 
      // Tolerance
      m_focusTolSelectedElement = 1.0;
      m_goodElements = QList<double>();
      m_badElements = QList<double>();
 
      for (int i = 0; i < 10; i++) {
        m_goodElements.append(i);
        m_badElements.append(i + 10);
      }
 
      // Current Correlation Information
      m_currentValue = 0.0;
      m_currentImg1 = "Current Image 1";
      m_currentParam1 = "Current Parameter 1";
      m_currentImg2 = "Current Image 2";
      m_currentParam2 = "Current Parameter 2";
 
      MatrixOptionsDialog *optionsDialog = new MatrixOptionsDialog(this, scene);
      optionsDialog->setAttribute(Qt::WA_DeleteOnClose);
      optionsDialog->show();
 
      connect(optionsDialog, SIGNAL( optionsUpdated() ),
              this, SIGNAL( optionsUpdated() ) );
  }
 
 
 
//   MatrixOptions::MatrixOptions(CorrelationMatrix *parent) { // give parent? MatrixSceneWidget
//   }
 
 
 
  MatrixOptions::~MatrixOptions() {
  }
 
 
  
  // Color Options
  QColor MatrixOptions::goodCorrelationColor() {
    return m_goodColor;
  }
 
 
 
  QColor MatrixOptions::badCorrelationColor() {
    return m_badColor;
  }
 
 
 
  double MatrixOptions::colorTolerance() {
    return m_colorTolerance;
  }
 
 
  
  bool MatrixOptions::colorScheme() {
    return m_tolerance; // if tolerance is false then we use gradient
  }
 
 
 
  void MatrixOptions::setColorScheme(bool tolerance) {
    m_tolerance = tolerance;
  }
 
 
 
  void MatrixOptions::setColorTolerance(double tolerance) {
    m_colorTolerance = tolerance;
  }
 
 
 
  void MatrixOptions::setGoodCorrelationColor(QColor color) {
    m_goodColor = color;
  }
 
 
 
  void MatrixOptions::setBadCorrelationColor(QColor color) {
    m_badColor = color;
  }
 
  
  // Focus Options
  MatrixOptions::FocusOption MatrixOptions::focusOption() {
    return m_focusOption;
  }
 
 
  
  double MatrixOptions::focusValue() {
    return m_focusTolSelectedElement;
  } // best, worst, the one selected from tolerance?
 
 
 
  QString MatrixOptions::focusImage1() {
    return m_image1;
  }
 
 
 
  QString MatrixOptions::focusParameter1() {
    return m_parameter1;
  }
 
 
 
  QString MatrixOptions::focusImage2() {
    return m_image2;
  }
 
 
 
  QString MatrixOptions::focusParameter2() {
    return m_parameter2;
  }
 
 
 
  QList<double> MatrixOptions::goodElements() {
    return m_badElements;
  }
 
 
 
  QList<double> MatrixOptions::badElements() {
    return m_goodElements;
  }
 
 
 
  void MatrixOptions::setFocusOption(FocusOption option) {
    m_focusOption = option;
  }
 
 
 
  void MatrixOptions::setFocusValue(double value) {
    m_focusTolSelectedElement = value;
  }
 
  
  
  void MatrixOptions::setGoodElements(QList<double> goodElements) {
    m_goodElements = goodElements;
  }
 
 
 
  void MatrixOptions::setBadElements(QList<double> badElements) {
    m_badElements = badElements;
  }
 
  
 
  // Current Correlation Information
 
 
 
  double MatrixOptions::currentCorrelation() {
    return m_currentValue;
  }
 
 
 
  QString MatrixOptions::currentImage1() {
    return m_currentImg1;
  }
 
 
 
  QString MatrixOptions::currentParameter1() {
    return m_currentParam1;
  }
 
 
 
  QString MatrixOptions::currentImage2() {
    return m_currentImg2;
  }
 
 
 
  QString MatrixOptions::currentParameter2() {
    return m_currentParam2;
  }
 
 
  
  void MatrixOptions::setCurrentCorrelation(double value) {
    m_currentValue = value;
  }
 
 
 
  void MatrixOptions::setCurrentImage1(QString current) {
    m_currentImg1 = current;
  }
 
 
 
  void MatrixOptions::setCurrentParameter1(QString current) {
    m_currentParam1= current;
  }
 
 
 
  void MatrixOptions::setCurrentImage2(QString current) {
    m_currentImg2 = current;
  }
 
 
 
  void MatrixOptions::setCurrentParameter2(QString current) {
    m_currentParam2 = current;
  }
 
 
 
  //Slots 
//   void MatrixOptions::updateCurrentCorrData(QString currentData) {
//     // update "current" values
//     emit changedCurrentCorrData();
//   }
 
 
 
  QMap< QString, QStringList> MatrixOptions::matrixImgsAndParams() {
    return *m_parentMatrix->imagesAndParameters();
  }
 
 
 
  CorrelationMatrix *MatrixOptions::parentMatrix() {
    return m_parentMatrix;
  }
};