AdvancedStretchDialog.cpp

#include "AdvancedStretchDialog.h"
 
#include <QHBoxLayout>
#include <QString>
#include <QPushButton>
 
#include "CubeViewport.h"
#include "Stretch.h"
#include "CubeStretch.h"
#include "AdvancedStretch.h"
 
namespace Isis {
  AdvancedStretchDialog::AdvancedStretchDialog(QWidget *parent) :
    QDialog(parent) {
    p_grayStretch = NULL;
    p_redStretch = NULL;
    p_grnStretch = NULL;
    p_bluStretch = NULL;
    p_enabled = false;
 
    setWindowTitle("Advanced Stretch Tool");
 
    QVBoxLayout *layout = new QVBoxLayout();
    
    setLayout(layout);
  }
 
 
  AdvancedStretchDialog::~AdvancedStretchDialog() {
    destroyCurrentStretches();
  }
 
 
  void AdvancedStretchDialog::enableRgbMode(Stretch &redStretch,
      Histogram &redHist,
      Stretch &grnStretch, Histogram &grnHist,
      Stretch &bluStretch, Histogram &bluHist) {
    destroyCurrentStretches();
 
    QHBoxLayout* rgbLayout = new QHBoxLayout();
 
    p_redStretch = new AdvancedStretch(redHist, redStretch,
                                       "Red", QColor(Qt::red));
    rgbLayout->addWidget(p_redStretch);
 
    p_grnStretch = new AdvancedStretch(grnHist, grnStretch,
                                       "Green", QColor(Qt::green));
    rgbLayout->addWidget(p_grnStretch);
 
    p_bluStretch = new AdvancedStretch(bluHist, bluStretch,
                                       "Blue", QColor(Qt::blue));
    rgbLayout->addWidget(p_bluStretch);
 
    ((QVBoxLayout*)layout())->addLayout(rgbLayout);
 
    QFrame* line = new QFrame();
    line->setFrameShape(QFrame::HLine);
    line->setFrameShadow(QFrame::Sunken);
    ((QVBoxLayout*)layout())->addWidget(line);
 
    updateGeometry();
 
    connect(p_redStretch, SIGNAL(stretchChanged()),
            this, SIGNAL(stretchChanged()));
    connect(p_grnStretch, SIGNAL(stretchChanged()),
            this, SIGNAL(stretchChanged()));
    connect(p_bluStretch, SIGNAL(stretchChanged()),
            this, SIGNAL(stretchChanged()));
 
    // Add buttons for save/load/delete stretch to RGB stretches
    QPushButton *saveToCubeButton = new QPushButton("Save Stretch Pairs to Cube..."); 
    saveToCubeButton->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
    connect(saveToCubeButton, SIGNAL(clicked(bool)), this, SIGNAL(saveToCube()));
 
    QPushButton *deleteFromCubeButton = new QPushButton("Delete Stretch Pairs from Cube...");
    deleteFromCubeButton->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
    connect(deleteFromCubeButton, SIGNAL(clicked(bool)), this, SIGNAL(deleteFromCube()));
 
    QPushButton *loadStretchButton = new QPushButton("Restore Saved Stretch from Cube...");
    loadStretchButton->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
    connect(loadStretchButton, SIGNAL(clicked(bool)), this, SIGNAL(loadStretch()));
 
    QHBoxLayout* buttonLayout = new QHBoxLayout();
 
    buttonLayout->addWidget(saveToCubeButton);
    buttonLayout->addWidget(deleteFromCubeButton);
    buttonLayout->addWidget(loadStretchButton);
    ((QBoxLayout*)layout())->addLayout(buttonLayout);
  }
 
  void AdvancedStretchDialog::updateForRGBMode(Stretch &redStretch,
      Histogram &redHist,
      Stretch &grnStretch, Histogram &grnHist,
      Stretch &bluStretch, Histogram &bluHist)
  {
    if(p_redStretch) {
      p_redStretch->setStretch(redStretch);
      p_redStretch->setHistogram(redHist);
    }
 
    if(p_grnStretch) {
      p_grnStretch->setStretch(grnStretch);
      p_grnStretch->setHistogram(grnHist);
    }
 
    if(p_bluStretch) {
      p_bluStretch->setStretch(bluStretch);
      p_bluStretch->setHistogram(bluHist);
    }
  }
 
 
 
  void AdvancedStretchDialog::enableGrayMode(Stretch &grayStretch,
      Histogram &grayHist) {
    destroyCurrentStretches();
 
    p_grayStretch = new AdvancedStretch(grayHist, grayStretch,
                                        "Gray", QColor(Qt::gray));
    layout()->addWidget(p_grayStretch);
    updateGeometry();
 
    connect(p_grayStretch, SIGNAL(stretchChanged()),
            this, SIGNAL(stretchChanged()));
    connect(p_grayStretch, SIGNAL(saveToCube()),
            this, SIGNAL(saveToCube()));
    connect(p_grayStretch, SIGNAL(deleteFromCube()),
            this, SIGNAL(deleteFromCube()));
    connect(p_grayStretch, SIGNAL(loadStretch()),
            this, SIGNAL(loadStretch()));
  }
 
 
  void AdvancedStretchDialog::restoreGrayStretch(CubeStretch stretch){
    if (p_grayStretch) {
      p_grayStretch->restoreSavedStretch(stretch); 
    }
    else {
      QString msg = "Gray mode not enabled, cannot restore gray stretch";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
  }
 
 
  void AdvancedStretchDialog::restoreRgbStretch(CubeStretch red, CubeStretch green, CubeStretch blue) {
    if (isRgbMode()) {
      if (p_redStretch) {
        p_redStretch->restoreSavedStretch(red); 
      }
      
      if (p_grnStretch) {
        p_grnStretch->restoreSavedStretch(green); 
      }
      
      if (p_bluStretch) {
        p_bluStretch->restoreSavedStretch(blue); 
      }
    }
    else {
      QString msg = "RGB mode not enabled, cannot restore RGB stretch";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
  }
 
 
  void AdvancedStretchDialog::destroyCurrentStretches() {
    if(p_redStretch) {
      layout()->removeWidget(p_redStretch);
      disconnect(p_redStretch, SIGNAL(stretchChanged()),
                 this, SIGNAL(stretchChanged()));
      delete p_redStretch;
      p_redStretch = NULL;
    }
 
    if(p_grnStretch) {
      layout()->removeWidget(p_grnStretch);
      disconnect(p_grnStretch, SIGNAL(stretchChanged()),
                 this, SIGNAL(stretchChanged()));
      delete p_grnStretch;
      p_grnStretch = NULL;
    }
 
    if(p_bluStretch) {
      layout()->removeWidget(p_bluStretch);
      disconnect(p_bluStretch, SIGNAL(stretchChanged()),
                 this, SIGNAL(stretchChanged()));
      delete p_bluStretch;
      p_bluStretch = NULL;
    }
 
    if(p_grayStretch) {
      layout()->removeWidget(p_grayStretch);
      disconnect(p_grayStretch, SIGNAL(stretchChanged()),
                 this, SIGNAL(stretchChanged()));
      delete p_grayStretch;
      p_grayStretch = NULL;
    }
  }
 
 
  void AdvancedStretchDialog::updateStretch(CubeViewport *cvp) {
    if(p_grayStretch){
      p_grayStretch->setStretch(cvp->grayStretch());
    }
    if(p_redStretch) {
      p_redStretch->setStretch(cvp->redStretch());
    }
    if(p_grnStretch){
      p_grnStretch->setStretch(cvp->greenStretch());
    }
    if(p_bluStretch){
      p_bluStretch->setStretch(cvp->blueStretch());
    }
  }
 
 
  void AdvancedStretchDialog::updateHistograms(const Histogram &redHist,
      const Histogram &grnHist,
      const Histogram &bluHist) {
 
    if(p_redStretch){
      p_redStretch->setHistogram(redHist);
    }
    if(p_grnStretch){
      p_grnStretch->setHistogram(grnHist);
    }
    if(p_bluStretch){
      p_bluStretch->setHistogram(bluHist);
    }
  }
 
 
  void AdvancedStretchDialog::updateHistogram(const Histogram &grayHist) {
    if(p_grayStretch)
      p_grayStretch->setHistogram(grayHist);
  }
 
 
  void AdvancedStretchDialog::showEvent(QShowEvent *event) {
    QDialog::showEvent(event);
    emit visibilityChanged();
  }
 
 
  void AdvancedStretchDialog::hideEvent(QHideEvent *event) {
    QDialog::hideEvent(event);
    emit visibilityChanged();
  }
 
 
  bool AdvancedStretchDialog::isRgbMode() const {
    return (p_redStretch && p_grnStretch && p_bluStretch);
  }
 
 
  CubeStretch AdvancedStretchDialog::getGrayStretch() {
    if(p_grayStretch) {
      return p_grayStretch->getStretch();
    }
    else {
      QString msg = "Gray mode not enabled, cannot get gray stretch";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
  }
 
 
  CubeStretch AdvancedStretchDialog::getRedStretch() {
    if(p_redStretch) {
      return p_redStretch->getStretch();
    }
    else {
      QString msg = "RGB mode not enabled, cannot get red stretch";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
  }
 
 
  CubeStretch AdvancedStretchDialog::getGrnStretch() {
    if(p_grnStretch) {
      return p_grnStretch->getStretch();
    }
    else {
      QString msg = "RGB mode not enabled, cannot get green stretch";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
  }
 
 
  CubeStretch AdvancedStretchDialog::getBluStretch() {
    if(p_bluStretch) {
      return p_bluStretch->getStretch();
    }
    else {
      QString msg = "RGB mode not enabled, cannot get blue stretch";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
  }
}