RecordingHandler Class Reference

The RecordingHandler class serves to enumerate the cameras available from the CameraHandler and retrieve and write frames from each camera to the filesystem. The recording of each camera can be disabled through constants and the framerate of the recording can be adjusted to save CPU-time and resources. More...

#include <RecordingHandler.h>

Inheritance diagram for RecordingHandler:

Collaboration diagram for RecordingHandler:

Public Types
enum class	RecordingMode { eCameraHandler , eTagDetectionHandler , eObjectDetectionHandler }
Public Types inherited from AutonomyThread< void >
enum	AutonomyThreadState

Public Member Functions
	RecordingHandler (RecordingMode eRecordingMode)
	Construct a new Recording Handler:: Recording Handler object.
	~RecordingHandler ()
	Destroy the Recording Handler:: Recording Handler object.
void	SetRecordingFPS (const int nRecordingFPS)
	Mutator for the desired FPS for all camera recordings.
int	GetRecordingFPS () const
	Accessor for the desired FPS for all camera recordings.
Public Member Functions inherited from AutonomyThread< void >
	AutonomyThread ()
	Construct a new Autonomy Thread object.
virtual	~AutonomyThread ()
	Destroy the Autonomy Thread object. If the parent object or main thread is destroyed or exited while this thread is still running, a race condition will occur. Stopping and joining the thread here insures that the main program can't exit if the user forgot to stop and join the thread.
void	Start ()
	When this method is called, it starts a new thread that runs the code within the ThreadedContinuousCode method. This is the users main code that will run the important and continuous code for the class.
void	RequestStop ()
	Signals threads to stop executing user code, terminate. DOES NOT JOIN. This method will not force the thread to exit, if the user code is not written properly and contains WHILE statement or any other long-executing or blocking code, then the thread will not exit until the next iteration.
void	Join ()
	Waits for thread to finish executing and then closes thread. This method will block the calling code until thread is finished.
bool	Joinable () const
	Check if the code within the thread and all pools created by it are finished executing and the thread is ready to be closed.
AutonomyThreadState	GetThreadState () const
	Accessor for the Threads State private member.
IPS &	GetIPS ()
	Accessor for the Frame I P S private member.

Private Member Functions
void	ThreadedContinuousCode () override
	This code will run continuously in a separate thread. New frames from the cameras that have recording enabled are grabbed and the images are written to the filesystem.
void	PooledLinearCode () override
	This method holds the code that is ran in the thread pool started by the ThreadedLinearCode() method. It currently does nothing and is not needed in the current implementation of the RecordingHandler.
void	UpdateRecordableCameras ()
	This method is used internally by the class to update the number of cameras that have recording enabled from the camera handler.
void	RequestAndWriteCameraFrames ()
	This method is used internally by the RecordingHandler to request and write frames to from the cameras stored in the member variable vectors.
void	UpdateRecordableTagDetectors ()
	This method is used internally by the class to update the number of TagDetectors that have recording enabled from the camera handler.
void	RequestAndWriteTagDetectorFrames ()
	This method is used internally by the RecordingHandler to request and write frames to from the TagDetectors stored in the member variable vectors.
void	UpdateRecordableObjectDetectors ()
	This method is used internally by the class to update the number of ObjectDetectors that have recording enabled from the camera handler.
void	RequestAndWriteObjectDetectorFrames ()
	This method is used internally by the RecordingHandler to request and write frames to from the ObjectDetectors stored in the member variable vectors.

Private Attributes
int	m_nTotalVideoFeeds
RecordingMode	m_eRecordingMode
std::vector< std::shared_ptr< ZEDCamera > >	m_vZEDCameras
std::vector< std::shared_ptr< BasicCamera > >	m_vBasicCameras
std::vector< std::shared_ptr< TagDetector > >	m_vTagDetectors
std::vector< std::shared_ptr< ObjectDetector > >	m_vObjectDetectors
std::vector< cv::VideoWriter >	m_vCameraWriters
std::vector< bool >	m_vRecordingToggles
std::vector< cv::Mat >	m_vFrames
std::vector< cv::cuda::GpuMat >	m_vGPUFrames
std::vector< std::future< bool > >	m_vFrameFutures

Additional Inherited Members
Protected Member Functions inherited from AutonomyThread< void >
void	RunPool (const unsigned int nNumTasksToQueue, const unsigned int nNumThreads=2, const bool bForceStopCurrentThreads=false)
	When this method is called, it starts/adds tasks to a thread pool that runs nNumTasksToQueue copies of the code within the PooledLinearCode() method using nNumThreads number of threads. This is meant to be used as an internal utility of the child class to further improve parallelization. Default value for nNumThreads is 2.
void	RunDetachedPool (const unsigned int nNumTasksToQueue, const unsigned int nNumThreads=2, const bool bForceStopCurrentThreads=false)
	When this method is called, it starts a thread pool full of threads that don't return std::futures (like a placeholder for the thread return type). This means the thread will not have a return type and there is no way to determine if the thread has finished other than calling the Join() method. Only use this if you want to 'set and forget'. It will be faster as it doesn't return futures. Runs PooledLinearCode() method code. This is meant to be used as an internal utility of the child class to further improve parallelization.
void	ParallelizeLoop (const int nNumThreads, const N tTotalIterations, F &&tLoopFunction)
	Given a ref-qualified looping function and an arbitrary number of iterations, this method will divide up the loop and run each section in a thread pool. This function must not return anything. This method will block until the loop has completed.
void	ClearPoolQueue ()
	Clears any tasks waiting to be ran in the queue, tasks currently running will remain running.
void	JoinPool ()
	Waits for pool to finish executing tasks. This method will block the calling code until thread is finished.
bool	PoolJoinable () const
	Check if the internal pool threads are done executing code and the queue is empty.
void	SetMainThreadIPSLimit (int nMaxIterationsPerSecond=0)
	Mutator for the Main Thread Max I P S private member.
int	GetPoolNumOfThreads ()
	Accessor for the Pool Num Of Threads private member.
int	GetPoolQueueLength ()
	Accessor for the Pool Queue Size private member.
std::vector< void >	GetPoolResults ()
	Accessor for the Pool Results private member. The action of getting results will destroy and remove them from this object. This method blocks if the thread is not finished, so no need to call JoinPool() before getting results.
int	GetMainThreadMaxIPS () const
	Accessor for the Main Thread Max I P S private member.
Protected Attributes inherited from AutonomyThread< void >
IPS	m_IPS

Detailed Description

The RecordingHandler class serves to enumerate the cameras available from the CameraHandler and retrieve and write frames from each camera to the filesystem. The recording of each camera can be disabled through constants and the framerate of the recording can be adjusted to save CPU-time and resources.

Author

clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date

2023-12-26

Member Enumeration Documentation

RecordingMode

enum class RecordingHandler::RecordingMode

strong

        {
            eCameraHandler,            // Record video feeds from the CameraHandler.
            eTagDetectionHandler,      // Record video feeds from the TagDetectionHandler.
            eObjectDetectionHandler    // Record video feeds from the ObjectDetectionHandler.
        };

Constructor & Destructor Documentation

RecordingHandler()

RecordingHandler::RecordingHandler

(

RecordingMode

eRecordingMode

)

Construct a new Recording Handler:: Recording Handler object.

Parameters

eRecordingMode

-

Author

clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date

2024-01-05

{
    // Initialize member variables.
    m_eRecordingMode = eRecordingMode;
    // Set max FPS of the ThreadedContinuousCode method.
    this->SetMainThreadIPSLimit(constants::RECORDER_FPS);
 
    // Resize vectors to match number of video feeds.
    switch (eRecordingMode)
    {
        // RecordingHandler was initialized to record feeds from the CameraHandler.
        case RecordingMode::eCameraHandler:
            // Initialize member variables.
            m_nTotalVideoFeeds = int(CameraHandler::BasicCamName::BASICCAM_END) + int(CameraHandler::ZEDCamName::ZEDCAM_END) - 2;
            // Resize member vectors to match number of total video feeds to record.
            m_vZEDCameras.resize(m_nTotalVideoFeeds);
            m_vBasicCameras.resize(m_nTotalVideoFeeds);
            m_vCameraWriters.resize(m_nTotalVideoFeeds);
            m_vRecordingToggles.resize(m_nTotalVideoFeeds);
            m_vFrames.resize(m_nTotalVideoFeeds);
            m_vGPUFrames.resize(m_nTotalVideoFeeds);
            m_vFrameFutures.resize(m_nTotalVideoFeeds);
            break;
 
        // RecordingHandler was initialized to record feeds from the TagDetectionHandler.
        case RecordingMode::eTagDetectionHandler:
            // Initialize member variables.
            m_nTotalVideoFeeds = int(TagDetectionHandler::TagDetectors::TAGDETECTOR_END) - 1;
            // Resize member vectors to match number of total video feeds to record.
            m_vTagDetectors.resize(m_nTotalVideoFeeds);
            m_vCameraWriters.resize(m_nTotalVideoFeeds);
            m_vRecordingToggles.resize(m_nTotalVideoFeeds);
            m_vFrames.resize(m_nTotalVideoFeeds);
            m_vFrameFutures.resize(m_nTotalVideoFeeds);
            break;
 
        // RecordingHandler was initialized to record feeds from the TagDetectionHandler.
        case RecordingMode::eObjectDetectionHandler:
            // Initialize member variables.
            m_nTotalVideoFeeds = int(ObjectDetectionHandler::ObjectDetectors::OBJECTDETECTOR_END) - 1;
            // Resize member vectors to match number of total video feeds to record.
            m_vObjectDetectors.resize(m_nTotalVideoFeeds);
            m_vCameraWriters.resize(m_nTotalVideoFeeds);
            m_vRecordingToggles.resize(m_nTotalVideoFeeds);
            m_vFrames.resize(m_nTotalVideoFeeds);
            m_vFrameFutures.resize(m_nTotalVideoFeeds);
            break;
 
        default:
            // Do nothing.
            break;
    }
}

Here is the call graph for this function:

~RecordingHandler()

RecordingHandler::~RecordingHandler

(

)

Destroy the Recording Handler:: Recording Handler object.

Author

clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date

2023-12-26

{
    // Signal and wait for recording thread to stop.
    this->RequestStop();
    this->Join();
 
    // Loop through and close video writers.
    for (cv::VideoWriter cvCameraWriter : m_vCameraWriters)
    {
        // Release video writer.
        cvCameraWriter.release();
    }
}

Here is the call graph for this function:

Member Function Documentation

SetRecordingFPS()

void RecordingHandler::SetRecordingFPS

(

const int

nRecordingFPS

)

Mutator for the desired FPS for all camera recordings.

Parameters

nRecordingFPS

- The frames per second to record all cameras at.

Author

clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date

2023-12-26

{
    // Set the max iterations per second of the recording handler.
    this->SetMainThreadIPSLimit(nRecordingFPS);
}

Here is the call graph for this function:

GetRecordingFPS()

int RecordingHandler::GetRecordingFPS

(

)

const

Accessor for the desired FPS for all camera recordings.

Returns

int - The FPS of all camera recordings.

Author

clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date

2023-12-26

{
    // Return member variable value.
    return this->GetMainThreadMaxIPS();
}

Here is the call graph for this function:

ThreadedContinuousCode()

void RecordingHandler::ThreadedContinuousCode ( )

overrideprivatevirtual

This code will run continuously in a separate thread. New frames from the cameras that have recording enabled are grabbed and the images are written to the filesystem.

Author

clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date

2023-12-26

Implements AutonomyThread< void >.

{
    // Check what mode recorder was initialized with.
    switch (m_eRecordingMode)
    {
        // Record video feeds from the CameraHandler.
        case RecordingMode::eCameraHandler:
            // Update recordable cameras.
            this->UpdateRecordableCameras();
            // Grab and write frames to VideoWriters.
            this->RequestAndWriteCameraFrames();
            break;
 
        // Record video feeds from the TagDetectionHandler.
        case RecordingMode::eTagDetectionHandler:
            // Update recordable detectors.
            this->UpdateRecordableTagDetectors();
            // Grab and write overlay frames to VideoWriters.
            this->RequestAndWriteTagDetectorFrames();
            break;
 
        // Record video feeds from the ObjectDetectionHandler.
        case RecordingMode::eObjectDetectionHandler:
            // Update recordable detectors.
            this->UpdateRecordableObjectDetectors();
            // Grab and write overlay frames to VideoWriters.
            this->RequestAndWriteObjectDetectorFrames();
            break;
 
        // Shutdown recording handler.
        default:
            // Submit logger message.
            LOG_ERROR(logging::g_qSharedLogger,
                      "The RecordingHandler was initialized with a RecordingMode enum value that doesn't make sense! Thread is shutting down...");
            // Request main thread stop.
            this->RequestStop();
            break;
    }
}

Here is the call graph for this function:

PooledLinearCode()

void RecordingHandler::PooledLinearCode ( )

overrideprivatevirtual

This method holds the code that is ran in the thread pool started by the ThreadedLinearCode() method. It currently does nothing and is not needed in the current implementation of the RecordingHandler.

Author

clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date

2023-12-26

Implements AutonomyThread< void >.

{}

UpdateRecordableCameras()

void RecordingHandler::UpdateRecordableCameras ( )

private

This method is used internally by the class to update the number of cameras that have recording enabled from the camera handler.

Author

clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date

2023-12-31

{
    // Loop through all Basic cameras from the CameraHandler.
    for (int nCamera = int(CameraHandler::BasicCamName::BASICCAM_START) + 1; nCamera != int(CameraHandler::BasicCamName::BASICCAM_END); ++nCamera)
    {
        // Get pointer to camera.
        std::shared_ptr<BasicCamera> pBasicCamera = globals::g_pCameraHandler->GetBasicCam(static_cast<CameraHandler::BasicCamName>(nCamera));
        // Store camera pointer in vector so we can get images later.
        m_vBasicCameras[nCamera - 1] = pBasicCamera;
 
        // Check if recording for this camera is enabled.
        if (pBasicCamera->GetEnableRecordingFlag() && pBasicCamera->GetCameraIsOpen())
        {
            // Set recording toggle.
            m_vRecordingToggles[nCamera - 1] = true;
            // Setup VideoWriter if needed.
            if (!m_vCameraWriters[nCamera - 1].isOpened())
            {
                // Assemble filepath string.
                std::filesystem::path szFilePath;
                std::filesystem::path szFilenameWithExtension;
                szFilePath = constants::LOGGING_OUTPUT_PATH_ABSOLUTE;                    // Main location for all recordings.
                szFilePath += logging::g_szProgramStartTimeString + "/cameras";          // Folder for each program run.
                szFilenameWithExtension = pBasicCamera->GetCameraLocation() + ".mkv";    // Folder for each camera index or name.
 
                // Check if directory exists.
                if (!std::filesystem::exists(szFilePath))
                {
                    // Create directory.
                    if (!std::filesystem::create_directories(szFilePath))
                    {
                        // Submit logger message.
                        LOG_ERROR(logging::g_qSharedLogger,
                                  "Unable to create the VideoWriter output directory: {} for camera {}",
                                  szFilePath.string(),
                                  pBasicCamera->GetCameraLocation());
                    }
                }
 
                // Construct the full output path.
                std::filesystem::path szFullOutputPath = szFilePath / szFilenameWithExtension;
 
                // Open writer.
                bool bWriterOpened = m_vCameraWriters[nCamera - 1].open(szFullOutputPath.string(),
                                                                        cv::VideoWriter::fourcc('H', '2', '6', '4'),
                                                                        constants::RECORDER_FPS,
                                                                        pBasicCamera->GetPropResolution());
 
                // Check writer opened status.
                if (!bWriterOpened)
                {
                    // Submit logger message.
                    LOG_WARNING(logging::g_qSharedLogger,
                                "RecordingHandler: Failed to open cv::VideoWriter for basic camera at path/index {}",
                                pBasicCamera->GetCameraLocation());
                }
            }
        }
        else
        {
            // Set recording toggle.
            m_vRecordingToggles[nCamera - 1] = false;
        }
    }
 
    // Get index offset so we don't overwrite BasicCam pointers and booleans.
    int nIndexOffset = int(CameraHandler::BasicCamName::BASICCAM_END) - 2;
    // Loop through all ZED cameras from the CameraHandler.
    for (int nCamera = int(CameraHandler::ZEDCamName::ZEDCAM_START) + 1; nCamera != int(CameraHandler::ZEDCamName::ZEDCAM_END); ++nCamera)
    {
        // Get pointer to camera.
        std::shared_ptr<ZEDCamera> pZEDCamera = globals::g_pCameraHandler->GetZED(static_cast<CameraHandler::ZEDCamName>(nCamera));
        // Store camera pointer in vector so we can get images later.
        m_vZEDCameras[nCamera + nIndexOffset] = pZEDCamera;
 
        // Check if recording for this camera is enabled.
        if (pZEDCamera->GetEnableRecordingFlag() && pZEDCamera->GetCameraIsOpen())
        {
            // Set recording toggle.
            m_vRecordingToggles[nCamera + nIndexOffset] = true;
            // Setup VideoWriter if needed.
            if (!m_vCameraWriters[nCamera + nIndexOffset].isOpened())
            {
                // Assemble filepath string.
                std::filesystem::path szFilePath;
                std::filesystem::path szFilenameWithExtension;
                szFilePath = constants::LOGGING_OUTPUT_PATH_ABSOLUTE;                                               // Main location for all recordings.
                szFilePath += logging::g_szProgramStartTimeString + "/cameras";                                     // Folder for each program run.
                szFilenameWithExtension =
                    pZEDCamera->GetCameraModel() + "_" + std::to_string(pZEDCamera->GetCameraSerial()) + ".mkv";    // Folder for each camera index or name.
 
                // Check if directory exists.
                if (!std::filesystem::exists(szFilePath))
                {
                    // Create directory.
                    if (!std::filesystem::create_directories(szFilePath))
                    {
                        // Submit logger message.
                        LOG_ERROR(logging::g_qSharedLogger,
                                  "Unable to create the output directory: {} for camera {} ({})",
                                  szFilePath.string(),
                                  pZEDCamera->GetCameraModel(),
                                  pZEDCamera->GetCameraSerial());
                    }
                }
 
                // Construct the full output path.
                std::filesystem::path szFullOutputPath = szFilePath / szFilenameWithExtension;
 
                // Open writer.
                bool bWriterOpened = m_vCameraWriters[nCamera + nIndexOffset].open(szFullOutputPath,
                                                                                   cv::VideoWriter::fourcc('H', '2', '6', '4'),
                                                                                   constants::RECORDER_FPS,
                                                                                   pZEDCamera->GetPropResolution());
 
                // Check writer opened status.
                if (!bWriterOpened)
                {
                    // Submit logger message.
                    LOG_WARNING(logging::g_qSharedLogger,
                                "RecordingHandler: Failed to open cv::VideoWriter for ZED camera with serial {}",
                                pZEDCamera->GetCameraSerial());
                }
            }
        }
        else
        {
            // Set recording toggle.
            m_vRecordingToggles[nCamera + nIndexOffset] = false;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

RequestAndWriteCameraFrames()

void RecordingHandler::RequestAndWriteCameraFrames ( )

private

This method is used internally by the RecordingHandler to request and write frames to from the cameras stored in the member variable vectors.

Author

clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date

2024-01-01

{
    // Loop through total number of cameras and request frames.
    for (int nIter = 0; nIter < m_nTotalVideoFeeds; ++nIter)
    {
        // Check if recording for the camera at this index is enabled.
        if (m_vRecordingToggles[nIter])
        {
            // Check if the camera at the current index is a BasicCam or ZEDCam.
            if (m_vBasicCameras[nIter] != nullptr)
            {
                // Request frame.
                m_vFrameFutures[nIter] = m_vBasicCameras[nIter]->RequestFrameCopy(m_vFrames[nIter]);
            }
            else if (m_vZEDCameras[nIter] != nullptr)
            {
                // Check if the camera is setup to use CPU or GPU mats.
                if (m_vZEDCameras[nIter]->GetUsingGPUMem())
                {
                    // Grab frames from camera.
                    m_vFrameFutures[nIter] = m_vZEDCameras[nIter]->RequestFrameCopy(m_vGPUFrames[nIter]);
                }
                else
                {
                    // Grab frames from camera.
                    m_vFrameFutures[nIter] = m_vZEDCameras[nIter]->RequestFrameCopy(m_vFrames[nIter]);
                }
            }
        }
    }
 
    // Loop through cameras and wait for frame requests to be fulfilled.
    for (int nIter = 0; nIter < m_nTotalVideoFeeds; ++nIter)
    {
        // Check if recording for the camera at this index is enabled.
        if (m_vRecordingToggles[nIter])
        {
            // Check if the camera at the current index is a BasicCam or ZEDCam.
            if (m_vBasicCameras[nIter] != nullptr)
            {
                // Wait for future to be fulfilled.
                if (m_vFrameFutures[nIter].get() && !m_vFrames[nIter].empty())
                {
                    // Check if this is a grayscale or color image.
                    if (m_vFrames[nIter].channels() == 1)
                    {
                        // Convert frame from 1 channel grayscale to 3 channel BGR.
                        cv::cvtColor(m_vFrames[nIter], m_vFrames[nIter], cv::COLOR_GRAY2BGR);
                    }
                    // Check if this has an alpha channel.
                    else if (m_vFrames[nIter].channels() == 4)
                    {
                        // Convert from from 4 channels to 3 channels.
                        cv::cvtColor(m_vFrames[nIter], m_vFrames[nIter], cv::COLOR_BGRA2BGR);
                    }
 
                    // Write frame to OpenCV video writer.
                    m_vCameraWriters[nIter].write(m_vFrames[nIter]);
                }
            }
            else if (m_vZEDCameras[nIter] != nullptr)
            {
                // Check if the camera is setup to use CPU or GPU mats.
                if (m_vZEDCameras[nIter]->GetUsingGPUMem())
                {
                    // Wait for future to be fulfilled.
                    if (m_vFrameFutures[nIter].get() && !m_vGPUFrames[nIter].empty())
                    {
                        // Download GPU mat frame to normal mat.
                        m_vGPUFrames[nIter].download(m_vFrames[nIter]);
 
                        // Check if this is a grayscale or color image.
                        if (m_vFrames[nIter].channels() == 1)
                        {
                            // Convert frame from 1 channel grayscale to 3 channel BGR.
                            cv::cvtColor(m_vFrames[nIter], m_vFrames[nIter], cv::COLOR_GRAY2BGR);
                        }
                        // Check if this has an alpha channel.
                        else if (m_vFrames[nIter].channels() == 4)
                        {
                            // Convert from from 4 channels to 3 channels.
                            cv::cvtColor(m_vFrames[nIter], m_vFrames[nIter], cv::COLOR_BGRA2BGR);
                        }
 
                        // Write frame to OpenCV video writer.
                        m_vCameraWriters[nIter].write(m_vFrames[nIter]);
                    }
                }
                else
                {
                    // Wait for future to be fulfilled.
                    if (m_vFrameFutures[nIter].get() && !m_vFrames[nIter].empty())
                    {
                        // Check if this is a grayscale or color image.
                        if (m_vFrames[nIter].channels() == 1)
                        {
                            // Convert frame from 1 channel grayscale to 3 channel BGR.
                            cv::cvtColor(m_vFrames[nIter], m_vFrames[nIter], cv::COLOR_GRAY2BGR);
                        }
                        // Check if this has an alpha channel.
                        else if (m_vFrames[nIter].channels() == 4)
                        {
                            // Convert from from 4 channels to 3 channels.
                            cv::cvtColor(m_vFrames[nIter], m_vFrames[nIter], cv::COLOR_BGRA2BGR);
                        }
 
                        // Write frame to OpenCV video writer.
                        m_vCameraWriters[nIter].write(m_vFrames[nIter]);
                    }
                }
            }
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateRecordableTagDetectors()

void RecordingHandler::UpdateRecordableTagDetectors ( )

private

This method is used internally by the class to update the number of TagDetectors that have recording enabled from the camera handler.

Author

clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date

2023-12-31

{
    // Loop through all Basic cameras from the CameraHandler.
    for (int nDetector = int(TagDetectionHandler::TagDetectors::TAGDETECTOR_START) + 1; nDetector != int(TagDetectionHandler::TagDetectors::TAGDETECTOR_END); ++nDetector)
    {
        // Get pointer to camera.
        std::shared_ptr<TagDetector> pTagDetector = globals::g_pTagDetectionHandler->GetTagDetector(static_cast<TagDetectionHandler::TagDetectors>(nDetector));
        // Store camera pointer in vector so we can get images later.
        m_vTagDetectors[nDetector - 1] = pTagDetector;
 
        // Check if recording for this camera is enabled.
        if (pTagDetector->GetEnableRecordingFlag() && pTagDetector->GetIsReady())
        {
            // Set recording toggle.
            m_vRecordingToggles[nDetector - 1] = true;
            // Setup VideoWriter if needed.
            if (!m_vCameraWriters[nDetector - 1].isOpened())
            {
                // Assemble filepath string.
                std::filesystem::path szFilePath;
                std::filesystem::path szFilenameWithExtension;
                szFilePath = constants::LOGGING_OUTPUT_PATH_ABSOLUTE;                  // Main location for all recordings.
                szFilePath += logging::g_szProgramStartTimeString + "/tagdetector";    // Folder for each program run.
                szFilenameWithExtension = pTagDetector->GetCameraName() + ".mkv";      // Folder for each camera index or name.
 
                // Check if directory exists.
                if (!std::filesystem::exists(szFilePath))
                {
                    // Create directory.
                    if (!std::filesystem::create_directories(szFilePath))
                    {
                        // Submit logger message.
                        LOG_ERROR(logging::g_qSharedLogger,
                                  "Unable to create the VideoWriter output directory: {} for tag detector {}",
                                  szFilePath.string(),
                                  pTagDetector->GetCameraName());
                    }
                }
 
                // Construct the full output path.
                std::filesystem::path szFullOutputPath = szFilePath / szFilenameWithExtension;
 
                // Open writer.
                bool bWriterOpened = m_vCameraWriters[nDetector - 1].open(szFullOutputPath.string(),
                                                                          cv::VideoWriter::fourcc('H', '2', '6', '4'),
                                                                          constants::RECORDER_FPS,
                                                                          pTagDetector->GetProcessFrameResolution());
 
                // Check writer opened status.
                if (!bWriterOpened)
                {
                    // Submit logger message.
                    LOG_WARNING(logging::g_qSharedLogger,
                                "RecordingHandler: Failed to open cv::VideoWriter for tag detector using camera {}",
                                pTagDetector->GetCameraName());
                }
            }
        }
        else
        {
            // Set recording toggle.
            m_vRecordingToggles[nDetector - 1] = false;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

RequestAndWriteTagDetectorFrames()

void RecordingHandler::RequestAndWriteTagDetectorFrames ( )

private

This method is used internally by the RecordingHandler to request and write frames to from the TagDetectors stored in the member variable vectors.

Author

clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date

2024-01-01

{
    // Loop through total number of cameras and request frames.
    for (int nIter = 0; nIter < m_nTotalVideoFeeds; ++nIter)
    {
        // Check if recording for the camera at this index is enabled and tag detector at index is not null.
        if (m_vRecordingToggles[nIter] && m_vTagDetectors[nIter] != nullptr)
        {
            // Request frame.
            m_vFrameFutures[nIter] = m_vTagDetectors[nIter]->RequestDetectionOverlayFrame(m_vFrames[nIter]);
        }
    }
 
    // Loop through cameras and wait for frame requests to be fulfilled.
    for (int nIter = 0; nIter < m_nTotalVideoFeeds; ++nIter)
    {
        // Check if recording for the camera at this index is enabled and tag detector is not null.
        if (m_vRecordingToggles[nIter] && m_vTagDetectors[nIter] != nullptr)
        {
            // Wait for future to be fulfilled.
            if (m_vFrameFutures[nIter].get() && !m_vFrames[nIter].empty())
            {
                // Check if this is a grayscale or color image.
                if (m_vFrames[nIter].channels() == 1)
                {
                    // Convert frame from 1 channel grayscale to 3 channel BGR.
                    cv::cvtColor(m_vFrames[nIter], m_vFrames[nIter], cv::COLOR_GRAY2BGR);
                }
                // Check if this has an alpha channel.
                else if (m_vFrames[nIter].channels() == 4)
                {
                    // Convert from from 4 channels to 3 channels.
                    cv::cvtColor(m_vFrames[nIter], m_vFrames[nIter], cv::COLOR_BGRA2BGR);
                }
 
                // Write frame to OpenCV video writer.
                m_vCameraWriters[nIter].write(m_vFrames[nIter]);
            }
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateRecordableObjectDetectors()

void RecordingHandler::UpdateRecordableObjectDetectors ( )

private

This method is used internally by the class to update the number of ObjectDetectors that have recording enabled from the camera handler.

Author

clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date

2023-12-31

{
    // Loop through all Basic cameras from the CameraHandler.
    for (int nDetector = int(ObjectDetectionHandler::ObjectDetectors::OBJECTDETECTOR_START) + 1;
         nDetector != int(ObjectDetectionHandler::ObjectDetectors::OBJECTDETECTOR_END);
         ++nDetector)
    {
        // Get pointer to camera.
        std::shared_ptr<ObjectDetector> pObjectDetector =
            globals::g_pObjectDetectionHandler->GetObjectDetector(static_cast<ObjectDetectionHandler::ObjectDetectors>(nDetector));
        // Store camera pointer in vector so we can get images later.
        m_vObjectDetectors[nDetector - 1] = pObjectDetector;
 
        // Check if recording for this camera is enabled.
        if (pObjectDetector->GetEnableRecordingFlag() && pObjectDetector->GetIsReady())
        {
            // Set recording toggle.
            m_vRecordingToggles[nDetector - 1] = true;
            // Setup VideoWriter if needed.
            if (!m_vCameraWriters[nDetector - 1].isOpened())
            {
                // Assemble filepath string.
                std::filesystem::path szFilePath;
                std::filesystem::path szFilenameWithExtension;
                szFilePath = constants::LOGGING_OUTPUT_PATH_ABSOLUTE;                     // Main location for all recordings.
                szFilePath += logging::g_szProgramStartTimeString + "/objectdetector";    // Folder for each program run.
                szFilenameWithExtension = pObjectDetector->GetCameraName() + ".mkv";      // Folder for each camera index or name.
 
                // Check if directory exists.
                if (!std::filesystem::exists(szFilePath))
                {
                    // Create directory.
                    if (!std::filesystem::create_directories(szFilePath))
                    {
                        // Submit logger message.
                        LOG_ERROR(logging::g_qSharedLogger,
                                  "Unable to create the VideoWriter output directory: {} for tag detector {}",
                                  szFilePath.string(),
                                  pObjectDetector->GetCameraName());
                    }
                }
 
                // Construct the full output path.
                std::filesystem::path szFullOutputPath = szFilePath / szFilenameWithExtension;
 
                // Open writer.
                bool bWriterOpened = m_vCameraWriters[nDetector - 1].open(szFullOutputPath.string(),
                                                                          cv::VideoWriter::fourcc('H', '2', '6', '4'),
                                                                          constants::RECORDER_FPS,
                                                                          pObjectDetector->GetProcessFrameResolution());
 
                // Check writer opened status.
                if (!bWriterOpened)
                {
                    // Submit logger message.
                    LOG_WARNING(logging::g_qSharedLogger,
                                "RecordingHandler: Failed to open cv::VideoWriter for tag detector using camera {}",
                                pObjectDetector->GetCameraName());
                }
            }
        }
        else
        {
            // Set recording toggle.
            m_vRecordingToggles[nDetector - 1] = false;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

RequestAndWriteObjectDetectorFrames()

void RecordingHandler::RequestAndWriteObjectDetectorFrames ( )

private

This method is used internally by the RecordingHandler to request and write frames to from the ObjectDetectors stored in the member variable vectors.

Author

clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date

2024-01-01

{
    // Loop through total number of cameras and request frames.
    for (int nIter = 0; nIter < m_nTotalVideoFeeds; ++nIter)
    {
        // Check if recording for the camera at this index is enabled and tag detector at index is not null.
        if (m_vRecordingToggles[nIter] && m_vObjectDetectors[nIter] != nullptr)
        {
            // Request frame.
            m_vFrameFutures[nIter] = m_vObjectDetectors[nIter]->RequestDetectionOverlayFrame(m_vFrames[nIter]);
        }
    }
 
    // Loop through cameras and wait for frame requests to be fulfilled.
    for (int nIter = 0; nIter < m_nTotalVideoFeeds; ++nIter)
    {
        // Check if recording for the camera at this index is enabled and tag detector is not null.
        if (m_vRecordingToggles[nIter] && m_vObjectDetectors[nIter] != nullptr)
        {
            // Wait for future to be fulfilled.
            if (m_vFrameFutures[nIter].get() && !m_vFrames[nIter].empty())
            {
                // Check if this is a grayscale or color image.
                if (m_vFrames[nIter].channels() == 1)
                {
                    // Convert frame from 1 channel grayscale to 3 channel BGR.
                    cv::cvtColor(m_vFrames[nIter], m_vFrames[nIter], cv::COLOR_GRAY2BGR);
                }
                // Check if this has an alpha channel.
                else if (m_vFrames[nIter].channels() == 4)
                {
                    // Convert from from 4 channels to 3 channels.
                    cv::cvtColor(m_vFrames[nIter], m_vFrames[nIter], cv::COLOR_BGRA2BGR);
                }
 
                // Write frame to OpenCV video writer.
                m_vCameraWriters[nIter].write(m_vFrames[nIter]);
            }
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this class was generated from the following files:

• src/handlers/RecordingHandler.h
• src/handlers/RecordingHandler.cpp