CubeViewport.h

#ifndef CubeViewport_h
#define CubeViewport_h
 
/* SPDX-License-Identifier: CC0-1.0 */
 
 
// parent of this class
#include <QAbstractScrollArea>
 
class QPaintEvent;
 
namespace Isis {
  class Brick;
  class Camera;
  class Cube;
  class CubeDataThread;
  class Projection;
  class Pvl;
  class PvlKeyword;
  class CubeStretch;
  class Stretch;
  class Tool;
  class UniversalGroundMap;
 
  class ViewportBuffer;
 
  class CubeViewport : public QAbstractScrollArea {
      Q_OBJECT
 
    public:
      CubeViewport(Cube *cube, CubeDataThread * cdt = 0, QWidget *parent = 0);
 
      virtual ~CubeViewport();
 
 
      class BandInfo {
        public:
          BandInfo();
          BandInfo(const BandInfo &other);
          ~BandInfo();
 
          const BandInfo &operator=(BandInfo other);
 
          CubeStretch getStretch() const;
          void setStretch(const Stretch &newStretch);
          int band;
        private:
          CubeStretch *stretch;
      };
 
      void setCube(Cube *cube);
      int cubeSamples() const;
      int cubeLines() const;
      int cubeBands() const;
 
      bool isColor() const {
        return p_color;
      };
 
      bool isGray() const {
        return !p_color;
      };
 
      int grayBand() const {
        return p_gray.band;
      };
 
      int redBand() const {
        return p_red.band;
      };
 
      int greenBand() const {
        return p_green.band;
      };
 
      int blueBand() const {
        return p_blue.band;
      };
 
      double scale() const {
        return p_scale;
      };
 
      bool cubeShown() const {
        return p_cubeShown;
      };
 
      int comboCount() const {
        return p_comboCount;
      };
 
      int comboIndex() const {
        return p_comboIndex;
      }
 
      void cubeContentsChanged(QRect rect);
 
      double fitScale() const;
      double fitScaleWidth() const;
      double fitScaleHeight() const;
 
      void viewportToCube(int x, int y,
                          double &sample, double &line) const;
 
      void cubeToViewport(double sample, double line,
                          int &x, int &y) const;
      void contentsToCube(int x, int y,
                          double &sample, double &line) const;
      void cubeToContents(double sample, double line,
                          int &x, int &y) const;
 
      double redPixel(int sample, int line);
 
      double greenPixel(int sample, int line);
 
      double bluePixel(int sample, int line);
 
      double grayPixel(int sample, int line);
      CubeStretch grayStretch() const;
      CubeStretch redStretch() const;
      CubeStretch greenStretch() const;
      CubeStretch blueStretch() const;
 
      Cube *cube() const {
        return p_cube;
      };
 
      Projection *projection() const {
        return p_projection;
      };
 
      Camera *camera() const {
        return p_camera;
      };
 
      UniversalGroundMap *universalGroundMap() const {
        return p_groundMap;
      };
 
      Cube *trackingCube() const {
        return p_trackingCube;
      };
 
      void moveCursor(int x, int y);
      bool cursorInside() const;
      QPoint cursorPosition() const;
      void setCursorPosition(int x, int y);
      void setCaption();
 
      void setBackground(QColor color) {
        p_bgColor = color;
      }
 
      void setComboCount(int count) {
        p_comboCount = count;
      }
 
      void setComboIndex(int index) {
        p_comboIndex = index;
      }
 
      QPixmap pixmap() {
        return p_pixmap;
      }
 
      ViewportBuffer *grayBuffer() {
        return p_grayBuffer;
      }
 
      ViewportBuffer *redBuffer() {
        return p_redBuffer;
      }
 
      ViewportBuffer *greenBuffer() {
        return p_greenBuffer;
      }
 
      ViewportBuffer *blueBuffer() {
        return p_blueBuffer;
      }
 
      void bufferUpdated(QRect rect);
 
      virtual void restretch(ViewportBuffer *buffer) = 0;
      void paintPixmap();
 
      void forgetStretches();
 
      void setAllBandStretches(Stretch stretch);
 
 
      CubeDataThread *cubeDataThread() {
        return p_cubeData;
      }
 
      int cubeID() {
        return p_cubeId;
      }
 
 
      void getAllWhatsThisInfo(Pvl & pWhatsThisPvl);
 
      void getBandFilterName(PvlKeyword & pFilterNameKey);
 
      void getCubeArea(double & pdStartSample, double & pdEndSample,
                                     double & pdStartLine, double & pdEndLine);
 
      bool confirmClose();
 
      void setTrackingCube();
 
    signals:
      void viewportUpdated();
      void viewportClosed(CubeViewport *);
      void mouseEnter();
      void mouseMove(QPoint);
      void mouseMove(QPoint, Qt::MouseButton);
      void mouseLeave();
      void mouseButtonPress(QPoint, Qt::MouseButton);
      void mouseButtonRelease(QPoint, Qt::MouseButton);
      void mouseDoubleClick(QPoint);
      void windowTitleChanged();
      void scaleChanged(); 
      void saveChanges(CubeViewport *); 
      void discardChanges(CubeViewport *); 
      void screenPixelsChanged(); 
 
      void progressChanged(int);
      void progressComplete();
 
      void doneWithData(int, const Isis::Brick *);
 
 
    public slots:
      QSize sizeHint() const;
      void setScale(double scale);
      void setScale(double scale, double sample, double line);
      void setScale(double scale, int x, int y);
      void center(int x, int y);
      void center(double sample, double line);
 
      virtual void viewRGB(int redBand, int greenBand, int blueBand);
      virtual void viewGray(int band);
 
      void stretchGray(const QString &string);
      void stretchRed(const QString &string);
      void stretchGreen(const QString &string);
      void stretchBlue(const QString &string);
 
      void stretchGray(const Stretch &stretch);
      void stretchRed(const Stretch &stretch);
      void stretchGreen(const Stretch &stretch);
      void stretchBlue(const Stretch &stretch);
 
      void stretchKnownGlobal();
 
      void cubeChanged(bool changed);
      void showEvent(QShowEvent *);
 
      void scrollBy(int dx, int dy);
 
      void changeCursor(QCursor cursor);
 
      void onProgressTimer();
      void enableProgress();
 
 
    protected:
      void scrollContentsBy(int dx, int dy);
      virtual void resizeEvent(QResizeEvent *e);
      virtual bool eventFilter(QObject *o, QEvent *e);
      virtual void keyPressEvent(QKeyEvent *e);
      virtual void paintEvent(QPaintEvent *e);
 
 
 
    protected slots:
      virtual void cubeDataChanged(int cubeId, const Isis::Brick *);
 
 
    private:
 
      void paintPixmap(QRect rect);
      void shiftPixmap(int dx, int dy);
 
      void updateScrollBars(int x, int y);
      void paintPixmapRects();
 
      //void computeStretch(Brick *brick, int band,
      //                    int ssamp, int esamp,
      //                    int sline, int eline, int linerate,
      //                    Stretch &stretch);
 
 
 
    protected: // data
      QPixmap p_pixmap;
 
      QVector< Stretch * > * p_knownStretches;
 
      QVector< Stretch * > * p_globalStretches;
 
 
    private: // data
      ViewportBuffer *p_grayBuffer;  
      ViewportBuffer *p_redBuffer;  
      ViewportBuffer *p_greenBuffer;  
      ViewportBuffer *p_blueBuffer;  
 
      QColor p_bgColor; 
 
      Cube *p_cube;  
      Camera *p_camera;  
      Projection *p_projection;  
      UniversalGroundMap *p_groundMap;  
      Cube *p_trackingCube; //<! The tracking cube associated with p_cube
 
      QTimer *p_progressTimer;
 
      double p_scale;
 
      bool p_color;
      BandInfo p_gray;
      BandInfo p_red;
      BandInfo p_green;
      BandInfo p_blue;
 
      int p_comboCount;
      int p_comboIndex;
 
      Brick *p_redBrick;  
      Brick *p_grnBrick;  
      Brick *p_bluBrick;  
      Brick *p_gryBrick;  
      Brick *p_pntBrick;  
      bool p_saveEnabled; 
      bool p_cubeShown;
      QImage *p_image;  
      bool p_paintPixmap;
      bool p_updatingBuffers; 
 
      QString p_whatsThisText;
      QString p_cubeWhatsThisText;
      QString p_viewportWhatsThisText;
      void updateWhatsThis();
 
      QList< QRect * > *p_pixmapPaintRects;
 
      CubeDataThread *p_cubeData;  
      int p_cubeId; 
 
      bool p_thisOwnsCubeData;
  };
}
 
#endif