void UAURDriverOpenCV::OnVideoSourceSwitch()
{
if (IsCalibrationInProgress())
{
CancelCalibration();
}
bNewFrameReady.AtomicSet(false);
OnCameraPropertiesChange();
}
SingleWallCalibrationToolbox::SingleWallCalibrationToolbox(fCalMainWindow* aParentMainWindow, Qt::WFlags aFlags)
: AbstractToolbox(aParentMainWindow)
, QWidget(aParentMainWindow, aFlags)
, m_Calibration(NULL)
, m_Segmentation(NULL)
, m_SpatialCalibrationData(NULL)
, m_SpatialValidationData(NULL)
, m_RecordingBuffer(NULL)
, m_SingleFrameCount(18)
, m_LastRecordedFrameTimestamp(0.0)
, m_CancelRequest(false)
, m_NumberOfCalibrationImagesToAcquire(200)
, m_NumberOfValidationImagesToAcquire(100)
, m_NumberOfSegmentedCalibrationImages(0)
, m_NumberOfSegmentedValidationImages(0)
, m_RecordingIntervalMs(200)
, m_MaxTimeSpentWithProcessingMs(150)
, m_LastProcessingTimePerFrameMs(-1)
{
ui.setupUi(this);
// Create algorithms
m_Calibration = vtkSingleWallCalibrationAlgo::New();
m_Segmentation = vtkLineSegmentationAlgo::New();
// Create tracked frame lists
m_SpatialCalibrationData = vtkTrackedFrameList::New();
m_SpatialCalibrationData->SetValidationRequirements(REQUIRE_UNIQUE_TIMESTAMP | REQUIRE_TRACKING_OK);
m_SpatialValidationData = vtkTrackedFrameList::New();
m_SpatialValidationData->SetValidationRequirements(REQUIRE_UNIQUE_TIMESTAMP | REQUIRE_TRACKING_OK);
m_RecordingBuffer = vtkTrackedFrameList::New();
m_RecordingBuffer->SetValidationRequirements(REQUIRE_UNIQUE_TIMESTAMP | REQUIRE_TRACKING_OK);
// Change result display properties
ui.label_Results->setFont(QFont("Courier", 8));
// Connect events
connect( ui.pushButton_StartSpatial, SIGNAL( clicked() ), this, SLOT( StartCalibration() ) );
connect( ui.pushButton_CancelSpatial, SIGNAL( clicked() ), this, SLOT( CancelCalibration() ) );
connect( ui.pushButton_SingleFrame, SIGNAL( clicked() ), this, SLOT( SingleFrame() ) );
}
void SingleWallCalibrationToolbox::DoCalibration()
{
LOG_TRACE("SingleWallCalibrationToolbox::DoSpatialCalibration");
// Get current time
double startTimeSec = vtkAccurateTimer::GetSystemTime();
// Calibrate if acquisition is ready
if ( m_NumberOfSegmentedCalibrationImages >= m_NumberOfCalibrationImagesToAcquire
&& m_NumberOfSegmentedValidationImages >= m_NumberOfValidationImagesToAcquire)
{
LOG_INFO("Segmentation success rate: " << m_NumberOfSegmentedCalibrationImages + m_NumberOfSegmentedValidationImages << " out of " << m_SpatialCalibrationData->GetNumberOfTrackedFrames() + m_SpatialValidationData->GetNumberOfTrackedFrames() << " (" << (int)(((double)(m_NumberOfSegmentedCalibrationImages + m_NumberOfSegmentedValidationImages) / (double)(m_SpatialCalibrationData->GetNumberOfTrackedFrames() + m_SpatialValidationData->GetNumberOfTrackedFrames())) * 100.0 + 0.49) << " percent)");
m_Calibration->SetTrackedFrameList(m_SpatialCalibrationData);
if (m_Calibration->Calibrate() != PLUS_SUCCESS)
{
LOG_ERROR("Calibration failed!");
CancelCalibration();
return;
}
if (SetAndSaveResults() != PLUS_SUCCESS)
{
LOG_ERROR("Setting and saving results failed!");
CancelCalibration();
return;
}
m_SpatialCalibrationData->Clear();
m_SpatialValidationData->Clear();
SetState(ToolboxState_Done);
m_ParentMainWindow->SetToolboxesEnabled(true);
m_ParentMainWindow->GetVisualizationController()->EnableWireLabels(false);
m_ParentMainWindow->GetVisualizationController()->ShowResult(false);
return;
}
// Cancel if requested
if (m_CancelRequest)
{
LOG_INFO("Calibration process cancelled by the user");
CancelCalibration();
return;
}
// Determine which data container to use
vtkTrackedFrameList* trackedFrameListToUse = NULL;
if (m_NumberOfSegmentedValidationImages < m_NumberOfValidationImagesToAcquire)
{
trackedFrameListToUse = m_SpatialValidationData;
}
else
{
trackedFrameListToUse = m_SpatialCalibrationData;
}
// Acquire tracked frames since last acquisition (minimum 1 frame)
if (m_LastProcessingTimePerFrameMs < 1)
{
// if processing was less than 1ms/frame then assume it was 1ms (1000FPS processing speed) to avoid division by zero
m_LastProcessingTimePerFrameMs = 1;
}
int numberOfFramesToGet = std::max(m_MaxTimeSpentWithProcessingMs / m_LastProcessingTimePerFrameMs, 1);
this->m_RecordingBuffer->Clear();
if ( m_ParentMainWindow->GetSelectedChannel() != NULL && m_ParentMainWindow->GetSelectedChannel()->GetTrackedFrameList(
m_LastRecordedFrameTimestamp, this->m_RecordingBuffer, numberOfFramesToGet) != PLUS_SUCCESS )
{
LOG_ERROR("Failed to get tracked frame list from data collector (last recorded timestamp: " << std::fixed << m_LastRecordedFrameTimestamp );
CancelCalibration();
return;
}
m_Segmentation->Reset();
if( m_Segmentation->Update() != PLUS_SUCCESS )
{
LOG_ERROR("Unable to segment image. Adjust position of line in image.");
QTimer::singleShot(100, this, SLOT(DoCalibration()));
return;
}
// TODO: also, show it on the overlay so the user can see if the segmentation is good
int numberOfNewlySegmentedImages = this->m_RecordingBuffer->GetNumberOfTrackedFrames();
trackedFrameListToUse->AddTrackedFrameList(m_RecordingBuffer, vtkTrackedFrameList::SKIP_INVALID_FRAME);
if (m_NumberOfSegmentedValidationImages < m_NumberOfValidationImagesToAcquire)
{
m_NumberOfSegmentedValidationImages += numberOfNewlySegmentedImages;
}
else
{
m_NumberOfSegmentedCalibrationImages += numberOfNewlySegmentedImages;
}
LOG_DEBUG("Number of segmented images in this round: " << numberOfNewlySegmentedImages << " out of " << m_RecordingBuffer->GetNumberOfTrackedFrames());
// Update progress if tracked frame has been successfully added
int progressPercent = (int)(((m_NumberOfSegmentedCalibrationImages + m_NumberOfSegmentedValidationImages) / (double)(std::max(m_NumberOfValidationImagesToAcquire, m_NumberOfSegmentedValidationImages) + m_NumberOfCalibrationImagesToAcquire)) * 100.0);
m_ParentMainWindow->SetStatusBarProgress(progressPercent);
// Compute time spent with processing one frame in this round
double computationTimeMs = (vtkAccurateTimer::GetSystemTime() - startTimeSec) * 1000.0;
// Update last processing time if new tracked frames have been acquired
if (trackedFrameListToUse->GetNumberOfTrackedFrames() > 0)
{
m_LastProcessingTimePerFrameMs = computationTimeMs / (m_RecordingBuffer->GetNumberOfTrackedFrames());
}
// Launch timer to run acquisition again
int waitTimeMs = std::max((int)(m_RecordingIntervalMs - computationTimeMs), 0);
if (waitTimeMs == 0)
{
LOG_WARNING("Processing cannot keep up with aquisition! Try to decrease MaxTimeSpentWithProcessingMs parameter in device set configuration (it should be more than the processing time (the last one was " << m_LastProcessingTimePerFrameMs << "), so if it is already small, try to increase RecordingIntervalMs too)");
}
LOG_DEBUG("Number of requested frames: " << numberOfFramesToGet);
LOG_DEBUG("Number of tracked frames in the list: " << std::setw(3) << m_RecordingBuffer->GetNumberOfTrackedFrames());
LOG_DEBUG("Last processing time: " << m_LastProcessingTimePerFrameMs);
LOG_DEBUG("Computation time: " << computationTimeMs);
LOG_DEBUG("Waiting time: " << waitTimeMs);
QTimer::singleShot(waitTimeMs, this, SLOT(DoCalibration()));
}
