Image Manager/Cvb++/QmlFirmwareUpdater

This example program is located in your CVB installation under %CVB%Tutorial/Image Manager/Cvb++/QmlFirmwareUpdater.

backend.cpp:

#include "backend.hpp"
 
#include "QDebug"
 
#include <cvb/data_type.hpp>
 
#include <cvb/device.hpp>
#include <cvb/device_factory.hpp>
 
 
BackEnd::BackEnd(QQuickView *view, QObject *parent) : QObject(parent), view_{view}
{
  // Register view to queue commands over threads
  qRegisterMetaType<QWindow::Visibility>();
}
 
BackEnd::~BackEnd()
{
}
 
void BackEnd::ShowStatus(const std::string & statusMessage)
{
  auto statusText = view_->findChild<QObject*>("status");
  if(statusText)
    statusText->setProperty("text", statusMessage.c_str());
}
 
void BackEnd::ShowGufContent(const std::string& statusMessage)
{
  auto statusText = view_->findChild<QObject*>("gufContent");
  if (statusText)
    statusText->setProperty("text", statusMessage.c_str());
}
 
const QVariantList BackEnd::CameraCombo()
{
  return cameraCombo_;
}
 
const QVariantList BackEnd::GufEntriesCombo()
{
  return gufEntriesCombo_;
}
 
void BackEnd::SetCameraCombo(const QVariantList& cameraCombo)
{
  if (cameraCombo_ != cameraCombo)
  {
    cameraCombo_ = cameraCombo;
    emit CameraComboChanged();
  }
}
 
void BackEnd::SetGufEntriesCombo(const QVariantList& gufEntriesCombo)
{
  if (gufEntriesCombo_ != gufEntriesCombo)
  {
    gufEntriesCombo_ = gufEntriesCombo;
    emit GufEntriesComboChanged();
  }
}
 
void BackEnd::UpdateGufEntryInfo(const int& gufEntryIdx)
{
  if(fwupdater_)
  {
    try
    {
      ShowStatus(CVB_LIT("Loading guf file."));
      auto entries = fwupdater_->UpdateFileInfos(gufEntryIdx);
      std::stringstream ss;
      for (const auto& entry : entries)
      {
        ss << entry << "\n";
      }
      ShowGufContent(ss.str());
      ShowStatus(CVB_LIT("Done."));
    }
    catch (...)
    {
      ShowStatus(CVB_LIT("Failed to retrieve available update file infos from guf."));
    }
  }
}
 
void BackEnd::BtnOpenGuf(const QString &path)
{
  qDebug() << "Using guf file " << path;
  gufFilePath_ = path.toLocal8Bit().constData();
  try
  {
    ShowStatus("Reading guf content.");
    fwupdater_ = Cvb::GenApi::FWUpdater::Create(gufFilePath_);
    ShowStatus("Done");
  }
  catch (const std::exception& e)
  {
    std::stringstream error;
    error << CVB_LIT("Error creating firmware updater using guf file.") + path.toStdString() + 
      CVB_LIT("\n") << e.what() << "\n Maybe check the Control.xml in the guf file.";
    ShowStatus(error.str());
  }
  catch (...)
  {
    ShowStatus("Failed to create firmware updater.");
  }
 
  QVariantList list;
  list.clear();
  if (fwupdater_)
  {
    try
    {
      gufFileEntries_ = fwupdater_->AvailableUpdateFiles();
      for (const auto& entry : gufFileEntries_)
      {
        std::stringstream ss;
        ss << entry;
        list.append(std::string(ss.str()).c_str());
      }
      SetGufEntriesCombo(list);
    }
    catch(...)
    {
      ShowStatus(CVB_LIT("Failed to retieve available update files from guf."));
    }
  }
}
 
 
void BackEnd::ListAvailableDevices()
{
  deviceMap_.clear();
  discover_ = Cvb::DeviceFactory::Discover(Cvb::Driver::DiscoverFlags::IgnoreGevSD);
  for (const auto & device : discover_)
  {
    Cvb::String devModel{ "Unset" };
 
    if(device.TryGetProperty(Cvb::Driver::DiscoveryProperties::DeviceModel, devModel))
      deviceMap_[devModel] = static_cast<int32_t>(device.Index());
  }
}
 
 
// Scan for available devices and update list of possible updates, call update list to update dropdown
void BackEnd::BtnScan()
{
  qDebug() << "Starting scan of available devices for guf file.";
  QVariantList list;
  list.clear();
  ListAvailableDevices();
  for (auto const& device : deviceMap_)
  {
    std::stringstream ss;
    ss << device.first;
    list.append(std::string(ss.str()).c_str());
  }
  SetCameraCombo(list);
}
 
 
void BackEnd::BtnStartUpdate(const int gufEntryIdx, const QString & selCamera)
{
  if (gufEntryIdx < 0)
  {
    ShowStatus(CVB_LIT("No guf entry set."));
    return;
  }
  if (selCamera.isEmpty())
  {
    ShowStatus(CVB_LIT("No camera selected."));
    return;
  }
  auto selDeviceIdx = deviceMap_[selCamera.toStdString()];
  qDebug() << "Starting update for device " << selCamera << " with update file " << QString::number(gufEntryIdx) << " \"" << gufFileEntries_[gufEntryIdx].c_str() << "\".";
  ShowStatus(CVB_LIT("Updating camera."));
  try
  {
    auto tmpDevPtr{ Cvb::DeviceFactory::Open(discover_[selDeviceIdx].AccessToken(), Cvb::AcquisitionStack::PreferGenTL) };
    fwupdater_->Update(std::move(tmpDevPtr), gufEntryIdx);
    ShowStatus(CVB_LIT("Update successful."));
  }
  catch (const std::exception& e)
  {
    std::stringstream error;
    error << CVB_LIT("Update failed: ") << e.what();
    ShowStatus(error.str());
  }
  catch (...)
  {
    ShowStatus(CVB_LIT("Sorry, something unknown and unexpected has happened. Following the mainstream we could have ignored this leaving you even more puzzled. However we must admit that we have no clue either."));
  }
 
}

backend.hpp:

#pragma once
 
#include "QVariantList"
#include <QObject>
#include <QQmlContext>
#include <QQuickView>
#include <QString>
#include <QQuickItem>
 
#include <cvb/image.hpp>
#include <cvb/genapi/fw_updater.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
 
  Q_PROPERTY(QVariantList CameraCombo READ CameraCombo WRITE SetCameraCombo NOTIFY CameraComboChanged)
  Q_PROPERTY(QVariantList GufEntriesCombo READ GufEntriesCombo WRITE SetGufEntriesCombo NOTIFY GufEntriesComboChanged)
public:
  // QObjects are expected to support a parent/child hierarchy
  explicit BackEnd(QQuickView *view, QObject *parent = 0);
 
  ~BackEnd();
 
  const QVariantList CameraCombo();
  void SetCameraCombo(const QVariantList& cameraCombo);
  const QVariantList GufEntriesCombo();
  void SetGufEntriesCombo(const QVariantList& cameraCombo);
 
 
signals:
  void CameraComboChanged();
  void GufEntriesComboChanged();
 
public slots:
  void BtnScan();
  void BtnOpenGuf(const QString &path);
  void BtnStartUpdate(const int gufEntryIdx, const QString & selCamera);
  void UpdateGufEntryInfo(const int & gufEntryIdx);
 
 
private:
  void ShowStatus(const std::string & statusMessage);
  void ShowGufContent(const std::string & statusMessage);
  void ListAvailableDevices();
 
  QQuickView *view_;
  QQmlContext* context_;
  QVariantList cameraCombo_;
  QVariantList gufEntriesCombo_;
 
  Cvb::String gufFilePath_;
  std::map<Cvb::String, int32_t> deviceMap_;
  std::vector<Cvb::String> gufFileEntries_;
  std::unique_ptr<Cvb::GenApi::FWUpdater> fwupdater_;
  std::vector<Cvb::DiscoveryInformation> discover_;
};

main.cpp:

// The QmlFirmwareUpdater example starts a QML FirmwareUpdater which can load a device and stream the
// device image.
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
 
#include <iostream>
 
#include <QApplication>
#include <QIcon>
#include <QMetaType>
#include <QQmlContext>
#include <QQuickStyle>
#include <QQuickView>
 
#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("FirmwareUpdater C++ tutorial");
 
    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;
  }
}