indiccdchip.h

Go to the documentation of this file.

/*******************************************************************************
 Copyright(c) 2019 Jasem Mutlaq. All rights reserved.
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Library General Public
 License version 2 as published by the Free Software Foundation.
 
 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 Library General Public License for more details.
 
 You should have received a copy of the GNU Library General Public License
 along with this library; see the file COPYING.LIB.  If not, write to
 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 Boston, MA 02110-1301, USA.
*******************************************************************************/
 
#pragma once
 
#include "indiapi.h"
#include "indidriver.h"
#include "indipropertyswitch.h"
#include "indipropertyblob.h"
 
#include "indipropertynumber.h"
 
#include <sys/time.h>
#include <stdint.h>
#include <fitsio.h>
 
namespace INDI
{
 
class CCDChip
{
    public:
        CCDChip();
        ~CCDChip();
 
        typedef enum { LIGHT_FRAME = 0, BIAS_FRAME, DARK_FRAME, FLAT_FRAME } CCD_FRAME;
        typedef enum { FRAME_X, FRAME_Y, FRAME_W, FRAME_H } CCD_FRAME_INDEX;
        typedef enum { BIN_W, BIN_H } CCD_BIN_INDEX;
        typedef enum
        {
            CCD_MAX_X,
            CCD_MAX_Y,
            CCD_PIXEL_SIZE,
            CCD_PIXEL_SIZE_X,
            CCD_PIXEL_SIZE_Y,
            CCD_BITSPERPIXEL
        } CCD_INFO_INDEX;
 
        bool openFITSFile(uint32_t size, int &status);
 
 
        bool finishFITSFile(int &status);
 
        void closeFITSFile();
 
        inline int getXRes() const
        {
            return XRes;
        }
 
        inline int getYRes() const
        {
            return YRes;
        }
 
        inline int getSubX() const
        {
            return SubX;
        }
 
        inline int getSubY() const
        {
            return SubY;
        }
 
        inline int getSubW() const
        {
            return SubW;
        }
 
        inline int getSubH() const
        {
            return SubH;
        }
 
        inline int getBinX() const
        {
            return BinX;
        }
 
        inline int getBinY() const
        {
            return BinY;
        }
 
        inline float getPixelSizeX() const
        {
            return PixelSizeX;
        }
 
        inline float getPixelSizeY() const
        {
            return PixelSizeY;
        }
 
        inline int getBPP() const
        {
            return BitsPerPixel;
        }
 
        inline int getFrameBufferSize() const
        {
            return RawFrameSize;
        }
 
        inline double getExposureLeft() const
        {
            return ImageExposureNP[0].getValue();
        }
 
        inline double getExposureDuration() const
        {
            return ExposureDuration;
        }
 
        const char *getExposureStartTime();
 
        inline uint8_t *getFrameBuffer()
        {
            return RawFrame;
        }
 
        void setFrameBuffer(uint8_t *buffer)
        {
            RawFrame = buffer;
        }
 
        inline bool isCompressed() const
        {
            return SendCompressed;
        }
 
        //        inline bool isInterlaced()
        //        {
        //            return Interlaced;
        //        }
 
        inline CCD_FRAME getFrameType() const
        {
            return FrameType;
        }
 
        const char *getFrameTypeName(CCD_FRAME fType);
 
        INDI::PropertyNumber getCCDInfo()
        {
            return ImagePixelSizeNP;
        }
 
        void setResolution(uint32_t x, uint32_t y);
 
        void setFrame(uint32_t subx, uint32_t suby, uint32_t subw, uint32_t subh);
 
        void setBin(uint8_t hor, uint8_t ver);
 
        void setMinMaxStep(const char *property, const char *element, double min, double max, double step,
                           bool sendToClient = true);
 
        void setPixelSize(double x, double y);
 
        void setCompressed(bool cmp);
 
        //        /**
        //         * @brief setInterlaced Set whether the CCD chip is interlaced or not?
        //         * @param intr If true, the CCD chip is interlaced.
        //         */
        //        void setInterlaced(bool intr);
 
        void setFrameBufferSize(uint32_t nbuf, bool allocMem = true);
 
        void setBPP(uint8_t bpp);
 
        void setFrameType(CCD_FRAME type);
 
        void setExposureDuration(double duration);
 
        void setExposureLeft(double duration);
 
        void setExposureComplete();
 
        void setExposureFailed();
 
        int getNAxis() const;
 
        void setNAxis(int value);
 
        void setImageExtension(const char *ext);
 
        char *getImageExtension()
        {
            return ImageExtention;
        }
 
        bool isExposing() const
        {
            return (ImageExposureNP.getState() == IPS_BUSY);
        }
 
        void binFrame();
 
        void binBayerFrame();
 
        fitsfile **fitsFilePointer()
        {
            return &m_FITSFilePointer;
        }
 
        size_t * fitsMemorySizePointer()
        {
            return &m_FITSMemorySize;
        }
 
        void ** fitsMemoryBlockPointer()
        {
            return &m_FITSMemoryBlock;
        }
 
    private:
 
        uint32_t XRes {0};
        uint32_t YRes {0};
        uint32_t SubX {0};
        uint32_t SubY {0};
        uint32_t SubW {0};
        uint32_t SubH {0};
        uint8_t BinX {1};
        uint32_t BinY {1};
        uint8_t NAxis {2};
        double PixelSizeX {0};
        double PixelSizeY {0};
        uint8_t BitsPerPixel {8};
        //bool Interlaced {false};
        // RAW Frame for image data stored as bytes.
        uint8_t *RawFrame {nullptr};
        // RAW Frame size in bytes.
        uint32_t RawFrameSize {0};
        // BINNED Frame when software binning is used.
        uint8_t *BinFrame {nullptr};
        // Should we compress frame before transmission?
        bool SendCompressed {false};
        // Frame Type
        CCD_FRAME FrameType {LIGHT_FRAME};
        // Exposure duration in seconds.
        double ExposureDuration {0};
        // Exposure startup time
        timeval StartExposureTime;
        // Image extension type (e.g. jpg)
        char ImageExtention[MAXINDIBLOBFMT];
        void * m_FITSMemoryBlock {nullptr};
        size_t m_FITSMemorySize {2880};
        fitsfile * m_FITSFilePointer {nullptr};
 
 
        INDI::PropertyNumber ImageExposureNP {1};
 
        INDI::PropertySwitch AbortExposureSP {1};
 
        INDI::PropertyNumber ImageFrameNP {4};
 
        INDI::PropertyNumber ImageBinNP{2};
        enum
        {
            HOR_BIN,
            VER_BIN
        };
        INDI::PropertyNumber ImagePixelSizeNP {6};
 
        INDI::PropertySwitch FrameTypeSP {4};
 
        INDI::PropertySwitch CompressSP {2};
        INDI::PropertyBlob FitsBP {1};
 
        INDI::PropertySwitch ResetSP{1};
 
        friend class CCD;
        friend class StreamRecoder;
 
#if 0
        ISwitch RapidGuideS[2];
        ISwitchVectorProperty RapidGuideSP;
 
        ISwitch RapidGuideSetupS[3];
        ISwitchVectorProperty RapidGuideSetupSP;
 
        INumber RapidGuideDataN[3];
        INumberVectorProperty RapidGuideDataNP;
#endif
 
};
 
}