1. Toy模板网首页
  2. >Toy博客

巴斯勒相机基于SDK 二次开发C++程序

1年前作者：程序员吴同学分类：Toy博客阅读(6)违法举报

这篇具有很好参考价值的文章主要介绍了巴斯勒相机基于SDK 二次开发C++程序。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

巴斯勒相机在VS中如何进行连接调用呢（软触发调用）
1.查找巴斯勒相机网口；
2.调用巴斯勒相机提供的接口，连接巴斯勒相机；
3.初始化相机；
（安装巴斯勒相机软件）

#pragma once
#include <pylon/PylonIncludes.h>
#include "CameraConfiguration.h"
#include "BitmapControl.h"
#include "utilities.h"

#define MAX_CAMERA	10

using namespace std;

class CPylonCamera:
			public CImageEventHandler             // For receiving grabbed images.
			, public CConfigurationEventHandler     // For getting notified about device removal.
{
public:
	CPylonCamera(void);
	~CPylonCamera(void);
public:
	// Device list.
	Pylon::DeviceInfoList_t m_devices;

	// Index of currently used camera.
	int m_ixCamera;

	// The CInstant camera.
	CInstantCamera m_camera[MAX_CAMERA];

	// The TransportLayer.
	Pylon::CTlFactory *m_pTlFactory;

	// Camera Node Map.
	GenApi::INodeMap *m_pCameraNodeMap;

	// The current pixel type.
	Pylon::PixelType m_PixelFormat;

	// To save images.
	bool m_bSaveImage;

	// Pointer for the last grabbed image, which will be displayed.
	CGrabResultPtr m_LastGrabbedImage;

	CBitmapControl m_ImageControl[MAX_CAMERA];

	// Will be used to lock the access.
	GenApi::CLock m_lock;

	// Used to measure the frame rate.
	CStopWatch m_StopWatch;

	// Frame rate
	CMovingAvg<double> m_Fps;

	virtual void OnImageGrabbed(CInstantCamera& camera, const CGrabResultPtr& ptrGrabResult);
	 //virtual void OnGrabError( CInstantCamera& camera, const char* errorMessage);
	 //virtual void OnCameraDeviceRemoved( CInstantCamera& camera);

	// Set up the camera
	void SetupCamera(int index);
	void SetTriggerFunction();
	void SetCamera(int index);
	bool InitCamera(int index,int w=1280,int h=1024);
	bool FindCamera();
	bool Connect(char *szID,int index);
	void StartLive(int index);
	void StopLive(int index);
	void GetOne(int index);
	bool IsGrabbing(int index);

	//设置相机参数
	bool SetFrame(int index,int nValue);				// 设置采集帧率
	bool SetGain(int index,int nValue);					// 设置增益
	bool SetExposureTime(int index,int nValue);	// 设置曝光时间
	bool SetReverseX(int index,bool bEnable);		// 设置X方向镜像

	//相机属性
	static DeviceInfoList_t GetCameraInfoList();
	CString GetDeviceSN(int index);
	CString GetDeviceUserID(int index);

	void GetCameraPrm(int index);

	int m_iExp[MAX_CAMERA];
	int m_iGain[MAX_CAMERA];
	int m_iWidth[MAX_CAMERA];
	int m_iHeight[MAX_CAMERA];
	int m_DevDir[MAX_CAMERA];
	int m_iFrame[MAX_CAMERA];
	bool m_bFrame[MAX_CAMERA];
	CString m_strSerialNumber[MAX_CAMERA];
	int m_CameraList[MAX_CAMERA];
	int m_CurCameraIndex;
	int m_CameraNum;
private:
	int64_t Adjust(int64_t val, int64_t min,int64_t max,int64_t inc);
public:
	long	m_ImgBufLen[MAX_CAMERA];
	BYTE	*m_pGraBuffer[MAX_CAMERA];
	BITMAPINFO *m_pBmpInfo[MAX_CAMERA];
};


#include "StdAfx.h"
#include "PylonCamera.h"

using namespace GenApi;
using namespace Pylon;

CPylonCamera::CPylonCamera(void)
{
	for(int i=0;i<MAX_CAMERA;i++)
	{
		m_iGain[i] = 25;
		m_iWidth[i] = CAMERA_SIZE_X;
		m_iHeight[i] = CAMERA_SIZE_Y;
		m_pGraBuffer[i] = NULL;
		m_camera[i].RegisterConfiguration(new CAcquireContinuousConfiguration, RegistrationMode_ReplaceAll, Ownership_TakeOwnership);
		m_camera[i].RegisterConfiguration( new CameraConfiguration, RegistrationMode_Append, Ownership_TakeOwnership);
		m_camera[i].RegisterConfiguration( this, RegistrationMode_Append, Ownership_ExternalOwnership);
		m_camera[i].RegisterImageEventHandler( this, RegistrationMode_Append, Ownership_ExternalOwnership);
		m_pBmpInfo[i] = new BITMAPINFO;
	}
	m_CurCameraIndex = 0;
}

CPylonCamera::~CPylonCamera(void)
{
	for(int i=0;i<MAX_CAMERA;i++)
	{
		m_camera[i].DestroyDevice();
		delete m_pBmpInfo[i];
		//	回收图像缓冲区
		if(m_pGraBuffer[i]!=NULL) delete []m_pGraBuffer[i];
	}
}

bool CPylonCamera::FindCamera()
{
	CString str;
	m_pTlFactory = &CTlFactory::GetInstance ();
	m_devices.clear ();
	m_pTlFactory->EnumerateDevices (m_devices);
	int nSize = m_devices.size();
	if(m_devices.empty ())
	{
		AfxMessageBox("没有安装相机!");
		return false;
	}
	else
	{
		for(int i = 0; i < nSize; i++)
		{
			str.Format("相机[%d] : %s", i + 1, m_devices[i].GetFullName().c_str());
		}
	}
	return true;
}

bool CPylonCamera::InitCamera(int index,int w,int h)
{
	m_iWidth[index] = w;
	m_iHeight[index] = h;
	m_ImgBufLen[index] = m_iWidth[index] * m_iHeight[index] * 3;

	/*
	分配Bayer转换后图像数据缓冲
	*/
	m_pGraBuffer[index] = new BYTE[(m_iWidth[index]+2) * (m_iHeight[index]+2)];
	ASSERT(m_pGraBuffer);

	// Reset the viewer.
	m_LastGrabbedImage.Release();
	m_ImageControl[index].SetImage(m_LastGrabbedImage);
	// Force CBitmapControl to repaint its client area.
	if(m_ImageControl[index].m_hWnd != NULL) m_ImageControl[index].Invalidate();

	//	初始化BITMAPINFO 结构，此结构在保存bmp文件、显示采集图像时使用
	m_pBmpInfo[index]->bmiHeader.biSize			= sizeof(BITMAPINFOHEADER);
	//	图像宽度，一般为输出窗口宽度
	m_pBmpInfo[index]->bmiHeader.biWidth			= m_iWidth[index];
	//	图像宽度，一般为输出窗口高度
	m_pBmpInfo[index]->bmiHeader.biHeight			= m_iHeight[index];
	/*
	*	以下设置一般相同，
	*	对于低于8位的位图，还应设置相应的位图调色板
	*/
	m_pBmpInfo[index]->bmiHeader.biPlanes			= 1;
	m_pBmpInfo[index]->bmiHeader.biBitCount			= 24;
	m_pBmpInfo[index]->bmiHeader.biCompression		= BI_RGB;
	m_pBmpInfo[index]->bmiHeader.biSizeImage		= 0;
	m_pBmpInfo[index]->bmiHeader.biXPelsPerMeter	= 0;
	m_pBmpInfo[index]->bmiHeader.biYPelsPerMeter	= 0;
	m_pBmpInfo[index]->bmiHeader.biClrUsed			= 0;
	m_pBmpInfo[index]->bmiHeader.biClrImportant		= 0;
	return true;
}

bool CPylonCamera::Connect(char *szID,int index)
{
	if(index<0 || index>=m_CameraNum) return false;
	
	CString str;
	int nSize = m_devices.size();
	int tIndex = -1;
	for(int i=0;i<nSize;i++)
	{
		str.Format(m_devices[i].GetSerialNumber());
		if(str.Compare(szID)==0)
		{
			tIndex = i;
			m_CameraList[index] = i;
			m_strSerialNumber[index] = str;
		}
	}
	if(tIndex<0)
	{
		str.Format("没有找到相机[%s]",szID);
		AfxMessageBox(str);
		return false;
	}
	SetupCamera(index);
	return true;
}

void CPylonCamera::SetupCamera(int index)
{
	CString str;
	int n = m_devices.size();
	if(n<index)
		return;
	try
	{
		m_camera[index].DestroyDevice();
		m_camera[index].Attach(m_pTlFactory->CreateDevice(m_devices[m_CameraList[index]]),Cleanup_None);
		if(m_camera[index].IsOpen())
			m_camera[index].Close();
		m_camera[index].Open();
	}
	catch (GenICam::GenericException& e)
	{
		CString str;
		str.Format(_T("设置相机[%s] error: %s"),m_devices[m_CameraList[index]].GetSerialNumber().c_str(),e.GetDescription());
		TRACE(str);
	}
}

void CPylonCamera::StartLive(int index)
{
	if(m_camera[index].IsGrabbing()) return;
	if (m_camera[index].IsPylonDeviceAttached()) {
		m_camera[index].StartGrabbing(GrabStrategy_OneByOne, GrabLoop_ProvidedByInstantCamera); 
	}
	m_StopWatch.Start();

	// 设置采集参数
	//if(m_iFrame[index]<0) m_iFrame[index]=0;
	//if(m_iFrame[index]>4) m_iFrame[index]=4;
	//SetFrame(index,m_iFrame[index]*10);
	//SetExposureTime(index,m_iExp[index]);
	//SetReverseX(index,m_DevDir[index]==TRUE);
	//SetGain(index,m_iGain[index]);
}

void CPylonCamera::GetOne(int index)
{
	if(m_camera[index].IsGrabbing())
	{
		m_camera[index].StopGrabbing();
		Sleep(200);
	}
	CGrabResultPtr ptrGrabResult;
	m_camera[index].GrabOne(200,ptrGrabResult);
	m_ImageControl[index].SetImage(ptrGrabResult);
}

void CPylonCamera::StopLive(int index)
{
	m_camera[index].StopGrabbing();
}

DeviceInfoList_t CPylonCamera::GetCameraInfoList()
{
	Pylon::DeviceInfoList_t deviceInfoList;
	try
	{
		Pylon::CTlFactory& tlFactory = CTlFactory::GetInstance();
		tlFactory.EnumerateDevices(deviceInfoList);
	}
	catch (GenICam::GenericException& e)
	{
		CString str;
		str.Format(_T("InitAll() error: %s"),e.GetDescription());
		TRACE(str);
	}
	return deviceInfoList;
}

CString CPylonCamera::GetDeviceSN(int index)
{
	if(!m_camera[index].IsPylonDeviceAttached()) return "NULL";
	CString strCameraSN = "";
	DeviceInfoList_t cameraInfoList = CPylonCamera::GetCameraInfoList();
	DeviceInfoList_t::iterator it = cameraInfoList.begin();
	strCameraSN = (*it).GetSerialNumber().c_str();
	return strCameraSN;
}

CString CPylonCamera::GetDeviceUserID(int index)
{
	if(!m_camera[index].IsPylonDeviceAttached()) return "NULL";
	CString strCameraUserID = "";
	DeviceInfoList_t cameraInfoList = CPylonCamera::GetCameraInfoList();
	DeviceInfoList_t::iterator it = cameraInfoList.begin();
	strCameraUserID = (*it).GetUserDefinedName().c_str();
	return strCameraUserID;
}

void CPylonCamera::GetCameraPrm(int index)
{
	m_pCameraNodeMap= &m_camera[index].GetNodeMap();

	CIntegerPtr ptrExp = m_pCameraNodeMap->GetNode ("ExposureTimeRaw");
	m_iExp[index] = (int)ptrExp->GetValue();

	CIntegerPtr ptrGain = m_pCameraNodeMap->GetNode ("GainRaw");
	m_iGain[index] = (int)ptrGain->GetValue();

	CBooleanPtr ptrFrameRateEnable = m_pCameraNodeMap->GetNode("AcquisitionFrameRateEnable");
	m_bFrame[index] = ptrFrameRateEnable->GetValue();

	if(m_bFrame[index] == true)
	{
		CIntegerPtr ptrFrame = m_pCameraNodeMap->GetNode ("AcquisitionFrameRateAbs");
		if(ptrFrame.IsValid())
		{
			m_iFrame[index] = (int)ptrFrame->GetValue();
		}
	}

	CIntegerPtr ptrWidth = m_pCameraNodeMap->GetNode ("Width");
	m_iWidth[index] = (int)ptrWidth->GetValue();

	CIntegerPtr ptrHeight  = m_pCameraNodeMap->GetNode ("Height");
	m_iHeight[index] = (int)ptrHeight->GetValue();
}

void CPylonCamera::SetTriggerFunction()
{
	static bool trigger = false;
	if(!trigger)
	{
		CEnumerationPtr  ptrTrigger  = m_pCameraNodeMap->GetNode ("TriggerMode");
		ptrTrigger->SetIntValue(1);
		trigger = true ;
	}
	else
	{
		CEnumerationPtr  ptrTrigger  = m_pCameraNodeMap->GetNode ("TriggerMode");
		ptrTrigger->SetIntValue(0);
		trigger = false ;
	}
}

void CPylonCamera::SetCamera(int index)
{
	m_pCameraNodeMap= &m_camera[index].GetNodeMap();

	CIntegerPtr ptrExp = m_pCameraNodeMap->GetNode ("ExposureTimeRaw");
	ptrExp->SetValue(m_iExp[index]);

	CIntegerPtr ptrGain = m_pCameraNodeMap->GetNode ("GainRaw");
	ptrGain->SetValue(m_iGain[index]);

	CIntegerPtr ptrWidth = m_pCameraNodeMap->GetNode ("Width");
	ptrWidth->SetValue(m_iWidth[index]);

	CIntegerPtr ptrHeight  = m_pCameraNodeMap->GetNode ("Height");
	ptrHeight->SetValue(m_iHeight[index]);
}

bool CPylonCamera::SetExposureTime(int index,int nValue)
{
	bool ret = false;
	try
	{
		m_pCameraNodeMap = &m_camera[index].GetNodeMap();
		CEnumerationPtr ptrExposureMode(m_pCameraNodeMap->GetNode("ExposureMode"));
		if(IsWritable(ptrExposureMode))
		{
			ptrExposureMode->FromString("Timed");
		}

		CIntegerPtr ptrExposureTimeRaw(m_pCameraNodeMap->GetNode("ExposureTimeRaw"));
		if(ptrExposureTimeRaw.IsValid())
		{
			int64_t newExposureTimeRaw = Adjust(nValue, ptrExposureTimeRaw->GetMin(), ptrExposureTimeRaw->GetMax(), ptrExposureTimeRaw->GetInc());
			ptrExposureTimeRaw->SetValue(newExposureTimeRaw);
			ret = true;
		}
	}
	catch(GenICam::GenericException &e)
	{
		CString str;
		str.Format(_T("SetExposureTimeRaw() error: %s"),e.GetDescription());
		TRACE(str);
	}
	return ret;
}

bool CPylonCamera::SetGain(int index,int nValue)
{
	bool ret = false;
	try
	{
		m_pCameraNodeMap = &m_camera[index].GetNodeMap();
		CEnumerationPtr ptrGainAuto(m_pCameraNodeMap->GetNode("GainAuto"));
		if(IsWritable(ptrGainAuto))
		{
			ptrGainAuto->FromString("Off");
		}

		CEnumerationPtr ptrGainSelector(m_pCameraNodeMap->GetNode("GainSelector"));
		if(IsWritable(ptrGainSelector))
		{
			ptrGainSelector->FromString("DigitalAll");
		}

		CIntegerPtr ptrGainRaw(m_pCameraNodeMap->GetNode("GainRaw"));
		if(ptrGainRaw.IsValid())
		{
			int64_t newGainRaw = Adjust(nValue, ptrGainRaw->GetMin(), ptrGainRaw->GetMax(), ptrGainRaw->GetInc());
			ptrGainRaw->SetValue(newGainRaw);
			ret = true;
		}
	}
	catch(GenICam::GenericException &e)
	{
		CString str;
		str.Format(_T("SetGainRaw() error: %s"),e.GetDescription());
		TRACE(str);
	}
	return ret;
}

bool CPylonCamera::SetFrame(int index,int nValue)
{
	// nValue  帧率, <=0表示无限制
	bool ret = false;
	try
	{
		m_pCameraNodeMap = &m_camera[index].GetNodeMap();
		CBooleanPtr ptrFrameRateEnable(m_pCameraNodeMap->GetNode("AcquisitionFrameRateEnable"));
		if(IsWritable(ptrFrameRateEnable))
		{
			if(nValue<=0) ptrFrameRateEnable->SetValue(false);
			else ptrFrameRateEnable->SetValue(true);
		}

		CIntegerPtr ptrFrameRateAbs(m_pCameraNodeMap->GetNode("AcquisitionFrameRateAbs"));
		if(ptrFrameRateAbs.IsValid())
		{
			int64_t newFrameRateAbs = Adjust(nValue, ptrFrameRateAbs->GetMin(), ptrFrameRateAbs->GetMax(), ptrFrameRateAbs->GetInc());
			ptrFrameRateAbs->SetValue(newFrameRateAbs);
			ret = true;
		}
	}
	catch(GenICam::GenericException &e)
	{
		CString str;
		str.Format(_T("SetFrame() error: %s"),e.GetDescription());
		TRACE(str);
	}
	return ret;
}

bool CPylonCamera::SetReverseX(int index,bool bEnable)
{
	bool ret = false;
	try
	{
		m_pCameraNodeMap = &m_camera[index].GetNodeMap();
		CBooleanPtr ptrFrameRateEnable(m_pCameraNodeMap->GetNode("ReverseX"));
		if(IsWritable(ptrFrameRateEnable))
		{
			ptrFrameRateEnable->SetValue(bEnable);
		}
	}
	catch(GenICam::GenericException &e)
	{
		CString str;
		str.Format(_T("SetReverseX() error: %s"),e.GetDescription());
		TRACE(str);
	}
	return ret;
}

void CPylonCamera::OnImageGrabbed(CInstantCamera& camera, const CGrabResultPtr& ptrGrabResult) 
{
	 if(ptrGrabResult->GrabSucceeded())
	 {
		 CString str;
		 for(int i=0;i<MAX_CAMERA;i++)
		 {
			 str = camera.GetDeviceInfo().GetSerialNumber();
			 if(str.Compare(m_strSerialNumber[i])==0)
			 {
				 m_ImageControl[i].SetImage(ptrGrabResult);
				 return;
			 }
		 }
	 }
}

int64_t CPylonCamera::Adjust(int64_t val, int64_t min,int64_t max,int64_t inc)
{
	if(inc <= 0)
	{
		throw LOGICAL_ERROR_EXCEPTION("Unexpected increment %d",inc);
	}
	if(min > max)
	{
		throw LOGICAL_ERROR_EXCEPTION("minimum bigger than maximum.");
	}
	if(val < min)
	{
		return min;
	}
	if(val > max)
	{
		return max;
	}
	if(inc == 1)
	{
		return val;
	}
	return min + ( ((val - min) / inc) * inc);
}

bool CPylonCamera::IsGrabbing(int index)
{
	return m_camera[index].IsGrabbing();
};

其他引用第三方库以及对应头文件
链接：https://pan.quark.cn/s/71bb1b3e0dad
提取码：JfM9文章来源地址https://www.toymoban.com/news/detail-850997.html

到了这里，关于巴斯勒相机基于SDK 二次开发C++程序的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包赞助服务器费用

相关文章

  • Linux下海康威视工业相机的SDK二次开发

    Linux下海康威视工业相机的SDK二次开发

    1.1安装包的下载和解压 去 官网 下载两个软件安装，分别是客户端和开发环境。 （这里我们下载V2.1.1（Linux）和Runtime组件包（Linux））： 工业相机文档/安装包中的不同安装版本安装包里有各个系统及arm开发板使用的安装包，选择相应的安装包进行安装 （这里我们选择最后一

    2024年02月09日
    浏览(10)
  • 基于海康威视的SDK实现二次开发

    基于海康威视的SDK实现二次开发

    因为网上关于海康威视SDK这块的开发资源比较少，自己也是一步一步摸索过来，知道那种痛苦， 所以把自己的一些过来人的经验写出来供大家学习参考 进入海康威视官网 下载你所需要的SDK开发包（这里我就用windows来作为案列） 下载完SDK解压 里面有开发文档和SDK的动态库文

    2024年04月10日
    浏览(9)
  • 大恒水星相机SDK（实时采集）基于QT与C++

    大恒水星相机SDK（实时采集）基于QT与C++

    资料文档下载 本次的开发环境是基于vs2019使用QT的框架对大恒相机的SDK进行实时采集的操作。我们从零开始讲，根据上面的 资料文档 我们来添加一个新的项目，并且将C++的库文件添加进去。 首先，我们新建的时候使用QT的模板。 记住我们新建的路径，下面添加库文件的时候

    2024年02月04日
    浏览(59)
  • 基于康耐视cognexVisionpro用C#二次开发的多相机视觉对位框架

    基于康耐视cognexVisionpro用C#二次开发的多相机视觉对位框架

    基于康耐视cognexVisionpro用C#二次开发的多相机视觉对位框架 支持1：多相机对位逻辑运算，旋转标定坐标关联运算（可供参考学习）可以协助理解做对位贴合项目思路。 支持2：直接连接运动控制卡，控制UVW平台运动（可供参考学习） 支持3：自动标定程序设定（可供参考学习

    2024年04月15日
    浏览(10)
  • 基于C++开发的医院医学影像PACS 可二次开发，三维重建

    基于C++开发的医院医学影像PACS 可二次开发，三维重建

    医学影像PACS系统源码，集成三维影像后处理功能，包括三维多平面重建、三维容积重建、三维表面重建、三维虚拟内窥镜、最大/小密度投影、心脏动脉钙化分析等功能。系统功能强大，代码完整。有演示。 本套PACS系统专门针对医院工作流程设计的，完全符合医院需要，配置

    2023年04月23日
    浏览(11)
  • 【VisionMaster SDK开发】第三讲 C#二次开发介绍及应用案例

    【VisionMaster SDK开发】第三讲 C#二次开发介绍及应用案例

    VisionMaster（后简称VM）作为一款功能强大的工业图像算法平台，可对工业中遇到的各种图像进行处理，同时拥有性能强大的算子以及丰富的教学例程，作为图像处理的通用平台是非常不错的选择。但Vision Master软件依旧有不足，就是难以配置复杂或定制化的图形界面，故需要结

    2024年02月05日
    浏览(13)

  • WPS二次开发系列：WPS SDK初始化

    本文将详细介绍WPS SDK初始化，帮您能够更好的在项目中接入WPS SDK实现自己的应用和WPS应用进行通信交互。 向WPS官方发送邮件申请，邮件格式如下 邮件模板： 发起人 ：有需要申请接入WPS移动端的企业或者个人 邮件主题： XXX公司XXX项目---WPS Android端 SDK二次开发集成申请 邮件

    2024年04月16日
    浏览(10)
  • Baumer工业相机堡盟相机如何使用NEOAPI SDK实现相机的连接（C++）

    Baumer工业相机堡盟相机如何使用NEOAPI SDK实现相机的连接（C++）

    ​ Baumer工业相机堡盟相机是一种高性能、高质量的工业相机，可用于各种应用场景，如物体检测、计数和识别、运动分析和图像处理。 Baumer的万兆网相机拥有出色的图像处理性能，可以实时传输高分辨率图像。此外，该相机还具有快速数据传输、低功耗、易于集成以及高度

    2024年02月03日
    浏览(10)
  • 图漾相机-SDK开发流程

    图漾相机-SDK开发流程

    请参照我们的在线文档：http://doc.percipio.xyz/cam/last/apiguides/api_description.html 因为所有SDK都是基于C++代码，所以以C++为例： 下载链接：https://www.percipio.xyz/downloadcenter/ 目前图漾SDK支持：Android、ROS、C#、Python、Windows、Halcon、Linux(ubuntu以及嵌入式开发) 深度图 输出的深度图是一个1

    2024年02月07日
    浏览(33)

  • 海康相机开发：SDK安装和ARM开发

    在海康相机开发过程中，首先需要进行SDK的安装和ARM平台的开发。本文将详细介绍如何安装海康相机SDK并进行ARM开发，包括安装步骤和相关源代码。 一、SDK安装步骤： 下载SDK：访问海康官方网站，找到相机SDK的下载页面，根据所需的平台选择合适的SDK版本进行下载。 安装

    2024年02月03日
    浏览(68)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包