408 lines
13 KiB
C++
408 lines
13 KiB
C++
//-----------------------------------------------------------------------------
|
|
// Basler pylon SDK
|
|
// Copyright (c) 2007-2023 Basler AG
|
|
// http://www.baslerweb.com
|
|
// Author: AH
|
|
//-----------------------------------------------------------------------------
|
|
/*!
|
|
\file
|
|
\brief Low Level API: Pylon generic device interface declaration
|
|
*/
|
|
|
|
|
|
#ifndef __PYLON_PYLONDEVICEPROXY__H__
|
|
#define __PYLON_PYLONDEVICEPROXY__H__
|
|
|
|
#if _MSC_VER > 1000
|
|
#pragma once
|
|
#endif
|
|
|
|
#include <pylon/Platform.h>
|
|
|
|
#ifdef _MSC_VER
|
|
# pragma pack(push, PYLON_PACKING)
|
|
#endif /* _MSC_VER */
|
|
|
|
#include <Base/GCException.h>
|
|
#include "Device.h"
|
|
#include "TlFactory.h"
|
|
|
|
|
|
//! Macro to define a custom camera class
|
|
#define PYLON_DEFINE_CAMERA(ClassName, BaseClass) \
|
|
PYLON_6_0_DEPRECATED("Use CBaslerUniversalInstantCamera") \
|
|
class ClassName : public BaseClass \
|
|
{ \
|
|
public: \
|
|
/** \name Construction */ \
|
|
/*@{*/ \
|
|
/** \brief \copybrief Pylon::CPylonDeviceProxyT::CPylonDeviceProxyT()
|
|
\copydetails Pylon::CPylonDeviceProxyT::CPylonDeviceProxyT()
|
|
*/ \
|
|
ClassName() \
|
|
{ \
|
|
} \
|
|
/** \brief \copybrief Pylon::CPylonDeviceProxyT::CPylonDeviceProxyT(IPylonDevice*,bool)
|
|
\copydetails Pylon::CPylonDeviceProxyT::CPylonDeviceProxyT(IPylonDevice*,bool)
|
|
*/ \
|
|
ClassName( IPylonDevice* pDevice, bool takeOwnership = true ) : BaseClass( pDevice, takeOwnership ) \
|
|
{ \
|
|
} \
|
|
/** \brief \copybrief Pylon::CPylonDeviceProxyT::~CPylonDeviceProxyT()
|
|
\copydetails Pylon::CPylonDeviceProxyT::~CPylonDeviceProxyT()
|
|
*/ \
|
|
virtual ~ClassName() \
|
|
{ \
|
|
} \
|
|
/*@}*/ \
|
|
};
|
|
|
|
|
|
namespace Pylon
|
|
{
|
|
//**************************************************************************************************
|
|
//! Low Level API: The camera class for generic camera devices
|
|
/**
|
|
This is the base class for pylon camera classes providing access to camera parameters.
|
|
\see \ref configuringcameras
|
|
|
|
\tparam TCameraParams The camera specific parameter class (auto generated from camera xml file)
|
|
\ingroup Pylon_LowLevelApi
|
|
*/
|
|
//**************************************************************************************************
|
|
template<class TCameraParams>
|
|
class CPylonDeviceProxyT : public TCameraParams
|
|
{
|
|
public:
|
|
//! \name Construction
|
|
// \{
|
|
|
|
//! Creates a camera object that is not attached to an pylon device. Use the Attach() method to attach the device
|
|
CPylonDeviceProxyT();
|
|
|
|
/** \brief Creates a camera object and attaches a camera object to a pylon device that takes the ownership over an pylon device.
|
|
|
|
When having the ownership, the destructor of this camera object destroys the pylon device
|
|
the camera object is attached to. Otherwise, the pylon device object remains valid when the camera
|
|
object has been destroyed.
|
|
*/
|
|
CPylonDeviceProxyT( IPylonDevice*, bool takeOwnership = true );
|
|
|
|
//! Destructor
|
|
virtual ~CPylonDeviceProxyT();
|
|
|
|
//\}
|
|
|
|
|
|
private:
|
|
//! \name Assignment and copying is not supported
|
|
// \{
|
|
CPylonDeviceProxyT( const CPylonDeviceProxyT& );
|
|
CPylonDeviceProxyT& operator=( const CPylonDeviceProxyT& );
|
|
// \}
|
|
|
|
|
|
public:
|
|
//! \name Some smart pointer functionality
|
|
// \{
|
|
|
|
/** \brief Attach the camera object to a pylon device
|
|
|
|
It is not allowed to call Attach when the camera object is already attached!
|
|
|
|
When having the ownership, the destructor of this camera object destroys the pylon device
|
|
the camera object is attached to. Otherwise, the pylon device object remains valid when the camera
|
|
object has been destroyed.
|
|
*/
|
|
virtual void Attach( IPylonDevice*, bool takeOwnership = true );
|
|
|
|
//! Checks if a pylon device is attached to the camera object
|
|
virtual bool IsAttached() const;
|
|
|
|
//! Checks if the camera object has the ownership of the pylon device
|
|
virtual bool HasOwnership() const;
|
|
|
|
//! Returns the pylon device interface pointer
|
|
virtual IPylonDevice* GetDevice() const;
|
|
|
|
// \}
|
|
|
|
|
|
public:
|
|
//! \name Implementation of the IPylonDevice interface.
|
|
//! See Pylon::IPylonDevice for more details.
|
|
// \{
|
|
|
|
/** \brief \copybrief Pylon::IPylonDevice::Open()
|
|
|
|
\copydetails Pylon::IPylonDevice::Open()
|
|
*/
|
|
void Open( AccessModeSet mode = (Stream | Control | Event) )
|
|
{
|
|
CheckDevicePtr();
|
|
m_pDevice->Open( mode );
|
|
}
|
|
|
|
/** \brief \copybrief Pylon::IPylonDevice::Close()
|
|
|
|
\copydetails Pylon::IPylonDevice::Close()
|
|
*/
|
|
void Close( void )
|
|
{
|
|
CheckDevicePtr();
|
|
m_pDevice->Close();
|
|
}
|
|
|
|
/** \brief \copybrief Pylon::IPylonDevice::IsOpen()
|
|
|
|
\copydetails Pylon::IPylonDevice::IsOpen()
|
|
*/
|
|
bool IsOpen( void ) const
|
|
{
|
|
CheckDevicePtr();
|
|
return m_pDevice->IsOpen();
|
|
}
|
|
|
|
/** \brief \copybrief Pylon::IPylonDevice::AccessMode()
|
|
|
|
\copydetails Pylon::IPylonDevice::AccessMode()
|
|
*/
|
|
AccessModeSet AccessMode( void ) const
|
|
{
|
|
CheckDevicePtr();
|
|
return m_pDevice->AccessMode();
|
|
}
|
|
|
|
/** \brief \copybrief Pylon::IPylonDevice::GetDeviceInfo()
|
|
|
|
\copydetails Pylon::IPylonDevice::GetDeviceInfo()
|
|
*/
|
|
const CDeviceInfo& GetDeviceInfo( void ) const
|
|
{
|
|
CheckDevicePtr();
|
|
return m_pDevice->GetDeviceInfo();
|
|
}
|
|
|
|
|
|
/** \brief \copybrief Pylon::IPylonDevice::GetNumStreamGrabberChannels()
|
|
|
|
\copydetails Pylon::IPylonDevice::GetNumStreamGrabberChannels()
|
|
*/
|
|
uint32_t GetNumStreamGrabberChannels( void ) const
|
|
{
|
|
CheckDevicePtr();
|
|
return m_pDevice->GetNumStreamGrabberChannels();
|
|
}
|
|
|
|
/** \brief \copybrief Pylon::IPylonDevice::GetStreamGrabber()
|
|
|
|
\copydetails Pylon::IPylonDevice::GetStreamGrabber()
|
|
*/
|
|
IStreamGrabber* GetStreamGrabber( uint32_t index )
|
|
{
|
|
CheckDevicePtr();
|
|
return m_pDevice->GetStreamGrabber( index );
|
|
}
|
|
|
|
/** \brief \copybrief Pylon::IPylonDevice::GetEventGrabber()
|
|
|
|
\copydetails Pylon::IPylonDevice::GetEventGrabber()
|
|
*/
|
|
IEventGrabber* GetEventGrabber( void )
|
|
{
|
|
CheckDevicePtr();
|
|
return m_pDevice->GetEventGrabber();
|
|
}
|
|
|
|
/** \brief \copybrief Pylon::IPylonDevice::GetNodeMap()
|
|
|
|
\copydetails Pylon::IPylonDevice::GetNodeMap()
|
|
*/
|
|
GenApi::INodeMap* GetNodeMap( void )
|
|
{
|
|
CheckDevicePtr();
|
|
return m_pDevice->GetNodeMap();
|
|
}
|
|
|
|
/** \brief \copybrief Pylon::IPylonDevice::GetTLNodeMap()
|
|
|
|
\copydetails Pylon::IPylonDevice::GetTLNodeMap()
|
|
*/
|
|
GenApi::INodeMap* GetTLNodeMap( void )
|
|
{
|
|
CheckDevicePtr();
|
|
return m_pDevice->GetTLNodeMap();
|
|
}
|
|
|
|
/** \brief \copybrief Pylon::IPylonDevice::CreateChunkParser()
|
|
|
|
\copydetails Pylon::IPylonDevice::CreateChunkParser()
|
|
*/
|
|
Pylon::IChunkParser* CreateChunkParser( void )
|
|
{
|
|
CheckDevicePtr();
|
|
return m_pDevice->CreateChunkParser();
|
|
}
|
|
|
|
/** \brief \copybrief Pylon::IPylonDevice::DestroyChunkParser()
|
|
|
|
\copydetails Pylon::IPylonDevice::DestroyChunkParser()
|
|
*/
|
|
void DestroyChunkParser( Pylon::IChunkParser* pChunkParser )
|
|
{
|
|
CheckDevicePtr();
|
|
m_pDevice->DestroyChunkParser( pChunkParser );
|
|
}
|
|
|
|
|
|
/** \brief \copybrief Pylon::IPylonDevice::CreateEventAdapter()
|
|
|
|
\copydetails Pylon::IPylonDevice::CreateEventAdapter()
|
|
*/
|
|
IEventAdapter* CreateEventAdapter( void )
|
|
{
|
|
CheckDevicePtr();
|
|
return m_pDevice->CreateEventAdapter();
|
|
}
|
|
|
|
/** \brief \copybrief Pylon::IPylonDevice::DestroyEventAdapter()
|
|
|
|
\copydetails Pylon::IPylonDevice::DestroyEventAdapter()
|
|
*/
|
|
void DestroyEventAdapter( IEventAdapter* pAdapter )
|
|
{
|
|
CheckDevicePtr();
|
|
m_pDevice->DestroyEventAdapter( pAdapter );
|
|
}
|
|
|
|
/** \brief \copybrief Pylon::IPylonDevice::CreateSelfReliantChunkParser()
|
|
|
|
\copydetails Pylon::IPylonDevice::CreateSelfReliantChunkParser()
|
|
*/
|
|
virtual ISelfReliantChunkParser* CreateSelfReliantChunkParser()
|
|
{
|
|
CheckDevicePtr();
|
|
return m_pDevice->CreateSelfReliantChunkParser();
|
|
}
|
|
|
|
/** \brief \copybrief Pylon::IPylonDevice::DestroySelfReliantChunkParser()
|
|
|
|
\copydetails Pylon::IPylonDevice::DestroySelfReliantChunkParser()
|
|
*/
|
|
virtual void DestroySelfReliantChunkParser( ISelfReliantChunkParser* pChunkParser )
|
|
{
|
|
CheckDevicePtr();
|
|
m_pDevice->DestroySelfReliantChunkParser( pChunkParser );
|
|
}
|
|
|
|
/** \brief \copybrief Pylon::IPylonDevice::RegisterRemovalCallback()
|
|
|
|
\copydetails Pylon::IPylonDevice::RegisterRemovalCallback()
|
|
*/
|
|
DeviceCallbackHandle RegisterRemovalCallback( DeviceCallback& d )
|
|
{
|
|
CheckDevicePtr();
|
|
return m_pDevice->RegisterRemovalCallback( d );
|
|
}
|
|
|
|
/** \brief \copybrief Pylon::IPylonDevice::DeregisterRemovalCallback()
|
|
|
|
\copydetails Pylon::IPylonDevice::DeregisterRemovalCallback()
|
|
*/
|
|
bool DeregisterRemovalCallback( DeviceCallbackHandle h )
|
|
{
|
|
CheckDevicePtr();
|
|
return m_pDevice->DeregisterRemovalCallback( h );
|
|
}
|
|
|
|
// \}
|
|
|
|
|
|
protected:
|
|
void CheckDevicePtr() const
|
|
{
|
|
if (NULL == m_pDevice)
|
|
{
|
|
throw LOGICAL_ERROR_EXCEPTION( "The camera class is not attached to a IPylonDevice" );
|
|
}
|
|
}
|
|
|
|
IPylonDevice* m_pDevice;
|
|
bool m_hasOwnership;
|
|
};
|
|
|
|
|
|
//**************************************************************************************************
|
|
// CPylonDeviceProxyT implementation
|
|
//**************************************************************************************************
|
|
|
|
template<class TCameraParams>
|
|
inline CPylonDeviceProxyT<TCameraParams>::CPylonDeviceProxyT( void )
|
|
: m_pDevice( NULL )
|
|
, m_hasOwnership( false )
|
|
{
|
|
}
|
|
|
|
template<class TCameraParams>
|
|
inline CPylonDeviceProxyT<TCameraParams>::CPylonDeviceProxyT( IPylonDevice* pDevice, bool takeOwnership )
|
|
: m_pDevice( NULL )
|
|
, m_hasOwnership( false )
|
|
{
|
|
Attach( pDevice, takeOwnership );
|
|
}
|
|
|
|
template<class TCameraParams>
|
|
inline CPylonDeviceProxyT<TCameraParams>::~CPylonDeviceProxyT( void )
|
|
{
|
|
if (HasOwnership() && IsAttached())
|
|
{
|
|
CTlFactory::GetInstance().DestroyDevice( m_pDevice );
|
|
}
|
|
}
|
|
|
|
template<class TCameraParams>
|
|
inline void CPylonDeviceProxyT<TCameraParams>::Attach( IPylonDevice* pDevice, bool takeOwnership )
|
|
{
|
|
if (IsAttached())
|
|
{
|
|
throw LOGICAL_ERROR_EXCEPTION( "Object is already attached to a pylon device" );
|
|
}
|
|
|
|
if (NULL == pDevice)
|
|
{
|
|
throw LOGICAL_ERROR_EXCEPTION( "Tried to attach a NULL pointer as device" );
|
|
}
|
|
|
|
TCameraParams::_Initialize( pDevice->GetNodeMap() );
|
|
|
|
m_pDevice = pDevice;
|
|
m_hasOwnership = takeOwnership;
|
|
}
|
|
|
|
template<class TCameraParams>
|
|
inline bool CPylonDeviceProxyT<TCameraParams>::IsAttached() const
|
|
{
|
|
return NULL != m_pDevice;
|
|
}
|
|
|
|
template<class TCameraParams>
|
|
inline bool CPylonDeviceProxyT<TCameraParams>::HasOwnership() const
|
|
{
|
|
return m_hasOwnership;
|
|
}
|
|
|
|
template<class TCameraParams>
|
|
inline IPylonDevice* CPylonDeviceProxyT<TCameraParams>::GetDevice() const
|
|
{
|
|
return m_pDevice;
|
|
}
|
|
|
|
|
|
} // namespace Pylon
|
|
|
|
#ifdef _MSC_VER
|
|
# pragma pack(pop)
|
|
#endif /* _MSC_VER */
|
|
|
|
#endif
|