ChipViewport.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include "IsisDebug.h"
 
#include "ChipViewport.h"
 
#include <iostream>
 
#include <QMessageBox>
#include <QPainter>
 
#include "ControlMeasure.h"
#include "ControlNet.h"
#include "ControlPoint.h"
#include "Cube.h"
#include "CubeViewport.h"
#include "SerialNumber.h"
#include "Stretch.h"
 
namespace Isis {
 
  ChipViewport::ChipViewport(int width, int height, QWidget *parent) : QWidget(parent) {
 
    setFixedSize(width, height);
    setBackgroundRole(QPalette::Dark);
//    setFocusPolicy(Qt::StrongFocus);
 
    m_width = width;
    m_height = height;
    m_zoomFactor = 1.0;
    m_rotation = 0;
    m_geomIt = false;
    m_tempView = NULL;
    m_cross = true;
    m_circle = false;
    m_chip = NULL;
    m_chipCube = NULL;
    m_matchChip = NULL;
    m_matchChipCube = NULL;
    m_image = NULL;
    m_image = new QImage(512, 512, QImage::Format_RGB32);
    m_image->fill(Qt::black);
    m_controlNet = NULL;
    m_stretchLocked = false;
    m_stretch = NULL;
 
    m_stretch = new Stretch;
  }
 
 
  ChipViewport::~ChipViewport() {
    if (m_stretch) {
      delete m_stretch;
      m_stretch = NULL;
    }
  }
 
 
  bool ChipViewport::cubeToViewport(double samp, double line,
                                    int &x, int &y) {
 
    m_chip->SetCubePosition(samp, line);
    x = ((int) m_chip->ChipSample()) - 1;
    y = ((int) m_chip->ChipLine()) - 1;
 
    return m_chip->IsInsideChip(samp, line);
  }
 
 
  void ChipViewport::setChip(Chip *chip, Cube *chipCube) {
    // Is the chip usable?
    if (chip == NULL || chipCube == NULL) {
      throw IException(IException::Programmer,
                       "Can not view NULL chip pointer",
                       _FILEINFO_);
    }
 
    m_zoomFactor = 1.0;
    m_rotation = 0;
 
    m_chip = chip;
    m_chipCube = chipCube;
    if (m_image != NULL)
      delete m_image;
    m_image = new QImage(chip->Samples(), chip->Lines(), QImage::Format_RGB32);
 
    autoStretch();
    emit tackPointChanged(m_zoomFactor);
  }
 
 
  void ChipViewport::autoStretch() {
    computeStretch(m_gray.stretch);
    paintImage();
    update();
  }
 
 
  void ChipViewport::stretchFromCubeViewport(Stretch *newStretch, CubeViewport *cvp) {
 
    ASSERT(cvp != NULL);
 
    if (!cvp || !m_chipCube)
      return;
 
    // only stretch if the CubeViewport is opened to the same cube as we are,
    // otherwise the signal was meant for a different ChipViewport!
    if (cvp->cube()->fileName() == m_chipCube->fileName()) {
 
      // if user right clicked in the CubeViewport then we get a SIGNAL with a
      // NULL Stretch.  This is used to signify that we need to restretch on our
      // own (go back to global).
      if (!newStretch) {
        computeStretch(m_gray.stretch, true);
        paintImage();
        update();
      }
      else {
        *m_stretch = *newStretch;
        m_gray.stretch = *newStretch;
        paintImage();
        update();
      }
    }
  }
 
 
  void ChipViewport::changeStretchLock(int newStatus) {
    if (newStatus == 0)
      m_stretchLocked = false;
    else
      m_stretchLocked = true;
  }
 
 
  void ChipViewport::computeStretch(Stretch &stretch, bool force) {
    if (m_stretchLocked && !force) {
      stretch = *m_stretch;
    }
    else {
      Statistics stats;
      for (int line = 1; line < m_chip->Lines(); line++) {
        for (int samp = 1; samp < m_chip->Samples(); samp++) {
          double value = m_chip->GetValue(samp, line);
          stats.AddData(&value, 1);
        }
      }
 
      Histogram hist(stats.BestMinimum(), stats.BestMaximum());
      for (int line = 1; line <= m_chip->Lines(); line++) {
        for (int samp = 1; samp <= m_chip->Samples(); samp++) {
          double value = m_chip->GetValue(samp, line);
          hist.AddData(&value, 1);
        }
      }
 
      stretch.ClearPairs();
      if (hist.Percent(0.5) != hist.Percent(99.5)) {
        stretch.AddPair(hist.Percent(0.5), 0.0);
        stretch.AddPair(hist.Percent(99.5), 255.0);
      }
      else {
        stretch.AddPair(-DBL_MAX, 0.0);
        stretch.AddPair(DBL_MAX, 255.0);
      }
 
      *m_stretch = stretch;
    }
  }
 
 
  void ChipViewport::paintImage() {
    //TODO ??? Need something similar to CubeViewport clipping, so that
    //         at edge of image, fill viewport w/ black
    for (int y = 0; y < m_chip->Lines(); y++) {
      QRgb *rgb = (QRgb *) m_image->scanLine(y);
      int r, g, b;
      for (int x = 0; x < m_chip->Samples(); x++) {
        r = g = b = (int) m_gray.stretch.Map(m_chip->GetValue(x + 1, y + 1));
        rgb[x] =  qRgb(r, g, b);
      }
    }
    repaint();
 
  }
 
 
  void ChipViewport::paintEvent(QPaintEvent *e) {
 
    QPainter painter(this);
 
    if (m_tempView != NULL) {
      painter.drawImage(0, 0, *(m_tempView->m_image));
    }
    else {
      painter.drawImage(0, 0, *m_image);
    }
 
    if (m_cross == true) {
      painter.setPen(Qt::red);
      painter.drawLine(0, (m_height - 1) / 2, m_width - 1, (m_height - 1) / 2);
      painter.drawLine((m_width - 1) / 2, 0, (m_width - 1) / 2, m_height - 1);
    }
 
    if (m_circle == true) {
      painter.setPen(Qt::red);
      painter.drawEllipse((m_height - 1) / 2 - m_circleSize / 2,
                          (m_width - 1) / 2 - m_circleSize / 2,
                          m_circleSize, m_circleSize);
    }
 
    QString serialNumber = m_chipCube? SerialNumber::Compose(*m_chipCube) : QString();
    if (m_controlNet && !serialNumber.isEmpty()
        && m_controlNet->GetCubeSerials().contains(serialNumber)) {
      // draw measure locations if we have a control network
      //  If the serial number is Unknown, we probably have a ground source
      //  file or level 2 which means it does not exist in the network
      //TODO Is there a better way to handle this?
      if (m_showPoints && serialNumber.compare("Unknown") &&
          m_controlNet->GetNumPoints() != 0) {
        QList<ControlMeasure *> measures =
                                   m_controlNet->GetMeasuresInCube(serialNumber);
        // loop through all points in the control net
        for (int i = 0; i < measures.count(); i++) {
          ControlMeasure *m = measures[i];
          // Find the measurments on the viewport
          double samp = m->GetSample();
          double line = m->GetLine();
          int x, y;
 
          cubeToViewport(samp, line, x, y);
          // Determine pen color
          // if the point or measure is ignored set to yellow
          if (m->Parent()->IsIgnored() ||
             (!m->Parent()->IsIgnored() && m->IsIgnored())) {
            painter.setPen(QColor(255, 255, 0)); // set point marker yellow
          }
          // check for ground measure
          else if (m->Parent()->GetType() == ControlPoint::Fixed) {
            painter.setPen(Qt::magenta);// set point marker magenta
          }
          else {
            painter.setPen(Qt::green); // set all other point markers green
          }
 
          // draw points which are not under cross
          if (x != (m_width - 1) / 2 || y != (m_height - 1) / 2) {
            painter.drawLine(x - 5, y, x + 5, y);
            painter.drawLine(x, y - 5, x, y + 5);
          }
        }
      }
    }
 
    m_tempView = NULL;
    //painter.end();
 
  }
 
 
  void ChipViewport::loadView(ChipViewport &newView) {
    m_tempView = &newView;
    update();
  }
 
 
  double ChipViewport::tackSample() {
    m_chip->SetChipPosition(m_chip->TackSample(), m_chip->TackLine());
    return m_chip->CubeSample();
  }
 
 
  double ChipViewport::tackLine() {
    m_chip->SetChipPosition(m_chip->TackSample(), m_chip->TackLine());
    return m_chip->CubeLine();
  }
 
 
  void ChipViewport::panUp() {
    int x, y;
    x = m_chip->TackSample();
    y = m_chip->TackLine() - 1;
    //  Reload with new cube position
    m_chip->SetChipPosition((double)x, (double)y);
    reloadChip(m_chip->CubeSample(), m_chip->CubeLine());
  }
 
 
  void ChipViewport::panDown() {
    int x, y;
    x = m_chip->TackSample();
    y = m_chip->TackLine() + 1;
    //  Reload with new cube position
    m_chip->SetChipPosition((double)x, (double)y);
    reloadChip(m_chip->CubeSample(), m_chip->CubeLine());
  }
 
 
  void ChipViewport::panLeft() {
    int x, y;
    x = m_chip->TackSample() - 1;
    y = m_chip->TackLine();
    //  Reload with new cube position
    m_chip->SetChipPosition((double)x, (double)y);
    reloadChip(m_chip->CubeSample(), m_chip->CubeLine());
  }
 
 
  void ChipViewport::panRight() {
    int x, y;
    x = m_chip->TackSample() + 1;
    y = m_chip->TackLine();
    //  Reload with new cube position
    m_chip->SetChipPosition((double)x, (double)y);
    reloadChip(m_chip->CubeSample(), m_chip->CubeLine());
  }
 
 
  void ChipViewport::zoomIn() {
    m_zoomFactor /= 2.0;
    reloadChip();
  }
 
 
  void ChipViewport::zoomOut() {
    m_zoomFactor *= 2.0;
    reloadChip();
  }
 
 
  void ChipViewport::zoom1() {
    m_zoomFactor = 1.0;
    reloadChip();
  }
 
 
  void ChipViewport::zoom(double zoomFactor) {
    m_zoomFactor = zoomFactor;
    reloadChip();
  }
 
 
  double ChipViewport::zoomFactor() {
    return m_zoomFactor;
  }
 
 
  void ChipViewport::refreshView(double tackSample, double tackLine) {
    reloadChip(tackSample, tackLine);
  }
 
 
  void ChipViewport::enterEvent(QEvent *e) {
    setFocus();
  }
 
 
  void ChipViewport::keyPressEvent(QKeyEvent *e) {
 
    int x, y;
    x = m_chip->TackSample();
    y = m_chip->TackLine();
    if (e->key() == Qt::Key_Up) {
      y--;
    }
    else if (e->key() == Qt::Key_Down) {
      y++;
    }
    else if (e->key() == Qt::Key_Left) {
      x--;
    }
    else if (e->key() == Qt::Key_Right) {
      x++;
    }
    else {
      QWidget::keyPressEvent(e);
      return;
    }
 
    //  Reload with new cube position
    m_chip->SetChipPosition((double)x, (double)y);
    reloadChip(m_chip->CubeSample(), m_chip->CubeLine());
    emit userMovedTackPoint();
  }
 
 
  void ChipViewport::mousePressEvent(QMouseEvent *event) {
 
    QPoint p = event->pos();
    if (event->button() == Qt::LeftButton) {
      //  Reload with new cube position
      m_chip->SetChipPosition((double)p.x(), (double)p.y());
      reloadChip(m_chip->CubeSample(), m_chip->CubeLine());
      emit userMovedTackPoint();
      //  This was added when the scrolled area was added to the QnetTool.
      //  For some reason when clicking in the ChipViewport, focus would be
      //  lost and the arrow keys would no longer work.
      //TODO  Is this the correct way to fix this, why is it happening?
      setFocus();
    }
  }
 
 
  void ChipViewport::setPoints(bool checked) {
 
    if (checked == m_showPoints)
      return;
 
    m_showPoints = checked;
    repaint();
 
  }
 
 
  void ChipViewport::setCross(bool checked) {
 
    if (checked == m_cross)
      return;
 
    m_cross = checked;
    repaint();
 
  }
 
 
  void ChipViewport::setCircle(bool checked) {
 
    if (checked == m_circle)
      return;
 
    m_circle = checked;
    repaint();
  }
 
 
  void ChipViewport::setCircleSize(int size) {
 
    m_circleSize = size;
    repaint();
 
  }
 
 
  void ChipViewport::geomChip(Chip *matchChip, Cube *matchChipCube) {
 
    m_geomIt = true;
    m_matchChip = matchChip;
    m_matchChipCube = matchChipCube;
    try {
      m_chip->Load(*m_chipCube, *matchChip, *matchChipCube);
//    m_chip->ReLoad(*matchChip,m_zoomFactor);
    }
    catch (IException &e) {
      QString msg = "Cannot geom chip.\n";
      msg += e.toString();
      QMessageBox::information((QWidget *)parent(), "Error", msg);
      return;
    }
 
    //TODO ??? Can these be added to paintEvent method ???
    autoStretch();
  }
 
 
  void ChipViewport::nogeomChip() {
 
    m_geomIt = false;
    try {
      m_chip->Load(*m_chipCube, m_rotation, m_zoomFactor);
    }
    catch (IException &e) {
      QString msg = "Cannot load no geom chip.\n";
      msg += e.toString();
      QMessageBox::information((QWidget *)parent(), "Error", msg);
      return;
    }
 
    //TODO ??? Can these be added to paintEvent method ???
    autoStretch();
  }
 
 
  void ChipViewport::rotateChip(int rotation) {
 
    m_rotation = -rotation;
    try {
      m_chip->Load(*m_chipCube, -rotation, m_zoomFactor);
    }
    catch (IException &e) {
      QString msg = "Cannot load rotated chip.\n";
      msg += e.toString();
      QMessageBox::information((QWidget *)parent(), "Error", msg);
      return;
    }
 
    //TODO ??? Can these be added to paintEvent method ???
    autoStretch();
  }
 
 
  void ChipViewport::reloadChip(double tackSample, double tackLine) {
 
    // Is the chip usable?
    if (m_chip == NULL) {
      throw IException(IException::Programmer,
                       "Can not view NULL chip pointer",
                       _FILEINFO_);
    }
 
    if (tackSample != 0. && tackLine != 0.)
      m_chip->TackCube(tackSample, tackLine);
    if (m_geomIt) {
      if (m_matchChip == NULL) {
        throw IException(IException::User, "Invalid match chip", _FILEINFO_);
      }
      try {
        m_chip->Load(*m_chipCube, *m_matchChip, *m_matchChipCube);
      }
      catch (IException &e) {
        QString msg = "Cannot reload chip.\n";
        msg += e.toString();
        QMessageBox::information((QWidget *)parent(), "Error", msg);
        return;
      }
//      m_chip->ReLoad(*m_matchChip,m_zoomFactor);
    }
    else {
      try {
        m_chip->Load(*m_chipCube, m_rotation, m_zoomFactor);
      }
      catch (IException &e) {
        QString msg = "Cannot reload chip.\n";
        msg += e.toString();
        QMessageBox::information((QWidget *)parent(), "Error", msg);
        return;
      }
    }
 
 
    //TODO ??? Can these be added to paintEvent method ???
    autoStretch();
 
    //  emit signal indicating tack point changed so that the TieTool
    //  can update the sample/line label.
    emit tackPointChanged(m_zoomFactor);
  }
}