CubeViewport.h

Go to the documentation of this file.

#ifndef CubeViewport_h
#define CubeViewport_h

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

          Stretch getStretch() const;
          void setStretch(const Stretch &newStretch);
          int band;
        private:
          Stretch *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);
      Stretch grayStretch() const;
      Stretch redStretch() const;
      Stretch greenStretch() const;
      Stretch 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