Galaxis Codebase: CameraFrameObserver Class Reference

#include <AsyncCamera.hpp>

Inheritance diagram for CameraFrameObserver:

Collaboration diagram for CameraFrameObserver:

Public Member Functions
	CameraFrameObserver (AVT::VmbAPI::CameraPtr camera)

	~CameraFrameObserver ()

virtual void	FrameReceived (const AVT::VmbAPI::FramePtr pFrame)

std::shared_ptr< sensor_msgs::msg::Image >	PopLastImage (bool blocking)

Private Attributes
cv_bridge::CvImage	m_bridgeImg

std::shared_ptr< sensor_msgs::msg::Image >	m_currentImageSPtr

std::mutex	m_currentImageSPtrMutex

std::condition_variable	m_newImageConditionVar

rclcpp::Clock	m_rosClock

AVT::VmbAPI::CameraPtr	m_cameraPtr

Detailed Description

Definition at line 24 of file AsyncCamera.hpp.

Constructor & Destructor Documentation

◆ CameraFrameObserver()

CameraFrameObserver::CameraFrameObserver ( AVT::VmbAPI::CameraPtr camera )

Definition at line 22 of file AsyncCamera.cpp.

                                                                     : AVT::VmbAPI::IFrameObserver( camera ) {
   m_currentImageSPtr = nullptr;
   
   m_cameraPtr = camera;
   m_cameraPtr->FlushQueue();
 }

References m_cameraPtr, and m_currentImageSPtr.

◆ ~CameraFrameObserver()

CameraFrameObserver::~CameraFrameObserver ( )

Definition at line 29 of file AsyncCamera.cpp.

                                           {
   m_cameraPtr->FlushQueue();
 }

References m_cameraPtr.

Member Function Documentation

◆ FrameReceived()

void CameraFrameObserver::FrameReceived ( const AVT::VmbAPI::FramePtr pFrame )

virtual

Definition at line 34 of file AsyncCamera.cpp.

                                                                           {
   auto timestampCameraImage = m_rosClock.now();
   log("[CAMERA] [ALVIUM] Frame received!");
  
   VmbUint32_t nImageSize = 0; 
   if(VmbErrorSuccess != imgFrame->GetImageSize( nImageSize )) {
     log_warning("[CAMERA] [ALVIUM] GetImageSize");
     m_cameraPtr->QueueFrame(imgFrame);
     return;
   }
   VmbUint32_t nWidth = 0;
   if(VmbErrorSuccess != imgFrame->GetWidth( nWidth )) {
     log_warning("[CAMERA] [ALVIUM] GetImageSize");
     m_cameraPtr->QueueFrame(imgFrame);
     return;
   }
   VmbUint32_t nHeight = 0;
   if(VmbErrorSuccess != imgFrame->GetHeight( nHeight )) {
     log_warning("[CAMERA] [ALVIUM] GetImageSize");
     m_cameraPtr->QueueFrame(imgFrame);
     return;
   }
  
   // Get Image
   unsigned char* imagePtr;
   if(VmbErrorSuccess != imgFrame->GetImage( imagePtr )) {
     log_warning("[CAMERA] [ALVIUM] GetImage");
     m_cameraPtr->QueueFrame(imgFrame);
     return;
   }
  
   // COPY TO OPENCV (for resizing)
   // Resize Parameters cv::Size(Width, Height)
   auto outImgSize = cv::Size(512, 256);
  
   if(static_cast<float>(nHeight)/static_cast<float>(nWidth) != static_cast<float>(outImgSize.height)/static_cast<float>(outImgSize.width)) {
     log_warning("[CAMERA] [ALVIUM] Camera Image Ratio NOT equal to desired Image Ration");
   }
  
   cv::Mat img(nHeight, nWidth, CV_8UC3, imagePtr);
   cv::Mat imgResize(outImgSize, CV_8UC3);
   cv::resize(img, imgResize, outImgSize);
  
  
   // release camera img frame => not used afterwards
   m_cameraPtr->QueueFrame(imgFrame);
  
  
   // create image msg and bridge to sensor image msg
   std::shared_ptr<sensor_msgs::msg::Image> msgImgSPtr = std::make_shared<sensor_msgs::msg::Image>();
   std_msgs::msg::Header header;
   header.frame_id = "cam";
   header.stamp = timestampCameraImage;
  
   m_bridgeImg = cv_bridge::CvImage(header, sensor_msgs::image_encodings::RGB8, imgResize);
   m_bridgeImg.toImageMsg(*msgImgSPtr); // cv_bridge to sensor_msgs::Image
  
  
   m_currentImageSPtrMutex.lock();
   m_currentImageSPtr = msgImgSPtr;
   m_newImageConditionVar.notify_one();
   m_currentImageSPtrMutex.unlock();
  
 }

References galaxis::utils::log(), galaxis::utils::log_warning(), m_bridgeImg, m_cameraPtr, m_currentImageSPtr, m_currentImageSPtrMutex, m_newImageConditionVar, and m_rosClock.

Here is the call graph for this function:

◆ PopLastImage()

std::shared_ptr< sensor_msgs::msg::Image > CameraFrameObserver::PopLastImage ( bool blocking )

Definition at line 99 of file AsyncCamera.cpp.

                                                                                   {
   std::unique_lock<std::mutex> lock(m_currentImageSPtrMutex);
   std::shared_ptr<sensor_msgs::msg::Image> ret = m_currentImageSPtr;
   m_currentImageSPtr = nullptr;
  
   // if return image is nullptr and blocking is enabled then wait for new image
   if(ret == nullptr && blocking) {
     m_newImageConditionVar.wait(lock); // release lock and wait until notify_one called
     ret = m_currentImageSPtr;
     m_currentImageSPtr = nullptr;
   }
  
   return ret;
 }