Cvb/QtStreamDisplayPair

This example requires Qt5 >= 5.9 setup for building.

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

• qt5-default

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
 
#include <iostream>
 
#include <QDebug>
#include <QApplication>
#include <QWidget>
#include <QHBoxLayout>
#include <QIcon>
 
#include <cvb/device.hpp>
#include <cvb/driver/stream.hpp>
#include <cvb/driver/stream.hpp>
#include <cvb/device_factory.hpp>
 
#include <cvb/ui/image_view.hpp>
#include <cvb/async/single_stream_handler.hpp>
 
// MainWidget with two displays (original and plane 0)
class MainWidget
  : public QWidget
{
  public:
 
    MainWidget()
      : QWidget()
    {
      masterView_ = new Cvb::UI::ImageView(this);
      slaveView_ = new Cvb::UI::ImageView(this);
 
      masterView_->SetUploadMode(Cvb::UI::UploadMode::Viewport);
      masterView_->CustomWaitForRepaint([&]()
      {
        masterView_->viewport()->repaint();
        slaveView_->viewport()->repaint();
      });
 
      slaveView_->SetRefreshMode(Cvb::UI::RefreshMode::UploadOnly);
 
      auto mainLayout = new QHBoxLayout(this);
      setLayout(mainLayout);
 
      mainLayout->addWidget(masterView_);
      mainLayout->addWidget(slaveView_);
    }
 
    void Run(const Cvb::Device & device)
    {
      // the display of the image
      slaveView_->Refresh(device.DeviceImage(), Cvb::UI::AutoRefresh::On);
      // the display of the image with plane 0
      masterView_->Refresh(device.DeviceImage()->Plane(0).Map());
      customAcquisitonHandler_ = CustomStreamHandler::Create(device.Stream(), *this);
      customAcquisitonHandler_->Run();
    }
 
  protected:
 
    void closeEvent(QCloseEvent *event) override
    {
      masterView_->SetWaitForRepaintEnabled(false);
      QWidget::closeEvent(event);
    }
 
 
  private:
 
    class CustomStreamHandler
      : public Cvb::SingleStreamHandler
    {
      public:
 
        static std::unique_ptr<CustomStreamHandler> Create(const Cvb::StreamPtr& stream, MainWidget& mainWidget)
        {
          return std::unique_ptr<CustomStreamHandler>(new CustomStreamHandler(stream, mainWidget));
        }
 
        ~CustomStreamHandler()
        {
          TryFinish();
        }
 
      private:
 
        CustomStreamHandler(const Cvb::StreamPtr& stream, MainWidget& mainWidget)
          : Cvb::SingleStreamHandler(stream)
          , mainWidget_(mainWidget)
        {
        }
 
 
 
        void HandleAsyncStream(const Cvb::StreamPtr & stream) override
        {
          auto waitResult = stream->WaitFor(std::chrono::milliseconds(10000));
          if (!waitResult.Image)
            return;
 
          mainWidget_.masterView_->Refresh(waitResult.Image->Plane(0).Map());
        }
 
        MainWidget& mainWidget_;
 
    };
 
    Cvb::UI::ImageView* masterView_ = nullptr;
    Cvb::UI::ImageView* slaveView_ = nullptr;
 
    std::unique_ptr<CustomStreamHandler> customAcquisitonHandler_;
};
 
int main(int argc, char* argv[])
{
  try
  {
 
    QApplication app(argc, argv);
    auto path = Cvb::InstallPath();
    path += CVB_LIT("drivers/GenICam.vin");
    // use command line argument if provided
    if (argc > 1)
    {
      std::string inputPath(argv[1]);
      path = Cvb::String(inputPath.begin(), inputPath.end());
    }
 
    // expand environment variables in path
    path = Cvb::ExpandPath(path);
 
    // open a device
    auto device = Cvb::DeviceFactory::Open(path, Cvb::AcquisitionStack::Vin);
 
    // connect the device image to the UI
    MainWidget mainWidget;
    mainWidget.setWindowIcon(QIcon(":/qttutorial.png"));
    mainWidget.Run(*device);
    mainWidget.resize(880, 600);
    mainWidget.show();
 
    return app.exec();
  }
  catch (const std::exception& error)
  {
    std::cout << error.what() << std::endl;
  }
}