daseq32.h

相机传输图像程序源代码 拜耳模式（RAW格式文件）与RGB图像数据互相转换函数库

                 * the \a DaSeq32Cfg configuration structure, it can be stopped only by calling
                 * the Stop() command.
                 * @return \b TRUE if the Sequencer Dral is active. Otherwise \b FALSE
                 * @sa Start(), Stop(), IsPaused()
                 */
                BOOL   IsRunning(void);

                /** Retrieves the actual priority for the DRAL thread.
                 * Use this function to determine the actual priority for the internal DRAL
                 * thread. This thread is involved in the notification process, therefore its
                 * priority has to be set in a way it can perform its task.
                 * @return The current DRAL thread priority. One of the Windows' definitions
                 *         \b THREAD_PRIORITY_XXX.
                 */
                int    GetThreadPriority(void);
                /** Sets the actual priority for the DRAL thread.
                 * Use this function to set the actual priority for the internal DRAL thread.\n
                 * This thread is involved in the notification process, therefore its priority has
                 * to be set in a way it can perform its task.
                 * @param Priority One of the Windows' definitions \b THREAD_PRIORITY_XXX.
                 */
                void   SetThreadPriority(int Priority);

                /* dont document - Sets a Dral internal variable.
                 * This function sets the specified value in the specified variable. It can be
                 * called after the Dral activation and during the Dral execution. Depending
                 * on the variable the effect might not be immediate.\n
                 * Applications should not use this function, as each specific class provides
                 * method to properly set, in a controlled way, its Dral variables.
                 * @param VarName ASCII string with the name of the variable to be set
                 * @param Value Value to set in the variable
                 * @param RPS RPS id where the variable is stored; it can assume values 0 or 1
                 * @return \ref ErrorDefinitions
                 */
                LVSTATUS SetVariable(char *VarName, U32BIT Value, int RPS=0);
                /* dont document - Retrieves a RPS variable current value.
                 * This function retrieves the current value of the specified variable.\n
                 * This function can be called after the DRAL activation and for all the time of
                 * DRAL execution.\n
                 * Applications should not use this function, as each specific class provides
                 * method to properly get, and eventually adjust, its Dral variables.
                 * @param VarName ASCII string with the name of the variable to be retreived
                 * @param Value Pointer to a 32-bit value to receive the actual variable content
                 * @param RPS RPS id where the variable is stored; it can assume values 0 or 1
                 * @return @ref ErrorDefinitions
                 */
                LVSTATUS GetVariable(char *VarName, U32BIT *Value, int RPS=0);

                /** Checks the waiting state of the Sequencer Dral.
                 * During execution, the Sequencer Dral can enter wait states determined by
                 * either the user configuration or an explicit Pause command issued by the
                 * application.\n
                 * This method determines whether the Sequencer Dral is in such state,
                 * waiting for a Continue command from the application or, when
                 * configured, the optocoupler input, to proceed with the acquisition.
                 * @return \b TRUE if the Sequencer Dral is waiting for commands, or \b FALSE when
                 *         it is acquiring
                 * @sa Pause(), Continue()
                 */
                BOOL IsPaused(void);
                
                /** Checks the successfull compilation of the Dral code.
                 * Safety check to determine whether a previous Activate() command was
                 * successful.\n
                 * The Activate() command returns anyway a specific error whenever a
                 * problem is detected during the compilation of the Dral code.
                 * @return \b TRUE if the Dral code was successfully compiled. When \b FALSE check
                 * the error returned by Activate() to determine the cause.
                 * @sa Activate()
                 */
                // BOOL IsCompiled(void);
                BOOL IsCompiled(void);
                /** Checks if the camera is properly locked.
                 * When the Sequencer Dral is active most of the Daisy operation cannot be
                 * safely performed.\n
                 * This method returns whether the camera is still properly locked, and
                 * makes sense to check it only when a master camera is involved in the
                 * acquisition. For slave cameras, where PicPort provides the timing to the
                 * cameras, this flag is always \b TRUE (camera locking ok).\n
                 * This flag is updated after each acquisition made by the Sequencer Dral.\n
                 * For master cameras, the grabber has to match their timing to have a wellsynchronized
                 * image. Changes of the operational temperature can affect
                 * the locking. Loosing the locking after some time after a cold boot of the
                 * system is normal.\n
                 * \n
                 * When this function returns \b FALSE, it is recommended to stop the
                 * Sequencer Dral and restart the whole initialization procedure,
                 * disconnecting the cameras.
                 * @param BoardNr in case of multiple boards involved in the
                 *                acquisition, this parameter determines which
                 *                board has to be checked.
                 * @return \b TRUE if the camera is properly locked, otherwise \b FALSE
                 * @sa Activate()
                 */
                BOOL IsCameraLocked(int BoardNr=0);

        /** Activates a user configuration.
         * Activates a DRAL configuration structure. The type of the structure
         * depends on the DRAL actually represented by the object of this class.
         * @param CfgBuffer Pointer to the configuration buffer of the
         *                  DRAL. This parameter can be NULL to mean
         *                  the DRAL will use the last configuration set
         *                  through the SetConfig() method or a
         *                  previous call to this method or the default
         *                  configuration.
         * @return One of the @ref ErrorDefinitions values. DSY_I_NoError when all right.
         */
        virtual LVSTATUS Activate(void *CfgBuffer=NULL);
        /** Sets the configuratin for the DRAL.
         * Sets the configuration structure for the DRAL. The type of the structure
         * depends on the DRAL actually represented by the object of this class.\n
         * A call to this function will \b NOT activate the passed configuration; its
         * activation has to be explicitly performed through a call to Activate().
         * @param CfgBuffer Pointer to the configuration buffer of the DRAL
         * @return One of the @ref ErrorDefinitions values. DSY_I_NoError when all right
         */
        virtual LVSTATUS SetConfig(void *CfgBuffer);
        /* dont document */
        virtual LVSTATUS SetRPSVariable(char *Name, RPSVariable *Var, U32BIT Value);
        /* dont document */
        virtual U32BIT GetRPSVariable(char *Name, RPSVariable *Var, U32BIT *Value=NULL);
        /* dont document */
        virtual U32BIT GetRPSStatus(void);

        /** Sets the external event handling mode for the Sequencer Dral.
         * Calling this function determines the way the Sequencer Dral handles the
         * input from the grabber optocoupler.\n
         * The check for the external event is considered equivalent to a Continue()
         * command from the application and checked in the same way on the
         * checkpoints determined by the Dral configuration in the FlowCheck field.\n
         * The Sequencer Dral can be set to ignore the external event, to consider
         * an external event as fully equivalent to a Continue() command, or to wait
         * for an explicit Continue() from the application and then wait for the
         * external event.
         * @param ExtEv_Mode one of the @ref DaSeq32_ExtEvent values
         * @return The value actually set
         * @sa GetExternalEvent(), Pause(), Continue(), IsPaused(), IsRunning()
         */
        virtual U32BIT SetExternalEvent(U32BIT ExtEv_Mode);
        /** Gets the actual external event handling mode for the Sequencer Dral.
         * Returns the external event handling mode actually set for the Sequencer
         * Dral.
         * See SetExternalEvent()
         * @return The actual external event-handling mode, one of the @ref DaSeq32_ExtEvent values
         * @sa SetExternalEvent(), Pause(), Continue(), IsPaused(), IsRunning()
         */
        virtual U32BIT GetExternalEvent(void);
        /** Sets the repetition delay for flow checks.
         * When the Sequencer Dral is pausing, waiting for an external event or a
         * Continue() command from the application, it is repeatedly checking the
         * optocoupler input and a memory location in the main system memory. By
         * default, the Sequencer puts no delay between two successive checks.\n
         * This could have an influence on the processor activity when it is accessing
         * the same memory for instruction fetch and eventual image processing.\n
         * The Sequencer Dral provides the possibility to put delays up to 7500
         * microseconds between two successive checks, minimizing in this way the
         * influence on the processor activity.\n
         * Note that increasing this delay influences the time the Sequencer Dral
         * detects the Continue() or the optocoupler input and could have undesired
         * effects on the acquisition timing.
         * @param FlowCheck_Delay one of the @ref DaSeq32_FlowCheckDelay values.
         * @sa GetFlowCheckDelay(), Pause(), Continue(), IsPaused()
         */
        virtual U32BIT SetFlowCheckDelay(U32BIT FlowCheck_Delay);
        /** Gets the actual checking delay time for the Sequencer Dral.
         * Returns the checking delay time actually set for the Sequencer Dral.\n
         * See SetFlowCheckDelay()
         * @return The actual checking delay time, one of the @ref DaSeq32_FlowCheckDelay values
         * @sa SetFlowCheckDelay(), Pause(), Continue(), IsPaused()
         */
        virtual U32BIT GetFlowCheckDelay(void);

        /* Returns the requested camera switches for the actual operation mode.
         * Obsolete. The function is no more supported.
         */
        virtual U32BIT GetCameraSwitch(void) { return Switch; }
        /* Returns the description of the specified camera hardware switch.
         * Obsolete. The function is no more supported.
         */
        virtual char  *GetCameraSwitchDescription(int Index) { return ""; }
        /* dont document */
        virtual U32BIT SetRestartSequence(U32BIT RestartMode);
        /* dont document */
        virtual U32BIT ReleaseSequence(void);
        /** Enables the Continue() flag on the specified image.
         * When in the Sequencer Dral configuration the FlowType field is set to
         * SqFlow_CheckOnImage, the application can control whether continuing
         * or not the acquisition after the acquisition of specific images.\n
         * When the Continue() flag for the image is reset, the Sequencer Dral enters
         * its waiting state, waiting for a Continue() from the application or for the
         * optocoupler input, when enabled.\n
         * Use this method to enable the acquisition after the specified image index.
         * @param ImageIndex Index of the image after which the Continue() flag has to be set.
         * @return \b DSY_I_NoError if the continue flag changed state otherwise \b DSY_W_RPS_ContinueAlreadySet,
         *         meaning the \a Continue flag was already set for the image.
         */
        virtual LVSTATUS ContinueOnImage(int ImageIndex);
        /** Disables the Continue() flag on the specified image.
         * When in the Sequencer Dral configuration the FlowType field is set to
         * SqFlow_CheckOnImage, the application can control whether continuing
         * or not the acquisition after the acquisition of specific images.\n
         * When the Continue() flag for the image is reset, the Sequencer Dral enters
         * its waiting state, waiting for a Continue() from the application or for the
         * optocoupler input, when enabled.\n
         * Use this method to disable the acquisition after the specified image index.
         * @param ImageIndex Index of the image after which the Continue() flag has to be reset.
         * @return \b DSY_I_NoError if the continue flag changed state otherwise \b DSY_W_RPS_PauseAlreadySet,
         *         meaning the continue flag was already reset for the image.
         */
        virtual LVSTATUS PauseOnImage(int ImageIndex);

        /** Returns the state of the input optocouplers.
         * The Daisy functions are not available during the Sequencer Dral
         * execution, therefore the DsyApp_Seq32 class provides alternative
         * methods to handle the optocouplers.\n
         * This function retrieves the actual state of the input optocouplers either the
         * immediate state or the buffered state, depending on the \b Buffered
         * parameter. The returned value is a bit mask which reflects the state of the
         * input optocouplers, where, for each valid bit position a \b