Scanner.h

#ifndef GCP_GRABBER_SCANNER_H
#define GCP_GRABBER_SCANNER_H

#include <valarray>

#include "gcp/util/common/GenericTask.h"
#include "gcp/util/common/NetStr.h"
#include "gcp/util/common/TcpClient.h"
#include "gcp/util/common/TimeOut.h"

#include "gcp/grabber/common/Image.h"
#include "gcp/grabber/common/ScannerMsg.h"

namespace gcp {
  namespace grabber {
    
    class FrameGrabber;
    class Master;
    
    class Scanner :
      public gcp::util::GenericTask<ScannerMsg> {
      
      public:
      
      Scanner(Master* parent, bool simulate);
      
      virtual ~Scanner();
      
      private:
      
      // A vector of image objects maintained by this task

      std::vector<Image> images_;

      // Which image we are currently integrating

      unsigned count_;

      unsigned channel_;

      // An object that will handle timeouts for the Scanner task. 

      gcp::util::TimeOut timeOut_;

      // A mask of channels to sample on each interval

      unsigned intervalMask_;

      // When sendImages() is called, this mask will record which images
      // remain to be sent

      unsigned remainMask_;
      bool storeAsFlatfield_;

      //  Master will access private members of this class.

      friend class Master;
      
      // A private pointer to the parent class

      Master* parent_;
      
      FrameGrabber* fg_;
      
      bool simulate_;
      
      std::valarray<unsigned short> image_;
      
      gcp::util::TcpClient client_;
      
      gcp::util::NetStr* netStr_;       
      
      void parseGreeting();
      
      bool connect();        
      
      void disconnect();     
      
      void connectScanner(bool reEnable);
      
      void disconnectScanner();
      
      void processMsg(ScannerMsg* taskMsg);
      
      void serviceMsgQ();
      
      void sendScannerConnectedMsg(bool connected);
      
      static NET_READ_HANDLER(netMsgReadHandler);
      
      static NET_SEND_HANDLER(imageSentHandler);
      
      static NET_ERROR_HANDLER(netErrorHandler);
      
      void addGrabberImage(Image& image);

      void packImage(Image& image);
      
      // Send multiple sequential images

      void sendImages(unsigned chanMask, bool storeAsFlatfield);
      
      // Send an image

      void sendNextImage();
      void sendImage(Image& image, bool storeAsFlatfield);
      
    }; // End class Scanner
    
  } // End namespace grabber
}; // End namespace gcp




#endif // End #ifndef GCP_GRABBER_SCANNER_H