Source Code for Camera Calibration Display

Location

./src/examples/src/videoviewmixin/calibrationfilter

This example shows:

• how to create a display
• how to create calibration and store it to a file

Header

 
/*
 * This file depends on Qt which is licensed under LGPLv3.
 * See ADTF_DIR/3rdparty/qt5 and doc/license for detailed information.
 */
#pragma once
#include <QWidget>
#include <adtfstreaming3/samplestreamer_intf.h>
#include <adtfstreaming3/reference_clock_intf.h>
#include "ui_calibration_ui.h"
 
class cCalibrationWidget: public QWidget, public Ui::cCalibrationUIBase
{
    Q_OBJECT
 
    public:
        cCalibrationWidget(adtf::streaming::ISampleWriter* pWriter);
 
    protected slots:
        void OnLoad();
        void OnSave();
        void OnTransmit();
 
        void OnWidth();
        void OnHeight();
 
        void OnPX();
        void OnPY();
 
        void OnPXSlide();
        void OnPYSlide();
 
        void OnValueChanged();
 
    protected:
        adtf::streaming::ISampleWriter* m_pWriter;
        tUInt32 m_nCounter;
        adtf::ucom::object_ptr<adtf::services::IReferenceClock> m_pClock;
};

 
/*
 * This file depends on Qt which is licensed under LGPLv3.
 * See ADTF_DIR/3rdparty/qt5 and doc/license for detailed information.
 */
#pragma once
#include <adtf_filtersdk.h>
#include <adtf_ui.h>
 
using namespace adtf::ucom;
using namespace adtf::base;
using namespace adtf::streaming;
using namespace adtf::filter;
using namespace adtf::ui;
 
#define OID_CAMERA_CALIBRATION  "adtf.tool.camera_calibration"
 
class cCalibrationWidget;
 
class cCameraCalibrationFilter: public cQtUIFilter
{
    public:
        ADTF_CLASS_ID_NAME(cCameraCalibrationFilter, "demo_camera_calibration.filter.disptb.cid", "Demo Camera Calibration Display");
 
    public:
        cCameraCalibrationFilter();
 
    protected: // Implement cBaseQtFilter
        QWidget* CreateView() override;
        tVoid ReleaseView() override;
 
    private:
        ISampleWriter* m_pWriter = nullptr;
        cCalibrationWidget* m_pWidget = nullptr;
};

Implementation

 
/*
 * This file depends on Qt which is licensed under LGPLv3.
 * See ADTF_DIR/3rdparty/qt5 and doc/license for detailed information.
 */
#include "camera.h"
#include "calibrationwidget.h"
#include <QFileDialog>
#include <QMessageBox>
#include <adtf_utils.h>
#include <adtfstreaming3/sample.h>
#include <projection_types.h>
 
static const tChar* strTemplate =
"Camera:\n\
  Manually Calibrated Camera\n\
  ADTF\n\
\n\
Extrinsic parameters:\n\
  Resolution:            %d x %d          [pixel]\n\
  Position:              ( %f %f %f ) [m]\n\
  Rotation:              ( %f %f %f ) [rad]\n\
\n\
Intrinsic parameters:\n\
  Focal length:          ( %f %f )  [pixel]\n\
  Skew parameter:        %f\n\
  Principal point:       ( %f %f )  [pixel]\n\
  Radial distortion:     ( %f %f )\n\
  Tangential distortion: ( %f %f )\n";
 
using namespace adtf::util;
using namespace adtf::base;
using namespace adtf::streaming;
 
cCalibrationWidget::cCalibrationWidget(ISampleWriter* pWriter): QWidget(), m_pWriter(pWriter), m_nCounter(0)
{
    THROW_IF_FAILED(_runtime->GetObject(m_pClock));
    setupUi(this);
    connect(m_pLoadButton, SIGNAL(clicked()), this, SLOT(OnLoad()));
    connect(m_pSaveButton, SIGNAL(clicked()), this, SLOT(OnSave()));
    connect(m_pTransmitButton, SIGNAL(clicked()), this, SLOT(OnTransmit()));
 
    connect(m_pWidth, SIGNAL(valueChanged(int)), this, SLOT(OnWidth()));
    connect(m_pHeight, SIGNAL(valueChanged(int)), this, SLOT(OnHeight()));
 
    connect(m_pPrincipalX, SIGNAL(valueChanged(double)), this, SLOT(OnPX()));
    connect(m_pPrincipalY, SIGNAL(valueChanged(double)), this, SLOT(OnPY()));
 
    connect(m_pPXSlider, SIGNAL(sliderMoved(int)), this, SLOT(OnPXSlide()));
    connect(m_pPYSlider, SIGNAL(sliderMoved(int)), this, SLOT(OnPYSlide()));
 
    OnWidth();
    OnHeight();
    OnPX();
    OnPY();
}
 
void cCalibrationWidget::OnLoad()
{
    QString strFileName = QFileDialog::getOpenFileName(this, "Open Calibration File");
    if (!strFileName.isEmpty())
    {
        cCamera oHelper;
        if (IS_FAILED(oHelper.ParseConfig(strFileName.toStdString().c_str())))
        {
            QMessageBox::critical(this, "Error while parsing file", "Unable to parse camera calibration file: " + strFileName);
            return;
        }
 
        m_pWidth->setValue(oHelper.m_nResX);
        m_pHeight->setValue(oHelper.m_nResY);
        
        m_pPosX->setValue(oHelper.m_fPosX);
        m_pPosY->setValue(oHelper.m_fPosY);
        m_pPosZ->setValue(oHelper.m_fPosZ);
        
        m_pRotX->setValue(oHelper.m_fRotX);
        m_pRotY->setValue(oHelper.m_fRotY);
        m_pRotZ->setValue(oHelper.m_fRotZ);
 
        m_pFocalX->setValue(oHelper.m_fFocalX);
        m_pFocalY->setValue(oHelper.m_fFocalY);
 
        m_pPrincipalX->setValue(oHelper.m_fPrincipalX);
        m_pPrincipalY->setValue(oHelper.m_fPrincipalY);
    }
}
 
void cCalibrationWidget::OnSave()
{
    QString strFileName = QFileDialog::getSaveFileName(this, "Save Calibration File");
    if (!strFileName.isEmpty())
    {
        auto oResult = cFileSystem::WriteTextFile(strFileName.toStdString().c_str(),
                                                  cString::Format(strTemplate,
                                                                  m_pWidth->value(),
                                                                  m_pHeight->value(),
                                                                  m_pPosX->value(),
                                                                  m_pPosY->value(),
                                                                  m_pPosZ->value(),
                                                                  m_pRotX->value(),
                                                                  m_pRotY->value(),
                                                                  m_pRotZ->value(),
                                                                  m_pFocalX->value(),
                                                                  m_pFocalY->value(),
                                                                  0.0,
                                                                  m_pPrincipalX->value(),
                                                                  m_pPrincipalY->value(),
                                                                  0.0, 0.0,
                                                                  0.0, 0.0));
        if (IS_FAILED(oResult))
        {
            QMessageBox::critical(this,
                                  "Error while saving file",
                                  QString("Unable to save camera calibration file %1: %2").arg(strFileName).arg(to_string(oResult).GetPtr()));
        }
    }
}
 
 
void cCalibrationWidget::OnTransmit()
{    
    auto tmNow = m_pClock->GetStreamTimeNs();
    output_sample_data<tCameraProjection> oOutputData(tmNow);
    oOutputData->f32PosX = m_pPosX->value();
    oOutputData->f32PosY = m_pPosY->value();
    oOutputData->f32PosZ = m_pPosZ->value();
 
    oOutputData->f32RotX = m_pRotX->value();
    oOutputData->f32RotY = m_pRotY->value();
    oOutputData->f32RotZ = m_pRotZ->value();
 
    oOutputData->f32FocalX = m_pFocalX->value();
    oOutputData->f32FocalY = m_pFocalY->value();
 
    oOutputData->f32PrincipalX = m_pPrincipalX->value();
    oOutputData->f32PrincipalY = m_pPrincipalY->value();
 
    oOutputData->nCounter = m_nCounter++;
    oOutputData->nSize = sizeof(tCameraProjection);
 
    m_pWriter->Write(oOutputData.Release());
    m_pWriter->ManualTrigger(tmNow);
}
 
void cCalibrationWidget::OnWidth()
{
    m_pPXSlider->setMaximum(m_pWidth->value());
}
 
void cCalibrationWidget::OnHeight()
{
     m_pPYSlider->setMaximum(m_pHeight->value());
}
 
void cCalibrationWidget::OnPX()
{
    m_pPXSlider->setValue(m_pPrincipalX->value());
}
 
void cCalibrationWidget::OnPY()
{
    m_pPYSlider->setValue(m_pPrincipalY->value());
}
 
void cCalibrationWidget::OnPXSlide()
{
    m_pPrincipalX->setValue(m_pPXSlider->value());
}
 
void cCalibrationWidget::OnPYSlide()
{
    m_pPrincipalY->setValue(m_pPYSlider->value());
}
 
void cCalibrationWidget::OnValueChanged()
{
    if (m_pImmediately->isChecked())
    {
        OnTransmit();
    }
}
 

 
/*
 * This file depends on Qt which is licensed under LGPLv3.
 * See ADTF_DIR/3rdparty/qt5 and doc/license for detailed information.
 */
#include "calibrationfilter.h"
#include "calibrationwidget.h"
#include <streammetatypecameracalibration.h>
 
ADTF_PLUGIN_VERSION("Demo Camera Calibration Display Plugin", 
                    disptb,
                    DISPTB_VERSION_MAJOR,
                    DISPTB_VERSION_MINOR,
                    DISPTB_VERSION_PATCH,
                    cCameraCalibrationFilter)
 
cCameraCalibrationFilter::cCameraCalibrationFilter()
{
    m_pWriter = CreateOutputPin("calib", videoviewmixin::stream_meta_type_camera_calibration());
    set_description(*this, "calib", "Output pin for calibration data.");
 
    SetDescription("Use this Filter to create a display for camera calibration data.");
    set_help_link(*this, "$(ADTF_DISPLAY_TOOLBOX_DIR)/doc/displaytoolbox_html/page_camera_calibration_example_readme.html");
}
 
QWidget* cCameraCalibrationFilter::CreateView()
{
    // Tree View
    m_pWidget = new cCalibrationWidget(m_pWriter);
    return m_pWidget;
}
 
tVoid cCameraCalibrationFilter::ReleaseView()
{
    delete m_pWidget;
    m_pWidget = nullptr;
}