camd.h

/* 
 * Basic camera daemon.
 * Copyright (C) 2001-2012 Petr Kubanek <petr@kubanek.net>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */

#ifndef __RTS2_CAMERA_CPP__
#define __RTS2_CAMERA_CPP__

#include <sys/time.h>
#include <time.h>

#include "scriptdevice.h"
#include "imghdr.h"

#define MAX_CHIPS  3
#define MAX_DATA_RETRY 100

#define STATISTIC_YES     0
#define STATISTIC_ONLY    1
#define STATISTIC_NO      2

namespace rts2camd
{

class Binning2D: public rts2core::Rts2SelData
{
        public:
                int vertical;

                int horizontal;

                Binning2D (int in_vertical, int in_horizontal): Rts2SelData ()
                {
                        vertical = in_vertical;
                        horizontal = in_horizontal;
                }

                std::string getDescription ()
                {
                        std::ostringstream _os;
                        _os << horizontal << "x" << vertical;
                        return _os.str();
                }
};

class DataType: public rts2core::Rts2SelData
{
        public:
                int type;

                DataType (int in_type): Rts2SelData ()
                {
                        type = in_type;
                }
};

class Camera;

class FilterVal
{
        public:
                FilterVal (Camera *master, const char *n, char fil);
                // values are registered in class, hence autodeleted when class holding them is deleted - so there isn't class destructor
                rts2core::ValueSelection *filter;
                rts2core::DoubleArray *offsets;
                rts2core::ValueBool *moving;

                const char *name;
};

class Camera:public rts2core::ScriptDevice
{
        public:
                Camera (int argc, char **argv);
                virtual ~ Camera (void);

                virtual int deleteConnection (rts2core::Connection * conn);
                virtual bool supportFrameTransfer ();

                // end of CameraChip

                virtual int initChips ();
                virtual int initValues ();
                void checkExposures ();
                void checkReadouts ();

                virtual void deviceReady (rts2core::Connection * conn);

                virtual void postEvent (rts2core::Event * event);

                virtual void changeMasterState (int old_state, int new_state);

                virtual int idle ();

                virtual rts2core::DevClient *createOtherType (rts2core::Connection * conn, int other_device_type);
                virtual int info ();

                virtual int killAll (bool callScriptEnds);
                virtual int scriptEnds ();

                virtual long camWaitExpose ();

                virtual int switchCooling (bool newval) { return 0; }

                virtual int setCoolTemp (float new_temp)
                {
                        tempSet->setValueDouble (new_temp);
                        sendValueAll (tempSet);
                        return 0;
                }

                virtual void beforeNight ()
                {
                        if (nightCoolTemp && !isnan (nightCoolTemp->getValueFloat ()))
                        {
                                switchCooling (true);
                                setCoolTemp (nightCoolTemp->getValueFloat ());
                        }
                }
                
                virtual void afterNight ()
                {
                        switchCooling (false);
                }

                virtual int readoutStart ();

                int camReadout (rts2core::Connection * conn);

                // focuser functions
                int setFocuser (int new_set);
                int getFocPos ();

                bool isIdle ();

                int getLastFilterNum ()
                {
                        return lastFilterNum;
                }

                virtual int commandAuthorized (rts2core::Connection * conn);

                virtual int maskQueValueBopState (int new_state, int valueQueCondition);

                virtual void setFullBopState (int new_state);

        protected:
                double pixelX;
                double pixelY;

                // buffer used to read data
                char* getDataBuffer (int chan);
                char* getDataTop (int chan);

                void addFilters (char *opt);

                void addFilterOffsets ();

                rts2core::ValueSelection * camFilterVal;
                rts2core::DoubleArray *camFilterOffsets;

                rts2core::ValueString *filterOffsetFile;

                // for multiple filter wheels
                std::list <FilterVal> camFilterVals;

                double getExposureEnd ()
                {
                        return exposureEnd->getValueDouble ();
                }

                void changeExposureEnd (double off)
                {
                        exposureEnd->setValueDouble (exposureEnd->getValueDouble () + off);
                }

                void nullExposureConn () { exposureConn = NULL; }

                rts2core::ValueInteger *quedExpNumber;

                rts2core::ValueSelection *expType;

                void changeAxisDirections (bool x_orig, bool y_orig);

                long getExposureNumber () { return exposureNumber->getValueLong (); }

                long getScriptExposureNumber () { return scriptExposureNum->getValueLong (); }

                void incExposureNumber ()
                {
                        exposureNumber->inc ();
                        sendValueAll (exposureNumber);
                        scriptExposureNum->inc ();
                        sendValueAll (scriptExposureNum);
                }

                const int getDataType ()
                {
                        return ((DataType *) dataType->getData ())->type;
                }

                void setDataType (int ntype) { dataType->setValueInteger (ntype); }

                void setDataTypeWritable () { dataType->setWritable (); }

                int nAcc;
                struct imghdr *focusingHeader;

                int sendImage (char *data, size_t dataSize);

                int sendReadoutData (char *data, size_t dataSize, int chan = 0);

                int fitsDataTransfer (const char *fn)
                {
                        if (exposureConn)
                                return exposureConn->fitsDataTransfer (fn);
                        return 0;
                }
                
                long getWriteBinaryDataSize ()
                {
                        if (currentImageData < 0 && calculateStatistics->getValueInteger () == STATISTIC_ONLY)
                                // end bytes
                                return calculateDataSize;
                        if (exposureConn)
                                return exposureConn->getWriteBinaryDataSize (currentImageData);
                        return 0;
                }

                long getWriteBinaryDataSize (int chan)
                {
                        if (currentImageData < 0 && calculateStatistics->getValueInteger () == STATISTIC_ONLY)
                                // end bytes
                                return calculateDataSize;
                        if (exposureConn)
                                return exposureConn->getWriteBinaryDataSize (currentImageData, chan);
                        return 0;
                }

                void addBinning2D (int bin_v, int bin_h);

                virtual void initBinnings ();

                void addDataType (int in_type);

                virtual void initDataTypes ();

                int binningHorizontal () { return binningX->getValueInteger (); }

                int binningVertical () { return binningY->getValueInteger (); }

                const int usedPixelByteSize ()
                {
                        if (getDataType () == RTS2_DATA_ULONG)
                                return 4;
                        return abs (getDataType () / 8);
                }

                const int maxPixelByteSize ();

                size_t chipUsedSize () { return getUsedWidthBinned () * getUsedHeightBinned (); }

                size_t getReadoutPixels () { return readoutPixels; }


                virtual size_t chipByteSize () { return chipUsedSize () * usedPixelByteSize (); }

                size_t lineByteSize () { return usedPixelByteSize () * (chipUsedReadout->getWidthInt ()); }

                virtual int processData (char *data, size_t size);

                rts2core::ValueRectangle *chipUsedReadout;

                virtual int processOption (int in_opt);

                virtual void usage ();

                int willConnect (rts2core::NetworkAddress * in_addr);
                char *device_file;
                // number of data channels
                rts2core::ValueInteger *dataChannels;
                // which channels are off (and which are on)
                rts2core::BoolArray *channels;

                rts2core::ValueBool *coolingOnOff;
                // temperature and others; all in deg Celsius
                rts2core::ValueFloat *tempAir;
                rts2core::ValueFloat *tempCCD;
                rts2core::ValueDoubleStat *tempCCDHistory;
                rts2core::ValueInteger *tempCCDHistoryInterval;
                rts2core::ValueInteger *tempCCDHistorySize;
                rts2core::ValueDoubleMinMax *tempSet;

                // night cooling temperature
                rts2core::ValueFloat *nightCoolTemp;

                char ccdType[64];
                char *ccdRealType;
                char serialNumber[64];

                virtual void checkQueChanges (int fakeState);

                void checkQueuedExposures ();

                void initCameraChip ();
                void initCameraChip (int in_width, int in_height, double in_pixelX, double in_pixelY);

                virtual int startExposure () = 0;

                virtual void afterReadout ();

                virtual int endReadout ();

                virtual int doReadout () = 0;

                void clearReadout ();

                void setSize (int in_width, int in_height, int in_x, int in_y)
                {
                        chipSize->setInts (in_x, in_y, in_width, in_height);
                        chipUsedReadout->setInts (in_x, in_y, in_width, in_height);
                }

                void setUsedHeight (int in_height)
                {
                        chipUsedReadout->setHeight (in_height);
                }

                virtual size_t suggestBufferSize () { return chipByteSize (); }

                const int getWidth () { return chipSize->getWidthInt (); }

                const int getUsedWidth () { return chipUsedReadout->getWidthInt (); }

                const int getUsedWidthBinned () { return (int) (ceil (getUsedWidth () / binningHorizontal ())); }

                const int getUsedRowBytes () { return getUsedWidthBinned () * usedPixelByteSize (); }

                const int getHeight () { return chipSize->getHeightInt (); }

                const int getUsedY () { return chipUsedReadout->getYInt (); }

                const int getUsedX () { return chipUsedReadout->getXInt (); }

                const int getUsedHeight () { return chipUsedReadout->getHeightInt (); }

                const int getUsedHeightBinned () { return (int) (ceil (getUsedHeight () / binningVertical ())); }

                const int chipTopX () { return chipUsedReadout->getXInt (); }

                const int chipTopY () { return chipUsedReadout->getYInt (); }

                virtual int setBinning (int in_vert, int in_hori);

                int center (int in_w, int in_h);

                virtual long isExposing ();

                virtual int endExposure ();

                virtual int stopExposure ();

                virtual int setValue (rts2core::Value * old_value, rts2core::Value * new_value);

                virtual void valueChanged (rts2core::Value *changed_value);

                void createExpType ()
                {
                        createValue (expType, "SHUTTER", "shutter state", true, RTS2_VALUE_WRITABLE);
                        expType->addSelVal ("LIGHT", NULL);
                        expType->addSelVal ("DARK", NULL);
                }

                void createFilter (bool working = false)
                {
                        if (camFilterVal == NULL)
                                createValue (camFilterVal, "filter", "used filter number", false, RTS2_VALUE_WRITABLE, working ? CAM_WORKING : CAM_EXPOSING);
                        if (camFilterOffsets == NULL)
                                createValue (camFilterOffsets, "filter_offsets", "filter offsets", false, RTS2_VALUE_WRITABLE);
                }

                void addShutterType (const char *enumName, rts2core::Rts2SelData *data = NULL) { expType->addSelVal (enumName, data); }

                void createDataChannels ()
                { 
                        createValue (dataChannels, "DATA_CHANNELS", "total number of data channels", true);
                        createValue (channels, "CHAN", "channels on/off", true, RTS2_DT_ONOFF | RTS2_VALUE_WRITABLE | RTS2_FITS_HEADERS, CAM_WORKING);
                }

                void setNumChannels (int num)
                {
                        channels->clear ();
                        for (int i = 0; i < num; i++)
                                channels->addValue (true);
                }

                int getNumChannels ()
                {
                        if (channels == NULL)
                                return 1;
                        return channels->size ();
                }

                void createTempAir () { createValue (tempAir, "CCD_AIR", "detector air temperature"); }

                void createTempCCD () { createValue (tempCCD, "CCD_TEMP", "CCD temperature"); }

                void createTempCCDHistory () {
                        createValue (tempCCDHistory, "ccd_temp_history", "history of ccd temperatures", false);
                        createValue (tempCCDHistoryInterval, "ccd_temp_interval", "interval in seconds between repeative queries of CCD temperature", false);
                        createValue (tempCCDHistorySize, "ccd_temp_size", "interval in seconds between repeative queries of CCD temperature", false);

                        tempCCDHistoryInterval->setValueInteger (2);
                        tempCCDHistorySize->setValueInteger (20);
                }

                void addTempCCDHistory (float temp);

                virtual void temperatureCheck () {};

                void createTempSet ()
                {
                        createValue (coolingOnOff, "COOLING", "camera cooling start/stop", true, RTS2_VALUE_WRITABLE | RTS2_DT_ONOFF, CAM_WORKING);
                        createValue (tempSet, "CCD_SET", "CCD set temperature", true, RTS2_VALUE_WRITABLE, CAM_WORKING);
                        createValue (nightCoolTemp, "nightcool", "night cooling temperature", false, RTS2_VALUE_WRITABLE);
                        nightCoolTemp->setValueFloat (NAN);
                        addOption ('c', NULL, 1, "night cooling temperature");
                }

                double getExposure () { return exposure->getValueDouble (); }

                void setExposureMinMax (double exp_min, double exp_max);

                virtual void setExposure (double exp) { exposure->setValueDouble (exp); }

                int getExpType () { return expType->getValueInteger (); }

                virtual int setFilterNum (int new_filter, const char *fn = NULL);
                virtual int getFilterNum (const char *fn = NULL);

                void offsetForFilter (int new_filter, std::list <FilterVal>::iterator fvi);

                int getCamFilterNum () { return camFilterVal->getValueInteger (); }

                void setFilterWorking (bool working) { getCondValue (camFilterVal)->setStateCondition (working ? CAM_WORKING : CAM_EXPOSING); } 

                void markReadoutStart () { timeReadoutStart = getNow (); }

                void updateReadoutSpeed (size_t computedPixels)
                {
                        if (!isnan (timeReadoutStart))
                        {
                                readoutTime->setValueDouble (getNow () - timeReadoutStart);
                                sendValueAll (readoutTime);

                                pixelsSecond->setValueDouble (computedPixels / readoutTime->getValueDouble ());
                                sendValueAll (pixelsSecond);

                                // end computation of readout time
                                if (computedPixels >= readoutPixels)
                                        timeReadoutStart = NAN;
                        }
                }

                void setFitsTransfer () { currentImageTransfer = FITS; }

        private:
                size_t readoutPixels;
                // data buffers - separated for each channel
                char** dataBuffers;
                size_t *dataWritten;

                // readout - ideally time for data->computer. Camera driver should start markReadoutStart and markReadoutEnd to mark start/end times
                double timeReadoutStart;
                // readout time including transfer (TCP/IP,..) overhead
                double timeTransferStart;

                // focusing header data
                struct imghdr *fhd;

                // physical readout time from device
                rts2core::ValueDouble *pixelsSecond;
                rts2core::ValueDouble *readoutTime;

                // data time including transfer overhead
                rts2core::ValueDouble *transferTime;

                // connection which requries data to be send after end of exposure
                rts2core::Connection *exposureConn;

                rts2core::ValueDoubleMinMax *exposure;

                // shared memory identifier
                int sharedMemNum;
                rts2core::DataSharedWrite *sharedData;

                // number of exposures camera takes
                rts2core::ValueLong *exposureNumber;
                // exposure number inside script
                rts2core::ValueLong *scriptExposureNum;
                rts2core::ValueBool *waitingForEmptyQue;
                rts2core::ValueBool *waitingForNotBop;

                rts2core::ValueInteger *binningX;
                rts2core::ValueInteger *binningY;

                char *focuserDevice;
                std::vector < const char * > wheelDevices;

                int lastFilterNum;

                int currentImageData;
                // true if current image is send over shared connection
                enum { TCPIP, SHARED, FITS } currentImageTransfer;

                // whenewer statistics should be calculated
                rts2core::ValueSelection *calculateStatistics;

                // image parameters
                rts2core::ValueDouble *average;
                rts2core::ValueDouble *min;
                rts2core::ValueDouble *max;
                rts2core::ValueDouble *sum;

                rts2core::ValueLong *computedPix;

                rts2core::ValueBool *calculateCenter;

                rts2core::ValueRectangle *centerBox;

                rts2core::ValueDouble *centerCutLevel;

                rts2core::DoubleArray *sumsX;
                rts2core::DoubleArray *sumsY;

                // center values
                rts2core::ValueDouble *centerX;
                rts2core::ValueDouble *centerY;

                // update statistics
                template <typename t> int updateStatistics (t *data, size_t dataSize)
                {
                        long double tSum = 0;
                        double tMin = min->getValueDouble ();
                        double tMax = max->getValueDouble ();
                        int pixNum = 0;
                        t *tData = data;
                        while (((char *) tData) < ((char *) data) + dataSize)
                        {
                                t tD = *tData;
                                tSum += tD;
                                if (tD < tMin)
                                        tMin = tD;
                                if (tD > tMax)
                                        tMax = tD;
                                tData++;
                                pixNum++;
                        }
                        sum->setValueDouble (sum->getValueDouble () + tSum);
                        if (tMin < min->getValueDouble ())
                                min->setValueDouble (tMin);
                        if (tMax > max->getValueDouble ())
                                max->setValueDouble (tMax);
                        return pixNum;
                }

                // update center box
                template <typename t> int updateCenter (t *data, size_t dataSize)
                {
                        // check if box is inside window
                        int x = centerBox->getXInt ();
                        if (x < 0)
                                x = getUsedX ();
                        int y = centerBox->getYInt ();
                        if (y < 0)
                                y = getUsedY ();
                        int w = centerBox->getWidthInt () / binningHorizontal ();
                        if (w < 0)
                                w = (getUsedWidth () - (x - getUsedX ())) / binningHorizontal ();
                        int h = centerBox->getHeightInt () / binningVertical ();
                        if (h < 0)
                                h = (getUsedHeight () - (y - getUsedY ())) / binningVertical ();
                        
                        x -= getUsedX ();
                        y -= getUsedY ();

                        if (x < 0 || y < 0 || (w + ceil ((double) x / binningHorizontal ())) > getUsedWidthBinned () || (h + ceil ((double) y / binningVertical ())) > getUsedHeightBinned ())
                                return -1;

                        t *tData = data;
                        // move to the first calculated pixel
                        tData += y * getUsedWidthBinned () + x;

                        int i;

                        double sx[w];
                        for (i = 0; i < w; i++)
                                sx[i] = 0;

                        sumsY->clear ();

                        for (int row = 0; row < h; row++)
                        {
                                double rs = 0;
                                for (int col = 0; col < w; col++, tData++)
                                {
                                        if (*tData >= centerCutLevel->getValueDouble ())
                                        {
                                                sx[col] += *tData;
                                                rs += *tData;
                                        }
                                }

                                sumsY->addValue (rs);
                        }

                        sumsX->clear ();

                        for (i = 0; i < w; i++)
                                sumsX->addValue (sx[i]);

                        sendValueAll (sumsX);
                        sendValueAll (sumsY);

                        centerX->setValueDouble (sumsX->calculateMedianIndex ());
                        centerY->setValueDouble (sumsY->calculateMedianIndex ());

                        sendValueAll (centerX);
                        sendValueAll (centerY);

                        return 0;
                }

                char multi_wcs;

                // WCS CRPIX
                rts2core::ValueDouble *wcs_crpix1;
                rts2core::ValueDouble *wcs_crpix2;

                double default_crpix[2];

                // WCS CD matrix
                rts2core::ValueString *wcs_ctype1;
                rts2core::ValueString *wcs_ctype2;
                rts2core::ValueDouble *wcs_cdelta1;
                rts2core::ValueDouble *wcs_cdelta2;
                rts2core::ValueDouble *wcs_crota;

                // 1:1 binning, default WCS - cdelta1,cdelta2,crota
                double default_cd[3];

                rts2core::ValueRectangle *chipSize;

                int camStartExposure ();
                int camStartExposureWithoutCheck ();

                rts2core::ValueInteger *camFocVal;

                int getStateChip (int chip);

                // chip binning
                rts2core::ValueSelection *binning;

                // allowed chip data type
                rts2core::ValueSelection *dataType;

                // when chip exposure will end
                rts2core::ValueTime *exposureEnd;

                // filter wheel is moving
                rts2core::ValueBool *focuserMoving;

                // set chipUsedSize size
                int box (int _x, int _y, int _width, int _height, rts2core::ValueRectangle *retv = NULL);

                // callback functions from camera connection
                int camExpose (rts2core::Connection * conn, int chipState, bool fromQue);
                int camBox (rts2core::Connection * conn, int x, int y, int width, int height);
                int camCenter (rts2core::Connection * conn, int in_w, int in_h);

                int getPhysicalChannel (int ch);

                void startImageData (rts2core::Connection * conn);

                int sendFirstLine (int chan, int pchan);

                // if true, send command OK after exposure is started
                bool sendOkInExposure;

                long calculateDataSize;

                void setFilterOffsets (char *opt);

                bool filterMoving ();

                void setFilterOffsetFile (const char *filename);

                std::map <std::string, double> filterOffsets;
};

}

#endif                                                   /* !__RTS2_CAMERA_CPP__ */