GevServer/QmlGevServer

This example requires Qt5 >= 5.9 setup for building.

You may build it with Ubuntu 18.04's default Qt5 after installing:

• qt5-default
• qtdeclarative5-dev
• qtquickcontrols2-5-dev
• qml-module-qtquick2
• qml-module-qtquick-controls
• qml-module-qtquick-dialogs
• qml-module-qtquick-controls2
• qml-module-qt-labs-settings
• qml-module-qt-labs-folderlistmodel

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <iostream>

#include <QApplication>
#include <QIcon>
#include <QMetaType>
#include <QQmlContext>
#include <QQuickStyle>
#include <QQuickView>

#include <cvb/image.hpp>

#include "backend.hpp"

int main(int argc, char *argv[])
{
  try
  {
    QQuickStyle::setStyle("Windows");
    QQuickStyle::setFallbackStyle("Universal");
    QApplication app(argc, argv);
    app.setOrganizationName("STEMMER IMAGING");
    app.setOrganizationDomain("https://www.stemmer-imaging.com/");
    app.setApplicationName("GevServer C++ tutorial");

    // Register QML components for an image display
    Cvb::UI::ImageViewItem::Register();

    QQuickView *view = new QQuickView;
    view->setResizeMode(QQuickView::SizeRootObjectToView);
    view->setIcon(QIcon(":/qttutorial.png"));

    view->resize(640, 390);
    view->show();

    // Set context property before creating QML file
    BackEnd be(view);
    view->rootContext()->setContextProperty("backEnd", &be);

    // Load main QML file
    view->setSource(QUrl::fromLocalFile("../main.qml"));

    return app.exec();
  }
  catch (const std::exception &error)
  {
    std::cout << error.what() << std::endl;
  }
}

import QtQuick 2.3
import CvbQuick 1.0 as CvbQuick
import QtQuick.Controls 2.2
import QtQuick.Layouts 1.3
import QtQuick.Dialogs 1.2
import QtQuick.Controls.Universal 2.2

GroupBox {
    id: gridBox
    width: 640
    height: 390
    Layout.fillWidth: true
    Layout.fillHeight: true

    property var loadFile: true
    property var enableSnapSend: false

    Universal.theme: Universal.System

    background: Rectangle {
            width: parent.width
            height: parent.height 
            color: Universal.background
        }

    FileDialog {
        id: fileDialog
        modality: Qt.NonModal
        title: loadFile ? "Select an image or driver to load" : "Save image"
        selectExisting: loadFile
        selectFolder: false
        nameFilters: ["Drivers (*.vin *.emu)", "Image files (*png *.bmp)", "All files (*)"]
        selectedNameFilter: loadFile ? "Drivers" : "Image files"
        sidebarVisible: true
        onAccepted: {
        var path = fileUrl.toString();
        // remove prefixed "file:///"
        path = path.replace(/^(file:\/{3})/,"");
        // unescape html codes like '%23' for '#'
        var cleanPath = decodeURIComponent(path);

        loadFile ? backEnd.LoadDevice(path) : backEnd.SaveImg(path)
        }
    }

    GridLayout {
        id: gridLayout
        rows: 4
        flow: GridLayout.TopToBottom
        anchors.fill: parent

        ComboBox 
        {
            id: connectionCombo
            enabled: btnStartServer.m_server_disabled
            Layout.fillWidth: true
            Layout.columnSpan: 2
            model: backEnd.ConnectionList()
        }

        CvbQuick.ImageView
        {
            id: imageView
            image : mainImage
            Layout.rowSpan: 3
            Layout.columnSpan: 3
            Layout.fillHeight: true
            Layout.fillWidth: true
            uploadMode : CvbQuick.UploadMode.Viewport
        }
        

        ComboBox 
        {
            id: driverTypeCombo
            enabled: btnStartServer.m_server_disabled
            Layout.fillWidth: true
            model:
            (Qt.platform.os == "windows") ?
            [
                qsTr("Socket Driver (loopback)"),
                qsTr("Filter Driver (default)")
            ]
            :
            [
                qsTr("Socket Driver")
            ]
        }
        
        Button
        {
            objectName: "btnStartServer"
            id: btnStartServer
            implicitWidth: btnLoadDevice.width
            property var m_server_disabled: true
            text: m_server_disabled ? qsTr("Start Server") : qsTr("Stop Server")
             onClicked: {
                 m_server_disabled = m_server_disabled ? false : true
                 backEnd.StartServer(connectionCombo.currentIndex, driverTypeCombo.currentIndex)
             }
        }

        Column
        {
        spacing: 5

        Button
        {
            objectName: "btnLoadDevice"
            id: btnLoadDevice
            enabled: btnStartServer.m_server_disabled
            text: qsTr("Load Device")
            onClicked:
            {
                loadFile = true
                fileDialog.open()
            }
            
        }

        Button
        {
            objectName: "btnSaveImg"
            id: btnSaveImg
            implicitWidth: btnLoadDevice.width
            text: qsTr("Save Image")
            onClicked: 
            {
                loadFile = false
                fileDialog.open()
            }
        }

        Button
        {
            objectName: "btnSnap"
            id: btnSnap
            implicitWidth: btnLoadDevice.width
            width: btnSaveImg.width
            enabled: btnStartServer.m_server_disabled
            text: qsTr("Snap")
            onClicked: backEnd.BtnSnap()
        }

        Switch
        {
            objectName: "switchEnableSnapSend"
            id: switchEnableSnapSend
            text: qsTr("Enable Snap Send")
            checked: false
            enabled: !btnStartServer.m_server_disabled
            onCheckedChanged: 
            {
                enableSnapSend = enableSnapSend ? false : true
                backEnd.SwitchEnableSnapSend(checked)
            }
        }   

        Button
        {
            objectName: "btnSnapSend"
            id: btnSnapSend
            implicitWidth: btnLoadDevice.width
            enabled: !btnStartServer.m_server_disabled && enableSnapSend
            text: qsTr("Snap Send")
            onClicked: backEnd.BtnSnapSend()
        }
        }

        Switch
        {
            objectName: "switchGrab"
            id: switchGrab
            text: qsTr("Grab")
            checked: false
            enabled: btnStartServer.m_server_disabled
            onCheckedChanged: backEnd.SwitchGrab(checked)
        }   
    }
}

#include "backend.hpp"

#include "QDebug"

#include <cvb/data_type.hpp>
#include <cvb/gevserver/node.hpp>
#include <cvb/gevserver/node_map.hpp>
#include <cvb/gevserver/server.hpp>
#include <cvb/gevserver/stream.hpp>
#include <cvb/size_2d.hpp>

#include <cvb/device_factory.hpp>
#include <cvb/image.hpp>
#include <cvb/ui/image_view_item.hpp>

BackEnd::BackEnd(QQuickView *view, QObject *parent) : QObject(parent), view_{view}
{
  // Register view to queue commands over threads
  qRegisterMetaType<QWindow::Visibility>();


  // open a device
  device_ = Cvb::DeviceFactory::Open(Cvb::InstallPath() + CVB_LIT("drivers/CVMock.vin"));

  hasRingBuffer_ = !!device_->Stream()->RingBuffer();
  if (hasRingBuffer_)
    device_->Stream()->RingBuffer()->SetLockMode(Cvb::Driver::RingBufferLockMode::On);

  streamHandler_->Create(device_->Stream());

  context_ = view->rootContext();
  context_->setContextProperty("mainImage", &imageController_);
  device_->Stream()->GetSnapshot();

  imageController_.Refresh(device_->DeviceImage(), Cvb::UI::AutoRefresh::On);
}

BackEnd::~BackEnd()
{
  if (acqThread_)
    StopAcq();
  if (server_ != Cvb::GevServer::ServerPtr() && server_->State() != Cvb::GevServer::State::Configuration)
    server_->Stop();
  if (device_->Stream()->IsRunning())
    device_->Stream()->Stop();
}

void BackEnd::StartServer(const int &addressIndex, const int &driverTypeIndex)
{
  qDebug() << "Starting server on address index " << addressIndex << " and driver type index " << driverTypeIndex;

  // Check for recursions
  if (startInProgress_)
    return;

  startInProgress_ = true;

  try
  {
    if (!acqStarted_)
    {
      // Stop and reset grab button if running
      StopGrab();

      // Create server
      server_ = Cvb::GevServer::Server::CreateWithConstSize(device_->DeviceImage()->Size(),
                                                            device_->DeviceImage()->ColorModel(),
                                                            device_->DeviceImage()->Plane(0).DataType(),
                                                            static_cast<Cvb::GevServer::DriverType>(driverTypeIndex));

      AddGenICamFeatures();

      // Set custom version/id
      server_->SetUserVersion(CVB_LIT("_C++GevServer"));
      server_->NodeMap()->SetXmlFileVersion(Cvb::GenApi::NodeMap::GenApiVersion(1, 0, 0));

      if (hasRingBuffer_)
        server_->Stream()->SetResendBuffersCount(2);
      else
        server_->Stream()->SetResendBuffersCount(0);

      // Start server
      auto address = iFaces_.at(addressIndex).IPAddress();
      server_->Start(address);

      // Start acquisition thread
      if (!acqThread_)
        StartAcq();

      acqStarted_ = true;
      qDebug() << "Started server";
    }
    else
    {
      if (acqThread_)
        StopAcq();
      server_->Stop();
      acqStarted_ = false;
      qDebug() << "Stopped server";
    }
  }
  catch (...)
  {
  }
  startInProgress_ = false;
}

void BackEnd::operator()() noexcept
{
  std::unique_lock<std::mutex> guard(mtx_);
  device_->Stream()->Start();
  while (!stopAcq_)
  {
    if (grabSwitchSwitched_)
    {
      if (hasRingBuffer_)
      {
        auto img = device_->Stream()->Wait<Cvb::RingBufferImage>();
        img.Image->Unlock();
      }
      else
        device_->Stream()->Wait();
    }
    else if (server_ != Cvb::GevServer::ServerPtr() && server_->State() == Cvb::GevServer::State::AcquisitionEnabled &&
             !snapSend_)
    {
      try
      {
        auto img = device_->Stream()->Wait<Cvb::RingBufferImage>();
        if (img.Status == Cvb::WaitStatus::Ok)
        {
          if (hasRingBuffer_)
          {
            bufferIndex_ = img.Image->BufferIndex();
            imgMap_[bufferIndex_] = img.Image;
            server_->Stream()->Send(img.Image, [this](const Cvb::ImagePtr &) {
              imgMap_[bufferIndex_]->Unlock();
              qDebug() << "unlocked buffer index " << std::to_string(bufferIndex_).c_str();
            });
          }
          else
            server_->Stream()->Send(*img.Image.get());
        }
      }
      catch (...)
      {
      }
    }
  }
  device_->Stream()->Stop();
}

void BackEnd::SwitchGrab(const bool &switched)
{
  grabSwitchSwitched_ = switched;

  if (grabSwitchSwitched_)
  {
    if (!acqThread_)
      StartAcq();
  }
  else
  {
    if (acqThread_)
      StopAcq();
  }
  qDebug() << "Grab switch switched to" << switched;
}

QVariantList BackEnd::ConnectionList()
{
  iFaces_.clear();
  iFaces_ = Cvb::GevServer::LogicalNetworkInterface::GetAllAvailable();

  QVariantList list;
  list.clear();

  for (auto const &iFace : iFaces_)
  {
    std::stringstream ss;
    ss << iFace.IPAddress() << " (" << iFace.IPv4Mask() << ")";
    list.append(std::string(ss.str()).c_str());
  }

  return list;
}

void BackEnd::LoadDevice(const QString &path)
{
  qDebug() << "Loading new device on path " << path;
  StopGrab();
  try
  {
    auto tmpDevice = Cvb::DeviceFactory::Open(CVB_LIT(path.toLatin1().toStdString().c_str()));
    device_.reset();
    device_ = tmpDevice;
    device_->Stream()->GetSnapshot();

    hasRingBuffer_ = !!device_->Stream()->RingBuffer();
    if (hasRingBuffer_)
      device_->Stream()->RingBuffer()->SetLockMode(Cvb::Driver::RingBufferLockMode::On);
    imageController_.Refresh(device_->DeviceImage(), Cvb::UI::AutoRefresh::On);
  }
  catch (...)
  {
    qDebug() << "Failed to load new device";
  }
}

void BackEnd::SaveImg(const QString &path)
{
  qDebug() << "Saving new file on path " << path;
  device_->DeviceImage()->Save(CVB_LIT(path.toLatin1().toStdString().c_str()));
}

void BackEnd::BtnSnap()
{
  qDebug() << "Snap image";
  StopGrab();
  // Snap a single image
  device_->Stream()->GetSnapshot();
}

void BackEnd::SwitchEnableSnapSend(const bool &switched)
{
  snapSend_ = switched;

  if (snapSend_)
    StopAcq();
  else
    StartAcq();

  qDebug() << "Enable snap switch switched to" << switched;
}

void BackEnd::BtnSnapSend()
{
  if (server_->State() == Cvb::GevServer::State::AcquisitionEnabled)
  {
    qDebug() << "Snap send";
    try
    {
      auto img = device_->Stream()->GetSnapshot();
      if (img.Status == Cvb::WaitStatus::Ok)
        if (hasRingBuffer_)
        {
          server_->Stream()->Send(img.Image, nullptr);
        }
        else
        {
          auto img2 = device_->Stream()->GetSnapshot();
          if (img2.Status == Cvb::WaitStatus::Ok)
            server_->Stream()->Send(*img2.Image);
        }
    }
    catch (...)
    {
    }
  }
  else
    qDebug() << "Acquisition not enabled on server";
}

void BackEnd::StopGrab()
{
  // If grab is currently running, stop it
  if (device_->Stream()->IsRunning() && grabSwitchSwitched_)
  {
    QObject *box = view_->findChild<QObject *>("switchGrab", Qt::FindChildrenRecursively);
    if (box)
      box->setProperty("checked", false);
  }
  if (device_->Stream()->IsRunning() && acqStarted_)
  {
    StopAcq();
  }
}

void BackEnd::OnWindowSizeChanged(const Cvb::GevServer::ValueNode & /*value*/)
{
  switch (windowStateRegNode_->Value())
  {
  case 0:
    view_->showMinimized();
    break;
  case 1:
    view_->showNormal();
    break;
  case 2:
    view_->showMaximized();
  default:
    throw std::runtime_error("Invalid window state value");
    break;
  }
}

void BackEnd::AddGenICamFeatures()
{
  auto catNode = Cvb::GevServer::CategoryNode::Create(CVB_LIT("Cust::CustomFeatures"));
  server_->NodeMap()->AddNode(catNode);
  catNode->SetDisplayName(CVB_LIT("Custom Features"));
  catNode->SetToolTip(CVB_LIT("Contains all application defined features."));
  auto rootNode = server_->NodeMap()->Node(CVB_LIT("Root"));
  rootNode->Add(catNode, Cvb::GevServer::NodeList::Child);

  windowStateRegNode_ = Cvb::GevServer::Int32RegNode::Create(CVB_LIT("Cust::WindowStateReg"));
  server_->NodeMap()->AddNode(windowStateRegNode_);
  windowStateRegNode_->SetVisibility(Cvb::GenApi::Visibility::Invisible);
  // No cache because of polling
  windowStateRegNode_->SetCacheMode(Cvb::GenApi::CacheMode::NoCache);
  // Polling time in ms
  windowStateRegNode_->SetPollingTime<float, std::ratio<1, 1000>>(
      std::chrono::duration<float, std::ratio<1, 1000>>(333));
  windowStateRegNode_->SetValue(1); // View in normal mode
  windowStateRegNode_->RegisterEventWrittenUpdated(
      [this](const Cvb::GevServer::ValueNode &value) { OnWindowSizeChanged(value); });

  auto enumerationNode = Cvb::GevServer::EnumerationNode::Create(CVB_LIT("Cust::WindowState"));
  server_->NodeMap()->AddNode(enumerationNode);
  enumerationNode->SetDisplayName(CVB_LIT("Window State"));
  enumerationNode->SetToolTip(CVB_LIT("Current window state of server application."));
  enumerationNode->SetValueConfig<Cvb::GevServer::IntegerBaseNodePtr>(windowStateRegNode_);

  auto minimized = Cvb::GevServer::EnumEntryNode::Create(CVB_LIT("Cust::Minimized"));
  minimized->SetNumericValue(0);
  enumerationNode->Add(minimized, Cvb::GevServer::NodeList::Child);

  auto normalNode = Cvb::GevServer::EnumEntryNode::Create(CVB_LIT("Cust::Normal"));
  normalNode->SetNumericValue(1); // Must be ascending entry in vector
  enumerationNode->Add(normalNode, Cvb::GevServer::NodeList::Child);

  auto maxNode = Cvb::GevServer::EnumEntryNode::Create(CVB_LIT("Cust::Maximized"));
  maxNode->SetNumericValue(2); // Must be ascending entry in vector
  enumerationNode->Add(maxNode, Cvb::GevServer::NodeList::Child);

  catNode->Add(enumerationNode, Cvb::GevServer::NodeList::Child);
}

#ifndef BACKEND_H
#define BACKEND_H

#include "QVariantList"
#include <QObject>
#include <QQmlContext>
#include <QQuickView>
#include <QString>

#include <thread>

#include <cvb/async/single_stream_handler.hpp>
#include <cvb/gevserver/logical_network_interface.hpp>
#include <cvb/ui/image_view_item.hpp>

class BackEnd : public QObject
{
  // This macro is required for QObject support.  You should get a compiler
  // error if you don't include this.
  Q_OBJECT

public:
  // QObjects are expected to support a parent/child hierarchy
  explicit BackEnd(QQuickView *view, QObject *parent = 0);

  ~BackEnd();

  void OnWindowSizeChanged(const Cvb::GevServer::ValueNode &value);

  void StartAcq()
  {
    std::unique_lock<std::mutex> guard(mtx_);

    stopAcq_ = false;
    acqThread_.reset(new std::thread(std::ref(*this)));
  }

  void StopAcq()
  {
    stopAcq_ = true;
    if (acqThread_)
    {
      acqThread_->join();
      acqThread_.reset();
    }
  }

  // Acquisition thread
  void operator()() noexcept;

signals:

public slots:
  void StartServer(const int &addressIndex, const int &driverTypeIndex);

  void LoadDevice(const QString &path);

  void SaveImg(const QString &path);

  void BtnSnap();

  void BtnSnapSend();

  QVariantList ConnectionList();

  void SwitchGrab(const bool &switched);

  void SwitchEnableSnapSend(const bool &switched);

private:
  void StopGrab();

  void AddGenICamFeatures();

  QQuickView *view_;
  QQmlContext *context_;
  // Create a controller object to communicate with QML
  Cvb::UI::ImageController imageController_;

  Cvb::EventCookie eventCookie_;
  // Hold this node for callback
  Cvb::GevServer::Int32RegNodePtr windowStateRegNode_;

  bool startInProgress_{false};
  bool grabSwitchSwitched_{false};
  bool acqStarted_{false};
  bool snapSend_{false};
  bool hasRingBuffer_{false};
  int bufferIndex_;

  std::map<int, Cvb::RingBufferImagePtr> imgMap_;
  std::vector<Cvb::GevServer::LogicalNetworkInterface> iFaces_;
  Cvb::GevServer::ServerPtr server_;
  Cvb::DevicePtr device_;
  Cvb::SingleStreamHandlerPtr streamHandler_;

  std::atomic<bool> stopAcq_;
  std::unique_ptr<std::thread> acqThread_;
  std::mutex mtx_;
};

#endif