AdvancedStretchDialog.cpp

#include "AdvancedStretchDialog.h"

#include <QHBoxLayout>

#include "CubeViewport.h"
#include "Stretch.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;

    QHBoxLayout *layout = new QHBoxLayout();
    setLayout(layout);
  }


  AdvancedStretchDialog::~AdvancedStretchDialog() {
    destroyCurrentStretches();
  }


  void AdvancedStretchDialog::enableRgbMode(Stretch &redStretch,
      Histogram &redHist,
      Stretch &grnStretch, Histogram &grnHist,
      Stretch &bluStretch, Histogram &bluHist) {
    destroyCurrentStretches();

    p_redStretch = new AdvancedStretch(redHist, redStretch,
                                       "Red", QColor(Qt::red));
    layout()->addWidget(p_redStretch);

    p_grnStretch = new AdvancedStretch(grnHist, grnStretch,
                                       "Green", QColor(Qt::green));
    layout()->addWidget(p_grnStretch);

    p_bluStretch = new AdvancedStretch(bluHist, bluStretch,
                                       "Blue", QColor(Qt::blue));
    layout()->addWidget(p_bluStretch);
    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()));
  }

  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()));
  }


  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);
  }


  Stretch AdvancedStretchDialog::getGrayStretch() {
    if(p_grayStretch) {
      return p_grayStretch->getStretch();
    }
    else {
      IString msg = "Gray mode not enabled, cannot get gray stretch";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
  }


  Stretch AdvancedStretchDialog::getRedStretch() {
    if(p_redStretch) {
      return p_redStretch->getStretch();
    }
    else {
      IString msg = "RGB mode not enabled, cannot get red stretch";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
  }


  Stretch AdvancedStretchDialog::getGrnStretch() {
    if(p_grnStretch) {
      return p_grnStretch->getStretch();
    }
    else {
      IString msg = "RGB mode not enabled, cannot get green stretch";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
  }


  Stretch AdvancedStretchDialog::getBluStretch() {
    if(p_bluStretch) {
      return p_bluStretch->getStretch();
    }
    else {
      IString msg = "RGB mode not enabled, cannot get blue stretch";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
  }
}