usNetworkGrabber.h

/****************************************************************************
 *
 * This file is part of the ustk software.
 * Copyright (C) 2016 - 2017 by Inria. All rights reserved.
 *
 * This software is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * ("GPL") version 2 as published by the Free Software Foundation.
 * See the file LICENSE.txt at the root directory of this source
 * distribution for additional information about the GNU GPL.
 *
 * For using ustk with software that can not be combined with the GNU
 * GPL, please contact Inria about acquiring a ViSP Professional
 * Edition License.
 *
 * This software was developed at:
 * Inria Rennes - Bretagne Atlantique
 * Campus Universitaire de Beaulieu
 * 35042 Rennes Cedex
 * France
 *
 * If you have questions regarding the use of this file, please contact
 * Inria at ustk@inria.fr
 *
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 * Authors:
 * Pedro Patlan
 * Marc Pouliquen
 *
 *****************************************************************************/
 
#ifndef __usNetworkGrabber_h_
#define __usNetworkGrabber_h_
 
#include <visp3/ustk_core/us.h>
#include <visp3/ustk_core/usConfig.h>
#include <visp3/ustk_grabber/usAcquisitionParameters.h>
 
#if defined(USTK_HAVE_QT5) || defined(USTK_HAVE_VTK_QT)
 
#include <cassert>
#include <cstring>
#include <iostream>
 
// Qt Network
#include <QtCore/QObject>
#include <QtCore/QThread>
#include <QtNetwork/QHostAddress>
#include <QtNetwork/QTcpSocket>
 
class VISP_EXPORT usNetworkGrabber : public QObject
{
  Q_OBJECT
public:
  typedef enum {
    OUTPUT_FRAME_POSITION_IN_VEC = 0,
    MOST_RECENT_FRAME_POSITION_IN_VEC = 1,
    CURRENT_FILLED_FRAME_POSITION_IN_VEC = 2
  } usDataPositionInBuffer;
 
  typedef enum {
    ODD = 0,     
    EVEN = 1,    
    ODD_EVEN = 2 
  } usVolumeField;
 
  // Following headers must be the same in the server (ultrasound station) !
 
  struct usInitHeaderSent {
    usInitHeaderSent() : headerId(1) {} // set header Id to 1 by default
    int headerId; 
    int probeId;     
    int slotId;      
    int imagingMode; 
  };
 
  struct usRunControlHeaderSent {
    usRunControlHeaderSent() : headerId(3), run(false) {} // set header Id to 1 by default
    int headerId; 
    bool run; 
  };
 
  struct usInitHeaderConfirmation {
    usInitHeaderConfirmation() : headerId(1), initOk(0), probeId(0) {} // set header Id to 1 by default
    int headerId; 
    int initOk;  
    int probeId; 
  };
 
  explicit usNetworkGrabber(QObject *parent = 0);
  ~usNetworkGrabber();
 
  void disconnect();
 
  bool initAcquisition(const usNetworkGrabber::usInitHeaderSent &header);
 
  bool getMotorActivation();
  usAcquisitionParameters::usMotorStep getStepsPerFrame();
  int getFramesPerVolume();
  int getImageDepth();
  int getImagingMode();
  int getMotorPosition();
  int getPostScanHeigh();
  bool getPostScanMode();
  int getPostScanWidth();
  int getSamplingFrequency();
  int getSector();
  int getTransmitFrequency();
 
  void readAcquisitionParameters(QDataStream &stream);
 
  bool sendAcquisitionParameters();
 
  void setIPAddress(const std::string &s_ip) { m_ip = s_ip; }
 
  void setMotorActivation(bool activateMotor);
  void setStepsPerFrame(usAcquisitionParameters::usMotorStep stepsPerFrame);
  void setFramesPerVolume(int framesPerVolume);
  void setImageDepth(int imageDepth);
  void setImagingMode(int imagingMode);
  void setMotorPosition(int motorPosition);
  void setPostScanHeigh(int postScanHeigh);
  void setPostScanMode(bool postScanMode);
  void setPostScanWidth(int postScanWidth);
  void setSamplingFrequency(int samplingFrequency);
  void setSector(int sector);
  void setTransmitFrequency(int transmitFrequency);
 
  void setVerbose(bool verbose) { m_verbose = verbose; }
 
signals:
  void serverUpdateEnded(bool success);
  void endBlockingLoop();
  void runAcquisitionSignal(bool run);
  void sendAcquisitionParametersSignal();
  void endConnection();
  void acquisitionInitialized(bool);
 
public slots:
  void center3DProbeMotor();
  void connected();
  void connectToServer();
  void connectToServer(QHostAddress address);
  virtual void dataArrived() = 0;
  void disconnected();
  void disconnectFromServer();
  void handleError(QAbstractSocket::SocketError err);
  void initAcquisitionSlot(usNetworkGrabber::usInitHeaderSent header);
  void processConnectionToServer();
  void runAcquisition();
  void stopAcquisition();
 
protected slots:
  void serverUpdated(bool sucess);
  void sendRunSignal(bool run);
  void sendAcquisitionParametersSlot();
 
protected:
  bool m_verbose; // to print connection infos if true
 
  // Network
  QTcpSocket *m_tcpSocket;
  bool m_connect;
  std::string m_ip;
 
  // bytes to read until image end
  int m_bytesLeftToRead;
 
  // acquisition parameters
  usAcquisitionParameters m_acquisitionParameters;
 
  // To know if the update was sucessfull on server side
  bool m_updateParametersSucess;
 
  // received headers
  usInitHeaderConfirmation m_confirmHeader;
  us::usImageHeader m_imageHeader;
 
  // grabber state
  bool m_isInit;
  bool m_isRunning;
 
  // separated thread to run the event loop
  QThread *m_thread;
};
 
#endif // QT4 || QT5
#endif // __usNetworkGrabber_h_