xypor/index.php

/*

    SPDX-FileCopyrightText: 2003-2017 Jasem Mutlaq <mutlaqja@ikarustech.com>

    SPDX-FileCopyrightText: 2016-2017 Robert Lancaster <rlancaste@gmail.com>


    SPDX-License-Identifier: GPL-2.0-or-later

*/


#pragma once


#include "fitscommon.h"

#include "auxiliary/imagemask.h"


#include <config-kstars.h>

#include "stretch.h"


#ifdef HAVE_DATAVISUALIZATION

#include "starprofileviewer.h"

#endif


#include <QFutureWatcher>

#include <QPixmap>

#include <QScrollArea>

#include <QStack>

#include <QTimer>

#include <QPointer>


#ifdef WIN32

// avoid compiler warning when windows.h is included after fitsio.h

#include <windows.h>

#endif


#include <fitsio.h>


#include <memory>


class QAction;

class QEvent;

class QGestureEvent;

class QImage;

class QLabel;

class QPinchGesture;

class QResizeEvent;

class QToolBar;


class FITSData;

class FITSLabel;


class FITSView : public QScrollArea

{

        Q_OBJECT

        Q_PROPERTY(bool suspended MEMBER m_Suspended)


    public:

        explicit FITSView(QWidget *parent = nullptr, FITSMode fitsMode = FITS_NORMAL, FITSScale filterType = FITS_NONE);

        virtual ~FITSView() override;


        typedef enum {dragCursor, selectCursor, scopeCursor, crosshairCursor } CursorMode;


        /**

         * @brief loadFITS Loads FITS data and displays it in a FITSView frame

         * @param inFilename FITS File name

         * @note If image is successfully, loaded() signal is emitted, otherwise failed() signal is emitted.

         * Obtain error by calling lastError()

         */

        void loadFile(const QString &inFilename);


        /**

         * @brief loadFITSFromData Takes ownership of the FITSData instance passed in and displays it in a FITSView frame

         * @param data pointer to FITSData objects

         */

        bool loadData(const QSharedPointer<FITSData> &data);


        /**

         * @brief clearView Reset view to NO IMAGE

         */

        void clearData();


        // Save FITS

        bool saveImage(const QString &newFilename);

        // Rescale image lineary from image_buffer, fit to window if desired

        bool rescale(FITSZoom type);


        const QSharedPointer<FITSData> &imageData() const

        {

            return m_ImageData;

        }


        Q_SCRIPTABLE void setStretchValues(double shadows, double midtones, double highlights);

        Q_SCRIPTABLE void setAutoStretch();


        double getCurrentZoom() const

        {

            return currentZoom;

        }

        const QImage &getDisplayImage() const

        {

            return rawImage;

        }

        const QPixmap &getDisplayPixmap() const

        {

            return displayPixmap;

        }


        // Tracking square

        void setTrackingBoxEnabled(bool enable);

        bool isTrackingBoxEnabled() const

        {

            return trackingBoxEnabled;

        }

        QPixmap &getTrackingBoxPixmap(uint8_t margin = 0);

        void setTrackingBox(const QRect &rect);

        const QRect &getTrackingBox() const

        {

            return trackingBox;

        }


        // last error

        const QString &lastError() const

        {

            return m_LastError;

        }


        // Overlay

        virtual void drawOverlay(QPainter *, double scale);


        // Overlay objects

        void drawStarRingFilter(QPainter *, double scale, ImageRingMask *ringMask);

        void drawStarCentroid(QPainter *, double scale);

        void drawClipping(QPainter *);

        void drawTrackingBox(QPainter *, double scale);

        void drawMarker(QPainter *, double scale);

        void drawCrosshair(QPainter *, double scale);


#if !defined(KSTARS_LITE) && defined(HAVE_WCSLIB)

        void drawEQGrid(QPainter *, double scale);

        void drawHiPSOverlay(QPainter *painter, double scale);

#endif

        void drawObjectNames(QPainter *painter, double scale);

        void drawCatObjectNames(QPainter *painter, double scale);

        void drawCatROI(QPainter *painter, double scale);

        void drawPixelGrid(QPainter *painter, double scale);

        void drawMagnifyingGlass(QPainter *painter, double scale);


        bool isImageStretched();

        bool isCrosshairShown();

        bool isClippingShown();

        bool areObjectsShown();

        bool isEQGridShown();

        bool isSelectionRectShown();

        bool isPixelGridShown();

        bool isHiPSOverlayShown();

        bool imageHasWCS();


        // Setup the graphics.

        void updateFrame(bool now = false);


        // Telescope

        bool isTelescopeActive();

        void updateScopeButton();

        void setScopeButton(QAction *action)

        {

            centerTelescopeAction = action;

        }


        // Events Management

#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)

        void enterEvent(QEnterEvent *event) override;

#else

        void enterEvent(QEvent *event) override;

#endif

        void leaveEvent(QEvent *event) override;

        CursorMode getCursorMode();

        void setCursorMode(CursorMode mode);

        void updateMouseCursor();


        // Zoom related

        void cleanUpZoom(QPoint viewCenter = QPoint());

        QPoint getImagePoint(QPoint viewPortPoint);

        uint16_t zoomedWidth()

        {

            return currentWidth;

        }

        uint16_t zoomedHeight()

        {

            return currentHeight;

        }

        double ZoomFactor() const

        {

            return m_ZoomFactor;

        }


        // Star Detection

        QFuture<bool> findStars(StarAlgorithm algorithm = ALGORITHM_CENTROID, const QRect &searchBox = QRect());

        void toggleStars(bool enable);

        void searchStars();

        void setStarsEnabled(bool enable);

        void setStarsHFREnabled(bool enable);

        int filterStars();


        // image masks

        QSharedPointer<ImageMask> imageMask()

        {

            return m_ImageMask;

        }

        void setImageMask(ImageMask *mask);


        // FITS Mode

        void updateMode(FITSMode fmode);

        FITSMode getMode()

        {

            return mode;

        }


        void setFilter(FITSScale newFilter)

        {

            filter = newFilter;

        }


        void setFirstLoad(bool value);


        void pushFilter(FITSScale value)

        {

            filterStack.push(value);

        }

        FITSScale popFilter()

        {

            return filterStack.pop();

        }


        CursorMode lastMouseMode { selectCursor };

        bool isStarProfileShown()

        {

            return showStarProfile;

        }

        // Floating toolbar

        void createFloatingToolBar();


        //void setLoadWCSEnabled(bool value);


        // Returns the params set to stretch the image.

        StretchParams getStretchParams() const

        {

            return stretchParams;

        }


        // Returns true if we're automatically generating stretch parameters.

        // Note: this is not whether we're stretching, that's controlled by stretchImage.

        bool getAutoStretch() const

        {

            return autoStretch;

        }


        // Sets the params for stretching. Will also stretch and re-display the image.

        // This only sets the first channel stretch params. For RGB images, the G&B channel

        // stretch parameters are a function of the Red input param and the existing RGB params.

        void setStretchParams(const StretchParams &params);


        // Sets whether to stretch the image or not.

        // Will also re-display the image if onOff != stretchImage.

        void setStretch(bool onOff);


        // Automatically generates stretch parameters and use them to re-display the image.

        void setAutoStretchParams();


        // When sampling is > 1, we will display the image at a lower resolution.

        // When sampling = 0, reset to the adaptive sampling value

        void setPreviewSampling(uint8_t value)

        {

            if (value == 0)

            {

                m_PreviewSampling = m_AdaptiveSampling;

                m_StretchingInProgress = false;

            }

            else

            {

                m_PreviewSampling = value * m_AdaptiveSampling;

                m_StretchingInProgress = true;

            }

        }


        // Returns the number of clipped pixels, if that's being computed.

        int getNumClipped()

        {

            return m_NumClipped;

        }


        QRect getSelectionRegion() const

        {

            return selectionRectangleRaw;

        }


        void emitZoom();


    public slots:

        void wheelEvent(QWheelEvent *event) override;

        void resizeEvent(QResizeEvent *event) override;

        void ZoomIn();

        void ZoomOut();

        void ZoomDefault();

        void ZoomToFit();

        void updateMagnifyingGlass(int x, int y);


        // Grids

        void toggleEQGrid();

        void toggleObjects();

        void togglePixelGrid();

        void toggleCrosshair();


        // HiPS

        void toggleHiPSOverlay();


        //Selection Rectngle

        void toggleSelectionMode();


        // Stars

        void toggleStars();

        void toggleStarProfile();

        void viewStarProfile();


        void centerTelescope();


        void toggleStretch();

        void toggleClipping();


        virtual void processPointSelection(int x, int y);

        virtual void processMarkerSelection(int x, int y);

        void processHighlight(int x, int y);

        void processCircle(QPoint p1, QPoint p2);


        void move3DTrackingBox(int x, int y);

        void resizeTrackingBox(int newSize);

        void processRectangle(QPoint p1, QPoint p2, bool refreshCenter = false);

        void processRectangleFixed(int s);


        /**

             * @brief syncWCSState Update toolbar and actions depending on whether WCS is available or not

             */

        void syncWCSState();


    protected slots:

        bool event(QEvent *event) override;

        bool gestureEvent(QGestureEvent *event);

        void pinchTriggered(QPinchGesture *gesture);


    protected:

        double average();

        double stddev();

        void calculateMaxPixel(double min, double max);

        void initDisplayImage();


        QPointF getPointForGridLabel(QPainter *painter, const QString &str, double scale);

        bool pointIsInImage(QPointF pt, double scale);


        void loadInFrame();


        double getScale();


        /// selectionRectangleRaw is used to do the calculations, this rectangle remains the same when user changes the zoom

        QRect selectionRectangleRaw;

        /// Floating toolbar

        QToolBar *floatingToolBar { nullptr };

        /// WCS Future Watcher

        QFutureWatcher<bool> wcsWatcher;

        /// FITS Future Watcher

        QFutureWatcher<bool> fitsWatcher;

        /// Cross hair

        QPointF markerCrosshair;

        /// Pointer to FITSData object

        QSharedPointer<FITSData> m_ImageData;

        /// Current zoom level

        double currentZoom { 0 };

        // The maximum percent zoom. The value is recalculated in the constructor

        // based on the amount of physical memory.

        int zoomMax { 400 };

        /// Image Buffer if Selection is to be done

        uint8_t *m_ImageRoiBuffer { nullptr };

        /// Above buffer size in bytes

        uint32_t m_ImageRoiBufferSize { 0 };


    private:

        bool processData();

        void doStretch(QImage *outputImage);

        double scaleSize(double size);

        bool isLargeImage();

        bool initDisplayPixmap(QImage &image, float space);

        void updateFrameLargeImage();

        void updateFrameSmallImage();

        bool drawHFR(QPainter * painter, const QString &hfr, int x, int y);


        QPointer<QLabel> noImageLabel;

        QPixmap noImage;

        QPointer<FITSLabel> m_ImageFrame;

        QVector<QPointF> eqGridPoints;


        /// Current width due to zoom

        uint16_t currentWidth { 0 };

        /// Current height due to zoom

        uint16_t currentHeight { 0 };

        /// Image zoom factor

        const double m_ZoomFactor;


        // Original full-size image

        QImage rawImage;

        // Actual pixmap after all the overlays

        QPixmap displayPixmap;


        bool firstLoad { true };

        bool markStars { false };

        bool showStarProfile { false };

        bool showCrosshair { false };

        bool showObjects { false };

        bool showEQGrid { false };

        bool showPixelGrid { false };

        bool showHiPSOverlay { false };

        bool showStarsHFR { false };

        bool showClipping { false };


        int m_NumClipped { 0 };


        bool showSelectionRect { false };


        // Should the image be displayed in linear (false) or stretched (true).

        // Initial value controlled by Options::autoStretch.

        bool stretchImage { false };


        // When stretching, should we automatically compute parameters.

        // When first displaying, this should be true, but may be set to false

        // if the user has overridden the automatically set parameters.

        bool autoStretch { true };


        // Params for stretching image.

        StretchParams stretchParams;


        // Resolution for display. Sampling=2 means display every other sample.

        uint8_t m_PreviewSampling { 1 };

        bool m_StretchingInProgress { false};

        // Adaptive sampling is based on available RAM

        uint8_t m_AdaptiveSampling {1};


        // mask for star detection

        QSharedPointer<ImageMask> m_ImageMask;


        CursorMode cursorMode { selectCursor };

        bool zooming { false };

        int zoomTime { 0 };

        QPoint zoomLocation;


        QString filename;

        FITSMode mode;

        FITSScale filter;

        QString m_LastError;

        QTimer m_UpdateFrameTimer;


        QStack<FITSScale> filterStack;


        // Tracking box

        bool trackingBoxEnabled { false };

        QRect trackingBox;

        QPixmap trackingBoxPixmap;

        QPixmap m_HiPSOverlayPixmap;


        // Scope pixmap

        QPixmap redScopePixmap;

        // Magenta Scope Pixmap

        QPixmap magentaScopePixmap;


        QAction *centerTelescopeAction { nullptr };

        QAction *toggleEQGridAction { nullptr };

        QAction *toggleObjectsAction { nullptr };

        QAction *toggleStarsAction { nullptr };

        QAction *toggleProfileAction { nullptr };

        QAction *toggleStretchAction { nullptr };

        QAction *toggleHiPSOverlayAction { nullptr };


        // State for the magnifying glass overlay.

        int magnifyingGlassX { -1 };

        int magnifyingGlassY { -1 };

        bool showMagnifyingGlass { false };

        bool m_Suspended {false};

        // Schedule updated when we have changes that adds

        // information to the view (not just zoom)

        bool m_QueueUpdate {false};


        QMutex updateMutex;


        //Star Profile Viewer

#ifdef HAVE_DATAVISUALIZATION

        QPointer<StarProfileViewer> starProfileWidget;

#endif


    signals:

        void newStatus(const QString &msg, FITSBar id);

        void newStretch(const StretchParams &params);

        void debayerToggled(bool);

        void wcsToggled(bool);

        void actionUpdated(const QString &name, bool enable);

        void trackingStarSelected(int x, int y);

        void loaded();

        void updated();

        void failed(const QString &error);

        void starProfileWindowClosed();

        void rectangleUpdated(QRect roi);

        void setRubberBand(QRect rect);

        void showRubberBand(bool on = false);

        void zoomRubberBand(double scale);

        void mouseOverPixel(int x, int y);

        void catLoaded();

        void catQueried();

        void catQueryFailed(const QString text);

        void catReset();

        void catHighlightChanged(const int highlight);

        void headerChanged();


        friend class FITSLabel;

};

QAction

QEnterEvent

QEvent

QFuture

QFutureWatcher

QGestureEvent

QImage

QLabel

QMutex

QObject::Q_OBJECT
Q_OBJECTQ_OBJECT

QObject::Q_PROPERTY
Q_PROPERTY(...)

QObject::parent
QObject * parent() const const

QPainter

QPinchGesture

QPixmap

QPoint

QPointer

QPointF

QRect

QResizeEvent

QScrollArea

QSharedPointer

QStack

QStack::pop
T pop()

QStack::push
void push(const T &t)

QString

QTimer

QToolBar

QVector

QWheelEvent

QWidget

QWidget::mask
QRegion mask() const const

QWidget::rect
rect

QWidget::size
size

QWidget::x
x

QWidget::y
y