  • 法律声明
  • 首页
  • 更新记录
  • 编程引导
  • 接口函数
  • 示例程序
  • 错误码定义
法律声明

在法律允许的最大范围内，本文档是“按照现状”提供，可能存在瑕疵或错误。本公司不对本文档提供任何形式的明示或默示保证，包括但不限于适销性、质量满意度、适合特定目的、不侵犯第三方权利等保证；亦不对使用或是分发本文档导致的任何特殊、附带、偶然或间接的损害进行赔偿，包括但不限于商业利润损失、系统故障、数据或文档丢失产生的损失。


  • 接口函数
  • 示例程序
  • 错误码定义
工业采集卡SDK开发指南V2.1.0（.NET）

概述

工业采集卡SDK开发指南主要对API的使用进行说明。API库为所有采集卡提供统一的访问控制接口，可简化接口调用，支持多种类型卡同时使用。
目前支持GigE Vision采集卡、CoaXPress采集卡和Camera Link采集卡，其接口主要分为枚举接口、采集卡接口、设备控制接口、流控制接口、参数模块接口、图像处理接口、缓存接口、附加和回调接口九个部分，为用户使用软件设计提供较高的自由度。

开始使用

SDK版本更新记录 | 记录SDK各版本的主要更新情况。
编程引导 | 介绍.NET接口使用流程。
接口函数 | 介绍所有.NET接口函数。
示例程序 | 介绍常见用例和接口基本的使用方法。
错误码 | 介绍接口函数返回的错误码定义，方便程序出现问题时进行排查。

运行环境

GigE Vision采集卡
硬件配置：PCI-E gen2 × 4
软件环境：Windows 7/10 32/64bits操作系统
CoaXPress采集卡
硬件配置：PCI-E gen2 × 8（CoaXPress-6采集卡）、PCI-E gen3 × 8（CoaXPress-12采集卡）
软件环境：Windows 7/10 32/64bits操作系统
Camera Link采集卡
硬件配置：PCI-E gen2 × 4
软件环境：Windows 7/10 32/64bits操作系统


SDK版本更新记录
更新版本 | 更新说明
V2.1.0 | 新增通过采集卡ID打开采集卡，可指定采集卡权限： CSystem.OpenInterfaceByID()
 | 新增通过设备ID打开设备： CInterface.OpenDeviceByID()
 | 新增保存TIFF图像： CImageProcess.SaveTiffToFile()
 | 新增保存PNG图像： CImageProcess.SavePngToFile()
 | 新增无损解码： CImageProcess.HB_Decode()
 | 新增回调模块，包括注册事件回调函数： CCallback.RegisterEventCallBack() 、注册异常信息回调函数： CCallback.RegisterExceptionCallBack()
 | 示例程序章节，新增获取采集卡事件
V2.0.0 | 实现.NET接口，可提供枚举接口、采集卡接口、设备控制接口、流控制接口、参数模块接口、图像处理接口、缓存和附加接口


接口函数基本使用流程
本章节介绍了.NET接口取图流程和取图方式。其中白色区域为采集卡相关接口，蓝色区域为相机相关接口，橙色区域为流相关接口，绿色区域为取图方式。
SDK获取图像有主动取图和回调取图两种方式（两种方式不能同时使用）：
• 主动取图：调用 CStream.StartAcquisition() 开始取流，然后调用 CStream.GetFrameBuffer() 获取图像缓存信息，再调用 CStream.ReleaseFrameBuffer() 释放图像缓存。
• 回调取图：使用 CStream.RegisterImageCallBack() 接口注册自定义的回调函数，然后调用 CStream.StartAcquisition() 开始取流。
• 注意事项：
a、两种取图方式不能同时使用。
b、回调函数中不建议有耗时操作、线程锁等，容易造成回调阻塞。
c、图像缓存结构内的图像数据是一个地址指针，建议在回调取图方式中将里面的数据拷贝出来另建线程使用。


接口函数
这里列出了所有模块:
枚举模块 | 枚举模块的接口可枚举各种类型的采集卡
采集卡模块 | 采集卡模块的接口可获取采集卡句柄、更新指定采集卡列表等操作
设备控制模块 | 设备控制模块的接口可获取设备句柄、关闭设备等一系列设备的基本功能
流控制模块 | 流控制模块的接口可获取流通道图像大小、注册缓存、取消缓存等功能
参数模块 | 参数模块的接口可获取和设置采集卡和相机的所有属性节点
图像处理模块 | 图像处理模块的接口可将采集到的的图像进行多样的图像处理操作
缓存模块 | 缓存模块接口可通过缓存句柄获取缓存的数据信息
附加模块 | 附加模块的接口可将byte数组转换为特定类型结构体
回调模块 | 回调模块的接口可获取注册事件等多种数据信息


类
枚举模块

枚举模块的接口可枚举各种类型的采集卡 更多...

类

class CSystem
枚举模块 更多...

详细描述

枚举模块的接口可枚举各种类型的采集卡


Public 成员函数 | 静态 Public 成员函数 | 所有成员列表
CSystem类 参考
枚举模块

枚举模块 更多...

Public 成员函数

string | GetSDKVersion ()
获取SDK版本信息 更多...
int | UpdateInterfaceList (uint nTLayerType, ref bool bChanged)
枚举采集卡 更多...
int | GetNumInterfaces (ref uint nNumIfaces)
获取采集卡数量 更多...
int | GetInterfaceInfo (uint nIndex, ref MV_FG_INTERFACE_INFO stIfaceInfo)
获取采集卡信息 更多...
int | OpenInterface (uint nIndex, out CInterface cInterface)
通过索引下标打开采集卡，不可指定采集卡权限 更多...
int | OpenInterface (uint nIndex, int nAccess, out CInterface cInterface)
通过索引下标打开采集卡，可指定采集卡权限 更多...
int | OpenInterfaceByID (String strInterfaceID, int nAccess, out CInterface cInterface)
通过采集卡ID打开采集卡，可指定采集卡权限 更多...
int | ReleaseTLayerResource (uint nTLayer)
释放指定类型的采集卡资源 更多...

静态 Public 成员函数

static IntPtr | MV_MEM_Alloc (uint nSize, uint nAlign)
对齐申请内存 更多...
static void | MV_MEM_Free (IntPtr ptrBuffer)
释放内存 更多...

详细描述

枚举模块

成员函数说明

◆ GetSDKVersion()

string CSystem.GetSDKVersion ( )

获取SDK版本信息

返回
版本信息字符串

格式：“版本 + 类型 + 编译时间”。

◆ UpdateInterfaceList()

int CSystem.UpdateInterfaceList | ( | uint | nTLayerType,
 |  | ref bool | bChanged
 | ) |  |

枚举采集卡

参数
nTLayerType | 采集卡类型，如要枚举多个类型可进行或操作
bChanged | 设备列表是否改变
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

进行采集卡操作之前必须调用该接口，只有在调用该接口时内部采集卡列表才会更新。

◆ GetNumInterfaces()

int CSystem.GetNumInterfaces ( ref uint nNumIfaces )

获取采集卡数量

参数
nNumIfaces 采集卡数量
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ GetInterfaceInfo()

int CSystem.GetInterfaceInfo | ( | uint | nIndex,
 |  | ref MV_FG_INTERFACE_INFO | stIfaceInfo
 | ) |  |

获取采集卡信息

参数
nIndex | 采集卡索引
stIfaceInfo | 采集卡信息
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ OpenInterface() [1/2]

int CSystem.OpenInterface | ( | uint | nIndex,
 |  | out CInterface | cInterface
 | ) |  |

通过索引下标打开采集卡，不可指定采集卡权限

参数
nIndex | 采集卡索引
cInterface | 采集卡控制类
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

CoaXPress和Camera Link采集卡只能以MV_FG_ACCESS_CONTROL权限打开。

◆ OpenInterface() [2/2]

int CSystem.OpenInterface | ( | uint | nIndex,
 |  | int | nAccess,
 |  | out CInterface | cInterface
 | ) |  |

通过索引下标打开采集卡，可指定采集卡权限

参数
nIndex | 采集卡索引
nAccess | 权限
cInterface | 采集卡控制类
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ OpenInterfaceByID()

int CSystem.OpenInterfaceByID | ( | String | strInterfaceID,
 |  | int | nAccess,
 |  | out CInterface | cInterface
 | ) |  |

通过采集卡ID打开采集卡，可指定采集卡权限

参数
strInterfaceID | 采集卡ID
nAccess | 权限
cInterface | 采集卡控制类
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ ReleaseTLayerResource()

int CSystem.ReleaseTLayerResource ( uint nTLayer )

释放指定类型的采集卡资源

参数
nTLayer 采集卡资源类型
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

调用该接口之前必须关闭所有该类型的采集卡。

◆ MV_MEM_Alloc()

static IntPtr CSystem.MV_MEM_Alloc | ( | uint | nSize,
 |  | uint | nAlign
 | ) |  |
static

对齐申请内存

参数
nSize | 内存大小
nAlign | 对齐长度
返回
非托管内存

◆ MV_MEM_Free()

static void CSystem.MV_MEM_Free ( IntPtr ptrBuffer )
static

释放内存

参数
ptrBuffer CSystem.MV_MEM_Alloc() 函数申请的非托管内存


类
采集卡模块

采集卡模块的接口可获取采集卡句柄、更新指定采集卡列表等操作 更多...

类

class CInterface
采集卡模块 更多...

详细描述

采集卡模块的接口可获取采集卡句柄、更新指定采集卡列表等操作


Public 成员函数 | 所有成员列表
CInterface类 参考
采集卡模块

采集卡模块 更多...

Public 成员函数

CInterface (IntPtr ptrHandle)
初始化 更多...
IntPtr | GetHandle ()
获取采集卡句柄 更多...
int | CloseInterface ()
关闭采集卡 更多...
int | UpdateDeviceList (ref bool bChanged)
更新指定采集卡下的设备列表 更多...
int | GetNumDevices (ref uint nNumDevices)
获取指定采集卡下的设备数量 更多...
int | GetDeviceInfo (uint nIndex, ref MV_FG_DEVICE_INFO stDevInfo)
获取设备信息 更多...
int | OpenDevice (uint nIndex, out CDevice cDevice)
通过索引下标打开设备 更多...
int | OpenDeviceByID (String strDeviceID, out CDevice cDevice)
int | CloseDevice ()
关闭设备 更多...

详细描述

采集卡模块

构造及析构函数说明

◆ CInterface()

CInterface.CInterface ( IntPtr ptrHandle )

初始化

参数
ptrHandle 采集卡句柄

成员函数说明

◆ GetHandle()

IntPtr CInterface.GetHandle ( )

获取采集卡句柄

◆ CloseInterface()

int CInterface.CloseInterface ( )

关闭采集卡

返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ UpdateDeviceList()

int CInterface.UpdateDeviceList ( ref bool bChanged )

更新指定采集卡下的设备列表

参数
bChanged 设备列表是否改变
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

仅在调用该接口时内部设备列表才可更新。

◆ GetNumDevices()

int CInterface.GetNumDevices ( ref uint nNumDevices )

获取指定采集卡下的设备数量

参数
nNumDevices 设备数量
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ GetDeviceInfo()

int CInterface.GetDeviceInfo | ( | uint | nIndex,
 |  | ref MV_FG_DEVICE_INFO | stDevInfo
 | ) |  |

获取设备信息

参数
nIndex | 设备索引，从0开始
stDevInfo | 设备信息
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ OpenDevice()

int CInterface.OpenDevice | ( | uint | nIndex,
 |  | out CDevice | cDevice
 | ) |  |

通过索引下标打开设备

参数
nIndex | 设备索引，从0开始
cDevice | 设备类
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ OpenDeviceByID()

int CInterface.OpenDeviceByID | ( | String | strDeviceID,
 |  | out CDevice | cDevice
 | ) |  |

通过设备ID打开设备

参数
strDeviceID | 设备ID
cDevice | 设备类
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ CloseDevice()

int CInterface.CloseDevice ( )

关闭设备

返回
成功，返回MV_FG_SUCCESS；失败，返回错误码


类
设备控制模块

设备控制模块的接口可获取设备句柄、关闭设备等一系列设备的基本功能 更多...

类

class CDevice
设备控制模块 更多...

详细描述

设备控制模块的接口可获取设备句柄、关闭设备等一系列设备的基本功能


Public 成员函数 | 所有成员列表
CDevice类 参考
设备控制模块

设备控制模块 更多...

Public 成员函数

CDevice (IntPtr ptrDevcie)
初始化 更多...
IntPtr | GetHandle ()
获取设备句柄 更多...
int | CloseDevice ()
关闭设备 更多...
int | GetNumStreams (ref uint nNumStreams)
获取流通道数量 更多...
int | OpenStream (uint nIndex, out CStream cStream)
打开流通道 更多...

详细描述

设备控制模块

构造及析构函数说明

◆ CDevice()

CDevice.CDevice ( IntPtr ptrDevcie )

初始化

参数
ptrDevcie 设备句柄

成员函数说明

◆ GetHandle()

IntPtr CDevice.GetHandle ( )

获取设备句柄

◆ CloseDevice()

int CDevice.CloseDevice ( )

关闭设备

返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ GetNumStreams()

int CDevice.GetNumStreams ( ref uint nNumStreams )

获取流通道数量

参数
nNumStreams 流通道数量
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ OpenStream()

int CDevice.OpenStream | ( | uint | nIndex,
 |  | out CStream | cStream
 | ) |  |

打开流通道

参数
nIndex | 流通道索引
cStream | 流通道类
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码


类
流控制模块

流控制模块的接口可获取流通道图像大小、注册缓存、取消缓存等功能 更多...

类

class | CMultiBuffer
流控制模块 更多...
class | CStream
流控制模块 更多...

详细描述

流控制模块的接口可获取流通道图像大小、注册缓存、取消缓存等功能


Public 成员函数 | Public 属性 | 所有成员列表
CMultiBuffer类 参考
流控制模块

流控制模块 更多...

Public 成员函数

CMultiBuffer ()
构造函数 更多...
void | SetStreamHandle (CStream cStream)
设置流通道类句柄 更多...
int | Init ()
初始化，调用前需要给 CMultiBuffer.PayloadSize() 和 CMultiBuffer.BufferCount() 赋值 更多...
int | Announce ()
向流通道中注册缓存，需要先调用 CMultiBuffer.SetStreamHandle() 和 CMultiBuffer.Init() 更多...
int | QueueBuffer ()
将缓存句柄放回输入队列 更多...
int | Revoke ()
从流通道中撤销缓存 更多...
bool | Contains (CBuffer cBuffer)
缓存类实例是否包含在缓存链表中 更多...
Byte [] | GetByte ()
获取缓存数组 更多...

Public 属性

uint | PayloadSize
流通道的图像大小 更多...
uint | BufferCount
缓存总数 更多...

详细描述

流控制模块

构造及析构函数说明

◆ CMultiBuffer()

CMultiBuffer.CMultiBuffer ( )

构造函数

成员函数说明

◆ SetStreamHandle()

void CMultiBuffer.SetStreamHandle ( CStream cStream )

设置流通道类句柄

参数
cStream 流通道类

◆ Init()

int CMultiBuffer.Init ( )

初始化，调用前需要给 CMultiBuffer.PayloadSize() 和 CMultiBuffer.BufferCount() 赋值

返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ Announce()

int CMultiBuffer.Announce ( )

向流通道中注册缓存，需要先调用 CMultiBuffer.SetStreamHandle() 和 CMultiBuffer.Init()

返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ QueueBuffer()

int CMultiBuffer.QueueBuffer ( )

将缓存句柄放回输入队列

返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ Revoke()

int CMultiBuffer.Revoke ( )

从流通道中撤销缓存

返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ Contains()

bool CMultiBuffer.Contains ( CBuffer cBuffer )

缓存类实例是否包含在缓存链表中

参数
cBuffer 缓存类
返回
包含返回true；不包含返回false

◆ GetByte()

Byte [] CMultiBuffer.GetByte ( )

获取缓存数组

返回
缓存数组

类成员变量说明

◆ PayloadSize

uint CMultiBuffer.PayloadSize

流通道的图像大小

◆ BufferCount

uint CMultiBuffer.BufferCount

缓存总数


Public 成员函数 | 所有成员列表
CStream类 参考
流控制模块

流控制模块 更多...

Public 成员函数

delegate void | ImageDelegate (ref MV_FG_BUFFER_INFO stBufferInfo, IntPtr pUser)
图像到来事件委托类型 更多...
CStream (IntPtr streamHandle)
初始化 更多...
IntPtr | GetHandle ()
获取句柄 更多...
int | CloseStream ()
关闭流通道 更多...
int | SetBufferNum (uint nBufferNum)
设置SDK内部申请的缓存个数 更多...
int | GetFrameBuffer (ref MV_FG_BUFFER_INFO stBufferInfo, uint nTimeout)
获取图像(SDK内部申请缓存方式) 更多...
int | ReleaseFrameBuffer (MV_FG_BUFFER_INFO stBufferInfo)
释放缓存信息(SDK内部申请缓存方式) 更多...
int | GetBufferChunkData (MV_FG_BUFFER_INFO stBufferInfo, uint nIndex, ref MV_FG_CHUNK_DATA_INFO stChunkData)
获取缓存内的ChunkData信息 更多...
int | GetPayloadSize (ref uint nPayloadSize)
获取流通道的PayloadSize 更多...
int | AnnounceBuffer (IntPtr pBuffer, uint nSize, IntPtr pPrivate, out CBuffer cBuffer)
注册缓存(必须在开始取流前注册缓存) 更多...
int | RevokeBuffer (CBuffer cBuffer, ref IntPtr pBuffer, ref IntPtr pPrivate)
撤销缓存 更多...
int | FlushQueue (MV_FG_BUFFER_QUEUE_TYPE enQueueType)
刷新缓存队列 更多...
int | RegisterImageCallBack (ImageDelegate imageDelegate, IntPtr pUser)
注册图像到来事件函数(SDK内部申请缓存方式) 更多...
int | StartAcquisition ()
开始采集 更多...
int | StopAcquisition ()
停止采集 更多...
int | GetImageBuffer (out CBuffer cBuffer, uint nTimeout)
获取一帧图像（外部申请缓存注册到SDK时使用） 更多...
int | AllocAndAnnounceBuffer (uint nImageCountPerBuffer, out CMultiBuffer cMultiBuffer)
SDK内部申请缓存（每块缓存可保存多张图像，上下拼接） 更多...
int | RevokeBuffer (CMultiBuffer cMultiBuffer)
撤销缓存 更多...
int | GetImageBuffer (uint nImageCountPerBuffer, out CMultiBuffer cMultiBuffer, uint nTimeout)
获取图像（外部申请缓存注册到SDK时使用） 更多...

详细描述

流控制模块

构造及析构函数说明

◆ CStream()

CStream.CStream ( IntPtr streamHandle )

初始化

参数
streamHandle 流通道句柄

成员函数说明

◆ ImageDelegate()

delegate void CStream.ImageDelegate | ( | ref MV_FG_BUFFER_INFO | stBufferInfo,
 |  | IntPtr | pUser
 | ) |  |

图像到来事件委托类型

参数
stBufferInfo | 图像缓存信息
pUser | 用户自定义数据

◆ GetHandle()

IntPtr CStream.GetHandle ( )

获取句柄

◆ CloseStream()

int CStream.CloseStream ( )

关闭流通道

返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ SetBufferNum()

int CStream.SetBufferNum ( uint nBufferNum )

设置SDK内部申请的缓存个数

参数
nBufferNum 缓存数量
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

当未调用该接口或者nBufferNum参数设置为0时，表示SDK内部无缓存，此时需要用户申请缓存并向流通道注册缓存，否则无法开始取流。当nBufferNum参数设置大于0时，表示缓存由SDK内部进行申请，此时不允许用户向流通道注册缓存。

◆ GetFrameBuffer()

int CStream.GetFrameBuffer | ( | ref MV_FG_BUFFER_INFO | stBufferInfo,
 |  | uint | nTimeout
 | ) |  |

获取图像(SDK内部申请缓存方式)

参数
stBufferInfo | 缓存信息
nTimeout | 超时时间，以毫秒为单位
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

需要调用 CStream.ReleaseFrameBuffer() 接口进行缓存信息的释放

◆ ReleaseFrameBuffer()

int CStream.ReleaseFrameBuffer ( MV_FG_BUFFER_INFO stBufferInfo )

释放缓存信息(SDK内部申请缓存方式)

参数
stBufferInfo 缓存信息
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ GetBufferChunkData()

int CStream.GetBufferChunkData | ( | MV_FG_BUFFER_INFO | stBufferInfo,
 |  | uint | nIndex,
 |  | ref MV_FG_CHUNK_DATA_INFO | stChunkData
 | ) |  |

获取缓存内的ChunkData信息

参数
stBufferInfo | 缓存信息
nIndex | ChunkData索引
stChunkData | ChunkData信息
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

在获取到缓存信息之后，调用 CStream.ReleaseFrameBuffer() 、 CBuffer.QueueBuffer() 或 CMultiBuffer.QueueBuffer() 之前调用该接口才能得到有效信息。

◆ GetPayloadSize()

int CStream.GetPayloadSize ( ref uint nPayloadSize )

获取流通道的PayloadSize

参数
nPayloadSize 流通道的图像大小
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

修改相机图像相关参数如宽高、像素格式等参数后需要重新获取流通道的图像大小。

◆ AnnounceBuffer()

int CStream.AnnounceBuffer | ( | IntPtr | pBuffer,
 |  | uint | nSize,
 |  | IntPtr | pPrivate,
 |  | out CBuffer | cBuffer
 | ) |  |

注册缓存(必须在开始取流前注册缓存)

参数
pBuffer | 图像缓存地址
nSize | 图像缓存大小
pPrivate | 私有信息地址
cBuffer | 缓存句柄
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

图像缓存大小通过 CStream.GetPayloadSize() 接口获取；私有信息由用户自定义。

◆ RevokeBuffer() [1/2]

int CStream.RevokeBuffer | ( | CBuffer | cBuffer,
 |  | ref IntPtr | pBuffer,
 |  | ref IntPtr | pPrivate
 | ) |  |

撤销缓存

参数
cBuffer | 缓存句柄
pBuffer | 图像缓存地址
pPrivate | 私有信息地址
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

只能撤销未使用队列中的缓存，可通过 CStream.FlushQueue() 接口将缓存放到未使用队列。

◆ FlushQueue()

int CStream.FlushQueue ( MV_FG_BUFFER_QUEUE_TYPE enQueueType )

刷新缓存队列

参数
enQueueType 队列类型
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

取流过程中不支持MV_FG_BUFFER_QUEUE_INPUT_TO_OUTPUT、MV_FG_BUFFER_QUEUE_ALL_TO_INPUT、MV_FG_BUFFER_QUEUE_ALL_DISCARD。

◆ RegisterImageCallBack()

int CStream.RegisterImageCallBack | ( | ImageDelegate | imageDelegate,
 |  | IntPtr | pUser
 | ) |  |

注册图像到来事件函数(SDK内部申请缓存方式)

参数
imageDelegate | 图像到来事件委托函数
pUser | 用户自定义数据
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

在回调函数中处理耗时操作会阻塞后续帧信息获取。注册回调方式和 CStream.GetFrameBuffer() 互斥。

◆ StartAcquisition()

int CStream.StartAcquisition ( )

开始采集

返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ StopAcquisition()

int CStream.StopAcquisition ( )

停止采集

返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ GetImageBuffer() [1/2]

int CStream.GetImageBuffer | ( | out CBuffer | cBuffer,
 |  | uint | nTimeout
 | ) |  |

获取一帧图像（外部申请缓存注册到SDK时使用）

参数
cBuffer | 缓存句柄
nTimeout | 超时时间，以毫秒为单位
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

通过 CBuffer.GetBufferInfo() 接口根据缓存句柄获取图像信息。

◆ AllocAndAnnounceBuffer()

int CStream.AllocAndAnnounceBuffer | ( | uint | nImageCountPerBuffer,
 |  | out CMultiBuffer | cMultiBuffer
 | ) |  |

SDK内部申请缓存（每块缓存可保存多张图像，上下拼接）

参数
nImageCountPerBuffer | 每块缓存保存的图像个数
cMultiBuffer | 缓存类
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ RevokeBuffer() [2/2]

int CStream.RevokeBuffer ( CMultiBuffer cMultiBuffer )

撤销缓存

参数
cMultiBuffer 缓存类
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ GetImageBuffer() [2/2]

int CStream.GetImageBuffer | ( | uint | nImageCountPerBuffer,
 |  | out CMultiBuffer | cMultiBuffer,
 |  | uint | nTimeout
 | ) |  |

获取图像（外部申请缓存注册到SDK时使用）

参数
nImageCountPerBuffer | 需要获取的图像数量
cMultiBuffer | 缓存类
nTimeout | 超时时间，以毫秒为单位
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码


类
参数模块

参数模块的接口可获取和设置采集卡和相机的所有属性节点 更多...

类

class CParam
参数模块 更多...

详细描述

参数模块的接口可获取和设置采集卡和相机的所有属性节点


Public 成员函数 | 所有成员列表
CParam类 参考
参数模块

参数模块 更多...

Public 成员函数

CParam (CDevice cDevice)
初始化 更多...
CParam (CInterface cInterface)
初始化 更多...
int | GetXmlFile (ref Byte[] xmlData, UInt32 nDataSize, ref uint nDataLen)
获取XML文件 更多...
int | GetNodeAccessMode (String pstrName, ref MV_FG_NODE_ACCESS_MODE pAccessMode)
获得节点的访问模式 更多...
Int32 | GetNodeInterfaceType (String pstrName, ref MV_FG_NODE_INTERFACE_TYPE pInterfaceType)
获得节点的类型 更多...
Int32 | GetIntValue (String strValue, ref MV_FG_INTVALUE pIntValue)
获取整型节点信息 更多...
Int32 | SetIntValue (String strValue, Int64 nValue)
设置整型节点信息 更多...
Int32 | GetEnumValue (String strValue, ref MV_FG_ENUMVALUE pEnumValue)
获取枚举类型节点的信息 更多...
Int32 | SetEnumValue (String strValue, UInt32 nValue)
设置枚举类型节点的信息 更多...
Int32 | SetEnumValueByString (String strValue, String sValue)
通过字符串设置枚举类型节点的信息 更多...
Int32 | GetFloatValue (String strValue, ref MV_FG_FLOATVALUE pFloatValue)
获取单精度浮点型节点的信息 更多...
Int32 | SetFloatValue (String strValue, Single fValue)
设置单精度浮点型节点的信息 更多...
Int32 | GetBoolValue (String strValue, ref Boolean pBoolValue)
获取布尔型节点的信息 更多...
Int32 | SetBoolValue (String strValue, Boolean bValue)
设置布尔类型节点的信息 更多...
Int32 | GetStringValue (String strKey, ref MV_FG_STRINGVALUE pStringValue)
获取字符串型节点的信息 更多...
Int32 | SetStringValue (String strKey, String sValue)
设置字符串型节点的信息 更多...
Int32 | SetCommandValue (String strValue)
执行命令型节点的命令 更多...
Int32 | FeatureLoad (String strFilePath)
导入设备属性 更多...
Int32 | FeatureSave (String strFilePath)
保存设备属性 更多...

详细描述

参数模块

构造及析构函数说明

◆ CParam() [1/2]

CParam.CParam ( CDevice cDevice )

初始化

参数
cDevice 相机类

◆ CParam() [2/2]

CParam.CParam ( CInterface cInterface )

初始化

参数
cInterface 采集卡类

成员函数说明

◆ GetXmlFile()

int CParam.GetXmlFile | ( | ref Byte [] | xmlData,
 |  | UInt32 | nDataSize,
 |  | ref uint | nDataLen
 | ) |  |

获取XML文件

参数
xmlData | 存放XML文件的缓存
nDataSize | 存放XML文件的缓存大小
nDataLen | XML文件长度
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ GetNodeAccessMode()

int CParam.GetNodeAccessMode | ( | String | pstrName,
 |  | ref MV_FG_NODE_ACCESS_MODE | pAccessMode
 | ) |  |

获得节点的访问模式

参数
pstrName | 节点名称
pAccessMode | 节点访问模式
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

获取EnumEntry类型节点的访问模式，strName应传入EnumEntry_NodeName_EnumEntryName。如获取PixelFormat枚举类型下的EnumEntry节点Mono8，strName格式为“EnumEntry_PixelFormat_Mono8”。

◆ GetNodeInterfaceType()

Int32 CParam.GetNodeInterfaceType | ( | String | pstrName,
 |  | ref MV_FG_NODE_INTERFACE_TYPE | pInterfaceType
 | ) |  |

获得节点的类型

参数
pstrName | 节点名称
pInterfaceType | 节点类型
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ GetIntValue()

Int32 CParam.GetIntValue | ( | String | strValue,
 |  | ref MV_FG_INTVALUE | pIntValue
 | ) |  |

获取整型节点信息

参数
strValue | 节点名称
pIntValue | 整型节点信息
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ SetIntValue()

Int32 CParam.SetIntValue | ( | String | strValue,
 |  | Int64 | nValue
 | ) |  |

设置整型节点信息

参数
strValue | 节点名称
nValue | 要设置的值
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ GetEnumValue()

Int32 CParam.GetEnumValue | ( | String | strValue,
 |  | ref MV_FG_ENUMVALUE | pEnumValue
 | ) |  |

获取枚举类型节点的信息

参数
strValue | 节点名称
pEnumValue | 枚举类型节点信息
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ SetEnumValue()

Int32 CParam.SetEnumValue | ( | String | strValue,
 |  | UInt32 | nValue
 | ) |  |

设置枚举类型节点的信息

参数
strValue | 节点名称
nValue | 要设置的值
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ SetEnumValueByString()

Int32 CParam.SetEnumValueByString | ( | String | strValue,
 |  | String | sValue
 | ) |  |

通过字符串设置枚举类型节点的信息

参数
strValue | 节点名称
sValue | 要设置的值
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ GetFloatValue()

Int32 CParam.GetFloatValue | ( | String | strValue,
 |  | ref MV_FG_FLOATVALUE | pFloatValue
 | ) |  |

获取单精度浮点型节点的信息

参数
strValue | 节点名称
pFloatValue | 单精度浮点型节点信息
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ SetFloatValue()

Int32 CParam.SetFloatValue | ( | String | strValue,
 |  | Single | fValue
 | ) |  |

设置单精度浮点型节点的信息

参数
strValue | 节点名称
fValue | 设备信息
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ GetBoolValue()

Int32 CParam.GetBoolValue | ( | String | strValue,
 |  | ref Boolean | pBoolValue
 | ) |  |

获取布尔型节点的信息

参数
strValue | 节点名称
pBoolValue | 布尔型节点信息
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ SetBoolValue()

Int32 CParam.SetBoolValue | ( | String | strValue,
 |  | Boolean | bValue
 | ) |  |

设置布尔类型节点的信息

参数
strValue | 节点名称
bValue | 要设置的值
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ GetStringValue()

Int32 CParam.GetStringValue | ( | String | strKey,
 |  | ref MV_FG_STRINGVALUE | pStringValue
 | ) |  |

获取字符串型节点的信息

参数
strKey | 节点名称
pStringValue | 字符串型节点信息
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ SetStringValue()

Int32 CParam.SetStringValue | ( | String | strKey,
 |  | String | sValue
 | ) |  |

设置字符串型节点的信息

参数
strKey | 节点名称
sValue | 要设置的值
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ SetCommandValue()

Int32 CParam.SetCommandValue ( String strValue )

执行命令型节点的命令

参数
strValue 节点名称
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ FeatureLoad()

Int32 CParam.FeatureLoad ( String strFilePath )

导入设备属性

参数
strFilePath 属性文件名，不支持中文路径
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ FeatureSave()

Int32 CParam.FeatureSave ( String strFilePath )

保存设备属性

参数
strFilePath 属性文件名，不支持中文路径
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码


类
图像处理模块

图像处理模块的接口可将采集到的的图像进行多样的图像处理操作 更多...

类

class CImageProcess
图像处理模块 更多...

详细描述

图像处理模块的接口可将采集到的的图像进行多样的图像处理操作


Public 成员函数 | 所有成员列表
CImageProcess类 参考
图像处理模块

图像处理模块 更多...

Public 成员函数

CImageProcess (CDevice cDevice)
初始化 更多...
CImageProcess (CInterface cInterface)
初始化 更多...
CImageProcess (CStream cStream)
初始化 更多...
int | DisplayOneFrame (IntPtr hWnd, ref MV_FG_INPUT_IMAGE_INFO stFrameInfo)
显示一帧图像 更多...
int | SaveBitmap (ref MV_FG_SAVE_BITMAP_INFO stSaveBitmapInfo)
保存BMP图像 更多...
int | SaveJpeg (ref MV_FG_SAVE_JPEG_INFO stSaveJpegInfo)
保存JPG图像 更多...
int | SaveTiffToFile (ref MV_FG_SAVE_TIFF_TO_FILE_INFO stSaveTiffInfo)
保存TIFF图像 更多...
int | SavePngToFile (ref MV_FG_SAVE_PNG_TO_FILE_INFO stSavePngInfo)
保存PNG图像 更多...
int | ConvertPixelType (ref MV_FG_CONVERT_PIXEL_INFO stConvertPixelInfo)
格式转换 更多...
int | ReconstructImage (ref MV_FG_RECONSTRUCT_INFO stReconstructInfo)
重组图像 更多...
int | HB_Decode (ref MV_FG_HB_DECODE_PARAM stDecodeParam)
无损解码 更多...

详细描述

图像处理模块

构造及析构函数说明

◆ CImageProcess() [1/3]

CImageProcess.CImageProcess ( CDevice cDevice )

初始化

参数
cDevice 相机类

◆ CImageProcess() [2/3]

CImageProcess.CImageProcess ( CInterface cInterface )

初始化

参数
cInterface 采集卡类

◆ CImageProcess() [3/3]

CImageProcess.CImageProcess ( CStream cStream )

初始化

参数
cStream 流通道类

成员函数说明

◆ DisplayOneFrame()

int CImageProcess.DisplayOneFrame | ( | IntPtr | hWnd,
 |  | ref MV_FG_INPUT_IMAGE_INFO | stFrameInfo
 | ) |  |

显示一帧图像

参数
hWnd | 窗口句柄
stFrameInfo | 显示的图像信息
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ SaveBitmap()

int CImageProcess.SaveBitmap ( ref MV_FG_SAVE_BITMAP_INFO stSaveBitmapInfo )

保存BMP图像

参数
stSaveBitmapInfo BMP图像信息
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ SaveJpeg()

int CImageProcess.SaveJpeg ( ref MV_FG_SAVE_JPEG_INFO stSaveJpegInfo )

保存JPG图像

参数
stSaveJpegInfo JPG图像信息
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ SaveTiffToFile()

int CImageProcess.SaveTiffToFile ( ref MV_FG_SAVE_TIFF_TO_FILE_INFO stSaveTiffInfo )

保存TIFF图像

参数
stSaveTiffInfo TIFF图像信息
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ SavePngToFile()

int CImageProcess.SavePngToFile ( ref MV_FG_SAVE_PNG_TO_FILE_INFO stSavePngInfo )

保存PNG图像

参数
stSavePngInfo PNG图像信息
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ ConvertPixelType()

int CImageProcess.ConvertPixelType ( ref MV_FG_CONVERT_PIXEL_INFO stConvertPixelInfo )

格式转换

参数
stConvertPixelInfo 像素格式转换信息
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ ReconstructImage()

int CImageProcess.ReconstructImage ( ref MV_FG_RECONSTRUCT_INFO stReconstructInfo )

重组图像

参数
stReconstructInfo 重组信息
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ HB_Decode()

int CImageProcess.HB_Decode ( ref MV_FG_HB_DECODE_PARAM stDecodeParam )

无损解码

参数
stDecodeParam 无损解码参数
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码


类
缓存模块

缓存模块接口可通过缓存句柄获取缓存的数据信息 更多...

类

class CBuffer
缓存模块 更多...

详细描述

缓存模块接口可通过缓存句柄获取缓存的数据信息


Public 成员函数 | 所有成员列表
CBuffer类 参考
缓存模块

缓存模块 更多...

Public 成员函数

CBuffer (IntPtr bufferHandle)
初始化 更多...
IntPtr | GetHandle ()
获取缓存句柄 更多...
void | Rlease ()
释放缓存句柄 更多...
int | GetBufferInfo (ref MV_FG_BUFFER_INFO stBufferInfo)
通过缓存句柄获取缓存信息 更多...
int | QueueBuffer ()
将缓存句柄放回输入队列 更多...

详细描述

缓存模块

构造及析构函数说明

◆ CBuffer()

CBuffer.CBuffer ( IntPtr bufferHandle )

初始化

参数
bufferHandle 缓存句柄

成员函数说明

◆ GetHandle()

IntPtr CBuffer.GetHandle ( )

获取缓存句柄

◆ Rlease()

void CBuffer.Rlease ( )

释放缓存句柄

◆ GetBufferInfo()

int CBuffer.GetBufferInfo ( ref MV_FG_BUFFER_INFO stBufferInfo )

通过缓存句柄获取缓存信息

参数
stBufferInfo 缓存信息
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ QueueBuffer()

int CBuffer.QueueBuffer ( )

将缓存句柄放回输入队列

返回
成功，返回MV_FG_SUCCESS；失败，返回错误码


类
附加模块

附加模块的接口可将byte数组转换为特定类型结构体 更多...

类

class CAdditional
附加模块 更多...

详细描述

附加模块的接口可将byte数组转换为特定类型结构体


静态 Public 成员函数 | 所有成员列表
CAdditional类 参考
附加模块

附加模块 更多...

静态 Public 成员函数

static object ByteToStruct (Byte[] bytes, Type type)
byte数组转为指定类型的结构 更多...

详细描述

附加模块

成员函数说明

◆ ByteToStruct()

static object CAdditional.ByteToStruct | ( | Byte [] | bytes,
 |  | Type | type
 | ) |  |
static

byte数组转为指定类型的结构

参数
bytes | Byte数组
type | 结构类型
返回
结构类型对象


类
回调模块

回调模块的接口可获取注册事件等多种数据信息 更多...

类

class CCallback
回调模块 更多...

详细描述

回调模块的接口可获取注册事件等多种数据信息


Public 成员函数 | 所有成员列表
CCallback类 参考
回调模块

回调模块 更多...

Public 成员函数

delegate void | EventDelegate (ref MV_FG_EVENT_INFO stBufferInfo, IntPtr pUser)
delegate void | ExceptionDelegate (MV_FG_EXCEPTION_TYPE enExceptionType, IntPtr pUser)
异常委托 更多...
CCallback (CInterface cInterface)
初始化 更多...
CCallback (CDevice cDevice)
初始化 更多...
CCallback (CStream cStream)
初始化 更多...
int | RegisterEventCallBack (String strEventName, EventDelegate eventDelegate, IntPtr pUser)
注册事件回调函数 更多...
int | RegisterExceptionCallBack (ExceptionDelegate exceptionDelegate, IntPtr pUser)
注册异常信息回调函数 更多...

详细描述

回调模块

构造及析构函数说明

◆ CCallback() [1/3]

CCallback.CCallback ( CInterface cInterface )

初始化

参数
cInterface 采集卡类

◆ CCallback() [2/3]

CCallback.CCallback ( CDevice cDevice )

初始化

参数
cDevice 相机类

◆ CCallback() [3/3]

CCallback.CCallback ( CStream cStream )

初始化

参数
cStream 流类

成员函数说明

◆ EventDelegate()

delegate void CCallback.EventDelegate | ( | ref MV_FG_EVENT_INFO | stBufferInfo,
 |  | IntPtr | pUser
 | ) |  |

事件委托

参数
stBufferInfo | 图像缓存信息
pUser | 用户自定义数据

◆ ExceptionDelegate()

delegate void CCallback.ExceptionDelegate | ( | MV_FG_EXCEPTION_TYPE | enExceptionType,
 |  | IntPtr | pUser
 | ) |  |

异常委托

参数
enExceptionType | 异常类型
pUser | 用户自定义数据

◆ RegisterEventCallBack()

int CCallback.RegisterEventCallBack | ( | String | strEventName,
 |  | EventDelegate | eventDelegate,
 |  | IntPtr | pUser
 | ) |  |

注册事件回调函数

参数
strEventName | 事件名称
eventDelegate | 事件委托函数
pUser | 用户自定义数据
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ RegisterExceptionCallBack()

int CCallback.RegisterExceptionCallBack | ( | ExceptionDelegate | exceptionDelegate,
 |  | IntPtr | pUser
 | ) |  |

注册异常信息回调函数

参数
exceptionDelegate | 异常委托函数
pUser | 用户自定义数据
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码


  • 获取Chunk数据
  • 像素格式转换
  • 主动取图
  • 回调取图
  • 获取采集卡事件
示例程序
  • 获取Chunk数据
  • 像素格式转换
  • 主动取图
  • 回调取图
  • 获取采集卡事件


获取Chunk数据

该示例程序展示如何打开ChunkData功能、如何配置ChunkData以及如何获取这些ChunkData信息。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MvFGCtrlC.NET;
using System.Runtime.InteropServices;
using System.IO;
namespace ChunkData
{
class ChunkData
{
static uint CHUNK_ID_TIMESTAMP_LITTLE = unchecked(0xa5a50101); // ch:时间戳 | en:Timestamp
static uint CHUNK_ID_EXPOSURE_LITTLE = unchecked(0xa5a50103); // ch:曝光 | en:Exposure
// ch:帧信息回调函数 | en:Frame info callback
static void ImageCallbackFunc(ref MV_FG_BUFFER_INFO stBufferInfo, IntPtr pUser)
{
if (null != stBufferInfo.pBuffer)
{
Console.WriteLine("FrameNumber: " + stBufferInfo.nFrameID.ToString() + ", Width: " +
stBufferInfo.nWidth.ToString() + ", Height: " + stBufferInfo.nHeight.ToString());
int nRet = 0;
GCHandle handle = GCHandle.FromIntPtr(pUser);
CStream cStreamTemp = handle.Target as CStream;
uint nChunkNum = stBufferInfo.nNumChunks; // Chunk个数
MV_FG_CHUNK_DATA_INFO stChunkDataInfo = new MV_FG_CHUNK_DATA_INFO(); // Chunk信息
// ch:打印chunk信息 | en:Print chunk info
Console.WriteLine("********************");
for (uint i = 0; i < nChunkNum; i++)
{
nRet = cStreamTemp.GetBufferChunkData(stBufferInfo, i, ref stChunkDataInfo);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Get chunk data failed:{0:x8}", nRet);
Console.WriteLine("********************");
break;
}
if (CHUNK_ID_TIMESTAMP_LITTLE == stChunkDataInfo.nChunkID)
{
UInt32 nTimeStamp = Convert.ToUInt32(Marshal.ReadInt32(stChunkDataInfo.pChunkData));
Console.WriteLine("Chunk ID[{0:x8}], Chunk length[{1}], Chunk data[{2}]",
stChunkDataInfo.nChunkID, stChunkDataInfo.nChunkLen, nTimeStamp);
}
else if (CHUNK_ID_EXPOSURE_LITTLE == stChunkDataInfo.nChunkID)
{
float fExposure = Convert.ToSingle(Marshal.ReadInt32(stChunkDataInfo.pChunkData));
Console.WriteLine("Chunk ID[{0:x8}], Chunk length[{1}], Chunk data[{2:f}]",
stChunkDataInfo.nChunkID, stChunkDataInfo.nChunkLen, fExposure);
}
}
Console.WriteLine("********************");
}
}
static void Main(string[] args)
{
int nRet = CErrorCode.MV_FG_SUCCESS;
CSystem cSystem = new CSystem(); // ch:操作采集卡 | en:Interface operations
CInterface cInterface = null; // ch:操作采集卡和设备 | en:Interface and device operation
CDevice cDevice = null; // ch:操作设备和流 | en:Device and stream operation
CStream cStream = null; // ch:操作流和缓存 | en:Stream and buffer operation
do
{
// ch:枚举采集卡 | en:Enum interface
bool bChanged = false;
nRet = cSystem.UpdateInterfaceList(
CParamDefine.MV_FG_CAMERALINK_INTERFACE | CParamDefine.MV_FG_GEV_INTERFACE | CParamDefine.MV_FG_CXP_INTERFACE,
ref bChanged);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Enum interface failed:{0:x8}", nRet);
break;
}
// ch:获取采集卡数量 | en:Get interface num
uint nInterfaceNum = 0; // ch:采集卡数量 | en:Interface number
nRet = cSystem.GetNumInterfaces(ref nInterfaceNum);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Get interface number failed:{0:x8}", nRet);
break;
}
if (0 == nInterfaceNum)
{
Console.WriteLine("No interface found");
break;
}
// ch:显示采集卡信息 | en:Show interface info
MV_FG_INTERFACE_INFO stIfInfo = new MV_FG_INTERFACE_INFO();
for (uint i = 0; i < nInterfaceNum; i++)
{
// ch:获取采集卡信息 | en:Get interface info
nRet = cSystem.GetInterfaceInfo(i, ref stIfInfo);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Get interface info failed:{0:x8}", nRet);
break;
}
if (CParamDefine.MV_FG_GEV_INTERFACE == stIfInfo.nTLayerType)
{
// Byte数组转换为结构体
MV_GEV_INTERFACE_INFO stGevIFInfo = (MV_GEV_INTERFACE_INFO)CAdditional.ByteToStruct(
stIfInfo.SpecialInfo.stGevIfInfo, typeof(MV_GEV_INTERFACE_INFO));
Console.WriteLine("[GEV]No." + i.ToString() + " Interface:");
Console.WriteLine("\tDisplayName: " + stGevIFInfo.chDisplayName);
Console.WriteLine("\tInterfaceID: " + stGevIFInfo.chInterfaceID);
Console.WriteLine("\tSerialNumber: " + stGevIFInfo.chSerialNumber);
}
else if (CParamDefine.MV_FG_CXP_INTERFACE == stIfInfo.nTLayerType)
{
// Byte数组转换为结构体
MV_CXP_INTERFACE_INFO stCxpIFInfo = (MV_CXP_INTERFACE_INFO)CAdditional.ByteToStruct(
stIfInfo.SpecialInfo.stCXPIfInfo, typeof(MV_CXP_INTERFACE_INFO));
Console.WriteLine("[CXP]No." + i.ToString() + " Interface:");
Console.WriteLine("\tDisplayName: " + stCxpIFInfo.chDisplayName);
Console.WriteLine("\tInterfaceID: " + stCxpIFInfo.chInterfaceID);
Console.WriteLine("\tSerialNumber: " + stCxpIFInfo.chSerialNumber);
}
else if (CParamDefine.MV_FG_CAMERALINK_INTERFACE == stIfInfo.nTLayerType)
{
// Byte数组转换为结构体
MV_CML_INTERFACE_INFO stCmlIFInfo = (MV_CML_INTERFACE_INFO)CAdditional.ByteToStruct(
stIfInfo.SpecialInfo.stCMLIfInfo, typeof(MV_CML_INTERFACE_INFO));
Console.WriteLine("[CML]No." + i.ToString() + " Interface:");
Console.WriteLine("\tDisplayName: " + stCmlIFInfo.chDisplayName);
Console.WriteLine("\tInterfaceID: " + stCmlIFInfo.chInterfaceID);
Console.WriteLine("\tSerialNumber: " + stCmlIFInfo.chSerialNumber);
}
else
{
Console.WriteLine("Unknown interface type.");
nRet = CErrorCode.MV_FG_ERR_INVALID_VALUE;
break;
}
}
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
break;
}
// ch:选择采集卡 | en:Select interface
int nInterfaceIndex = -1;
Console.Write("Please input index(0-{0:d}):", nInterfaceNum - 1);
try
{
nInterfaceIndex = Convert.ToInt32(Console.ReadLine());
}
catch
{
Console.WriteLine("Invalid Index!");
break;
}
if (nInterfaceIndex < 0 || nInterfaceIndex >= nInterfaceNum)
{
Console.WriteLine("Error Index!");
break;
}
// ch:打开采集卡，获得采集卡句柄 | en:Open interface, get handle
nRet = cSystem.OpenInterface((uint)nInterfaceIndex, out cInterface);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Open Interface failed:{0:x8}", nRet);
break;
}
// ch:枚举采集卡上的相机 | en:Enum camera of interface
nRet = cInterface.UpdateDeviceList(ref bChanged);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Enum device failed:{0:x8}", nRet);
break;
}
// ch:获取设备数量 | en:Get device number
uint nDeviceNum = 0; // ch:设备数量 | en:Device number
nRet = cInterface.GetNumDevices(ref nDeviceNum);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Get device number failed:{0:x8}", nRet);
break;
}
if (0 == nDeviceNum)
{
Console.WriteLine("No device found");
break;
}
// ch:显示设备信息 | en:Show device info
MV_FG_DEVICE_INFO stDeviceInfo = new MV_FG_DEVICE_INFO();
for (uint i = 0; i < nDeviceNum; i++)
{
// ch:获取设备信息 | en:Get device info
nRet = cInterface.GetDeviceInfo(i, ref stDeviceInfo);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Get device info failed:{0:x8}", nRet);
break;
}
if (CParamDefine.MV_FG_GEV_DEVICE == stDeviceInfo.nDevType)
{
// Byte数组转换为结构体
MV_GEV_DEVICE_INFO stGevDevInfo = (MV_GEV_DEVICE_INFO)CAdditional.ByteToStruct(
stDeviceInfo.DevInfo.stGEVDevInfo, typeof(MV_GEV_DEVICE_INFO));
Console.WriteLine("[GEV]No." + i.ToString() + " Device:");
Console.WriteLine("\tUserDefinedName: " + stGevDevInfo.chUserDefinedName);
Console.WriteLine("\tModelName: " + stGevDevInfo.chModelName);
Console.WriteLine("\tSerialNumber: " + stGevDevInfo.chSerialNumber);
}
else if (CParamDefine.MV_FG_CXP_DEVICE == stDeviceInfo.nDevType)
{
// Byte数组转换为结构体
MV_CXP_DEVICE_INFO stCxpDevInfo = (MV_CXP_DEVICE_INFO)CAdditional.ByteToStruct(
stDeviceInfo.DevInfo.stCXPDevInfo, typeof(MV_CXP_DEVICE_INFO));
Console.WriteLine("[CXP]No." + i.ToString() + " Device:");
Console.WriteLine("\tUserDefinedName: " + stCxpDevInfo.chUserDefinedName);
Console.WriteLine("\tModelName: " + stCxpDevInfo.chModelName);
Console.WriteLine("\tSerialNumber: " + stCxpDevInfo.chSerialNumber);
}
else if (CParamDefine.MV_FG_CAMERALINK_DEVICE == stDeviceInfo.nDevType)
{
// Byte数组转换为结构体
MV_CML_DEVICE_INFO stCmlDevInfo = (MV_CML_DEVICE_INFO)CAdditional.ByteToStruct(
stDeviceInfo.DevInfo.stCMLDevInfo, typeof(MV_CML_DEVICE_INFO));
Console.WriteLine("[CML]No." + i.ToString() + " Device:");
Console.WriteLine("\tUserDefinedName: " + stCmlDevInfo.chUserDefinedName);
Console.WriteLine("\tModelName: " + stCmlDevInfo.chModelName);
Console.WriteLine("\tSerialNumber: " + stCmlDevInfo.chSerialNumber);
}
else
{
Console.WriteLine("Unknown device type.");
nRet = CErrorCode.MV_FG_ERR_INVALID_VALUE;
break;
}
}
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
break;
}
// ch:选择设备 | en:Select device
int nDeviceIndex = -1;
Console.Write("Please input index(0-{0:d}):", nDeviceNum - 1);
try
{
nDeviceIndex = Convert.ToInt32(Console.ReadLine());
}
catch
{
Console.WriteLine("Invalid Index!");
break;
}
if (nDeviceIndex < 0 || nDeviceIndex >= nDeviceNum)
{
Console.WriteLine("Error Index!");
break;
}
// ch:打开设备，获得设备句柄 | en:Open device, get handle
nRet = cInterface.OpenDevice((uint)nDeviceIndex, out cDevice);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Open device failed:{0:x8}", nRet);
break;
}
CParam cDeviceParam = new CParam(cDevice); // ch:操作采集卡或设备参数配置 | en:Interface or device config operation
// ch:开启Chunk Mode | en:Open Chunk Mode
nRet = cDeviceParam.SetBoolValue("ChunkModeActive", true);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Set chunk mode failed:{0:x8}", nRet);
break;
}
// ch:Chunk Selector设为Exposure | en: Chunk Selector set as Exposure
nRet = cDeviceParam.SetEnumValueByString("ChunkSelector", "Exposure");
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Set exposure chunk failed:{0:x8}", nRet);
break;
}
// ch:开启Chunk Enable | en:Open Chunk Enable
nRet = cDeviceParam.SetBoolValue("ChunkEnable", true);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Set exposure chunk enable failed:{0:x8}", nRet);
break;
}
// ch:Chunk Selector设为Timestamp | en: Chunk Selector set as Timestamp
nRet = cDeviceParam.SetEnumValueByString("ChunkSelector", "Timestamp");
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Set timestamp chunk failed:{0:x8}", nRet);
break;
}
// ch:开启Chunk Enable | en:Open Chunk Enable
nRet = cDeviceParam.SetBoolValue("ChunkEnable", true);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Set timestamp chunk enable failed:{0:x8}", nRet);
break;
}
// ch:关闭触发模式 | en:Close trigger mode
nRet = cDeviceParam.SetEnumValueByString("TriggerMode", "Off");
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Turn off trigger mode failed:{0:x8}", nRet);
break;
}
// ch:获取流通道个数 | en:Get number of stream
uint nStreamNum = 0;
nRet = cDevice.GetNumStreams(ref nStreamNum);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Get stream number failed:{0:x8}", nRet);
break;
}
if (0 == nStreamNum)
{
Console.WriteLine("No stream available");
break;
}
// ch:打开流通道(目前只支持单个通道) | en:Open stream(Only a single stream is supported now)
nRet = cDevice.OpenStream(0, out cStream);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Open stream failed:{0:x8}", nRet);
break;
}
// ch:设置SDK内部缓存数量 | en:Set internal buffer number
const uint nBufNum = 3;
nRet = cStream.SetBufferNum(nBufNum);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Set buffer number failed:{0:x8}", nRet);
break;
}
// ch:注册帧缓存信息回调函数 | en:Register frame info callback
GCHandle handle = GCHandle.Alloc(cStream);
nRet = cStream.RegisterImageCallBack(new CStream.ImageDelegate(ImageCallbackFunc), GCHandle.ToIntPtr(handle));
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Register image callback failed:{0:x8}", nRet);
break;
}
// ch:开始取流 | en:Start Acquisition
nRet = cStream.StartAcquisition();
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Start acquistion failed:{0:x8}", nRet);
break;
}
Console.WriteLine("Press enter to exit.");
Console.ReadKey();
// ch:停止取流 | en:Stop Acquisition
nRet = cStream.StopAcquisition();
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Stop acquistion failed:{0:x8}", nRet);
break;
}
} while (false);
// ch:关闭流通道 | en:Close Stream
if (null != cStream)
{
nRet = cStream.CloseStream();
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Close stream failed:{0:x8}", nRet);
}
cStream = null;
}
// ch:关闭设备 | en:Close device
if (null != cDevice)
{
nRet = cDevice.CloseDevice();
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Close device failed:{0:x8}", nRet);
}
cDevice = null;
}
// ch:关闭采集卡 | en:Close interface
if (null != cInterface)
{
nRet = cInterface.CloseInterface();
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Close interface failed:{0:x8}", nRet);
}
cInterface = null;
}
Console.WriteLine("Press enter to exit.");
Console.ReadKey();
}
}
}


像素格式转换

该示例程序通过图像转换接口将相机取图的图像格式转换为用户需要的格式。
using System;
using System.Collections.Generic;
using MvFGCtrlC.NET;
using System.Runtime.InteropServices;
using System.IO;
namespace ConvertPixelType
{
class ConvertPixelType
{
// ch:是否为Mono格式 | en:Judge whether it is Mono format
static bool IsMonoPixelFormat(MV_FG_PIXEL_TYPE enType)
{
switch (enType)
{
case MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_Mono10:
case MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_Mono10_Packed:
case MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_Mono12:
case MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_Mono12_Packed:
case MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_Mono16:
return true;
default:
return false;
}
}
// ch:是否为彩色格式 | en:Judge whether it is color format
static bool IsColorPixelFormat(MV_FG_PIXEL_TYPE enType)
{
switch (enType)
{
case MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_RGBA8_Packed:
case MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_BGRA8_Packed:
case MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_BayerGR8:
case MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_BayerRG8:
case MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_BayerGB8:
case MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_BayerBG8:
case MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_BayerGB10:
case MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_BayerGB10_Packed:
case MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_BayerBG10:
case MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_BayerBG10_Packed:
case MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_BayerRG10:
case MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_BayerRG10_Packed:
case MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_BayerGR10:
case MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_BayerGR10_Packed:
case MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_BayerGB12:
case MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_BayerGB12_Packed:
case MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_BayerBG12:
case MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_BayerBG12_Packed:
case MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_BayerRG12:
case MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_BayerRG12_Packed:
case MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_BayerGR12:
case MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_BayerGR12_Packed:
case MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_BayerGR16:
case MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_BayerRG16:
case MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_BayerGB16:
case MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_BayerBG16:
case MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_YUV422_Packed:
case MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_YUV422_YUYV_Packed:
return true;
default:
return false;
}
}
static void Main(string[] args)
{
int nRet = CErrorCode.MV_FG_SUCCESS;
CSystem cSystem = new CSystem(); // ch:操作采集卡 | en:Interface operations
CInterface cInterface = null; // ch:操作采集卡和设备 | en:Interface and device operation
CDevice cDevice = null; // ch:操作设备和流 | en:Device and stream operation
CStream cStream = null; // ch:操作流和缓存 | en:Stream and buffer operation
do
{
// ch:枚举采集卡 | en:Enum interface
bool bChanged = false;
nRet = cSystem.UpdateInterfaceList(
CParamDefine.MV_FG_CAMERALINK_INTERFACE | CParamDefine.MV_FG_GEV_INTERFACE | CParamDefine.MV_FG_CXP_INTERFACE,
ref bChanged);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Enum interface failed:{0:x8}", nRet);
break;
}
// ch:获取采集卡数量 | en:Get interface num
uint nInterfaceNum = 0; // ch:采集卡数量 | en:Interface number
nRet = cSystem.GetNumInterfaces(ref nInterfaceNum);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Get interface number failed:{0:x8}", nRet);
break;
}
if (0 == nInterfaceNum)
{
Console.WriteLine("No interface found");
break;
}
// ch:显示采集卡信息 | en:Show interface info
MV_FG_INTERFACE_INFO stIfInfo = new MV_FG_INTERFACE_INFO();
for (uint i = 0; i < nInterfaceNum; i++)
{
// ch:获取采集卡信息 | en:Get interface info
nRet = cSystem.GetInterfaceInfo(i, ref stIfInfo);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Get interface info failed:{0:x8}", nRet);
break;
}
if (CParamDefine.MV_FG_GEV_INTERFACE == stIfInfo.nTLayerType)
{
// Byte数组转换为结构体
MV_GEV_INTERFACE_INFO stGevIFInfo = (MV_GEV_INTERFACE_INFO)CAdditional.ByteToStruct(
stIfInfo.SpecialInfo.stGevIfInfo, typeof(MV_GEV_INTERFACE_INFO));
Console.WriteLine("[GEV]No." + i.ToString() + " Interface:");
Console.WriteLine("\tDisplayName: " + stGevIFInfo.chDisplayName);
Console.WriteLine("\tInterfaceID: " + stGevIFInfo.chInterfaceID);
Console.WriteLine("\tSerialNumber: " + stGevIFInfo.chSerialNumber);
}
else if (CParamDefine.MV_FG_CXP_INTERFACE == stIfInfo.nTLayerType)
{
// Byte数组转换为结构体
MV_CXP_INTERFACE_INFO stCxpIFInfo = (MV_CXP_INTERFACE_INFO)CAdditional.ByteToStruct(
stIfInfo.SpecialInfo.stCXPIfInfo, typeof(MV_CXP_INTERFACE_INFO));
Console.WriteLine("[CXP]No." + i.ToString() + " Interface:");
Console.WriteLine("\tDisplayName: " + stCxpIFInfo.chDisplayName);
Console.WriteLine("\tInterfaceID: " + stCxpIFInfo.chInterfaceID);
Console.WriteLine("\tSerialNumber: " + stCxpIFInfo.chSerialNumber);
}
else if (CParamDefine.MV_FG_CAMERALINK_INTERFACE == stIfInfo.nTLayerType)
{
// Byte数组转换为结构体
MV_CML_INTERFACE_INFO stCmlIFInfo = (MV_CML_INTERFACE_INFO)CAdditional.ByteToStruct(
stIfInfo.SpecialInfo.stCMLIfInfo, typeof(MV_CML_INTERFACE_INFO));
Console.WriteLine("[CML]No." + i.ToString() + " Interface:");
Console.WriteLine("\tDisplayName: " + stCmlIFInfo.chDisplayName);
Console.WriteLine("\tInterfaceID: " + stCmlIFInfo.chInterfaceID);
Console.WriteLine("\tSerialNumber: " + stCmlIFInfo.chSerialNumber);
}
else
{
Console.WriteLine("Unknown interface type.");
nRet = CErrorCode.MV_FG_ERR_INVALID_VALUE;
break;
}
}
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
break;
}
// ch:选择采集卡 | en:Select interface
int nInterfaceIndex = -1;
Console.Write("Please input index(0-{0:d}):", nInterfaceNum - 1);
try
{
nInterfaceIndex = Convert.ToInt32(Console.ReadLine());
}
catch
{
Console.WriteLine("Invalid Index!");
break;
}
if (nInterfaceIndex < 0 || nInterfaceIndex >= nInterfaceNum)
{
Console.WriteLine("Error Index!");
break;
}
// ch:打开采集卡，获得采集卡句柄 | en:Open interface, get handle
nRet = cSystem.OpenInterface((uint)nInterfaceIndex, out cInterface);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Open Interface failed:{0:x8}", nRet);
break;
}
// ch:枚举采集卡上的相机 | en:Enum camera of interface
nRet = cInterface.UpdateDeviceList(ref bChanged);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Enum device failed:{0:x8}", nRet);
break;
}
// ch:获取设备数量 | en:Get device number
uint nDeviceNum = 0; // ch:设备数量 | en:Device number
nRet = cInterface.GetNumDevices(ref nDeviceNum);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Get device number failed:{0:x8}", nRet);
break;
}
if (0 == nDeviceNum)
{
Console.WriteLine("No device found");
break;
}
// ch:显示设备信息 | en:Show device info
MV_FG_DEVICE_INFO stDeviceInfo = new MV_FG_DEVICE_INFO();
for (uint i = 0; i < nDeviceNum; i++)
{
// ch:获取设备信息 | en:Get device info
nRet = cInterface.GetDeviceInfo(i, ref stDeviceInfo);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Get device info failed:{0:x8}", nRet);
break;
}
if (CParamDefine.MV_FG_GEV_DEVICE == stDeviceInfo.nDevType)
{
// Byte数组转换为结构体
MV_GEV_DEVICE_INFO stGevDevInfo = (MV_GEV_DEVICE_INFO)CAdditional.ByteToStruct(
stDeviceInfo.DevInfo.stGEVDevInfo, typeof(MV_GEV_DEVICE_INFO));
Console.WriteLine("[GEV]No." + i.ToString() + " Device:");
Console.WriteLine("\tUserDefinedName: " + stGevDevInfo.chUserDefinedName);
Console.WriteLine("\tModelName: " + stGevDevInfo.chModelName);
Console.WriteLine("\tSerialNumber: " + stGevDevInfo.chSerialNumber);
}
else if (CParamDefine.MV_FG_CXP_DEVICE == stDeviceInfo.nDevType)
{
// Byte数组转换为结构体
MV_CXP_DEVICE_INFO stCxpDevInfo = (MV_CXP_DEVICE_INFO)CAdditional.ByteToStruct(
stDeviceInfo.DevInfo.stCXPDevInfo, typeof(MV_CXP_DEVICE_INFO));
Console.WriteLine("[CXP]No." + i.ToString() + " Device:");
Console.WriteLine("\tUserDefinedName: " + stCxpDevInfo.chUserDefinedName);
Console.WriteLine("\tModelName: " + stCxpDevInfo.chModelName);
Console.WriteLine("\tSerialNumber: " + stCxpDevInfo.chSerialNumber);
}
else if (CParamDefine.MV_FG_CAMERALINK_DEVICE == stDeviceInfo.nDevType)
{
// Byte数组转换为结构体
MV_CML_DEVICE_INFO stCmlDevInfo = (MV_CML_DEVICE_INFO)CAdditional.ByteToStruct(
stDeviceInfo.DevInfo.stCMLDevInfo, typeof(MV_CML_DEVICE_INFO));
Console.WriteLine("[CML]No." + i.ToString() + " Device:");
Console.WriteLine("\tUserDefinedName: " + stCmlDevInfo.chUserDefinedName);
Console.WriteLine("\tModelName: " + stCmlDevInfo.chModelName);
Console.WriteLine("\tSerialNumber: " + stCmlDevInfo.chSerialNumber);
}
else
{
Console.WriteLine("Unknown device type.");
nRet = CErrorCode.MV_FG_ERR_INVALID_VALUE;
break;
}
}
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
break;
}
// ch:选择设备 | en:Select device
int nDeviceIndex = -1;
Console.Write("Please input index(0-{0:d}):", nDeviceNum - 1);
try
{
nDeviceIndex = Convert.ToInt32(Console.ReadLine());
}
catch
{
Console.WriteLine("Invalid Index!");
break;
}
if (nDeviceIndex < 0 || nDeviceIndex >= nDeviceNum)
{
Console.WriteLine("Error Index!");
break;
}
// ch:打开设备，获得设备句柄 | en:Open device, get handle
nRet = cInterface.OpenDevice((uint)nDeviceIndex, out cDevice);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Open device failed:{0:x8}", nRet);
break;
}
CParam cDeviceParam = new CParam(cDevice); // ch:操作采集卡或设备参数配置 | en:Interface or device config operation
// ch:关闭触发模式 | en:Close trigger mode
nRet = cDeviceParam.SetEnumValueByString("TriggerMode", "Off");
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Turn off trigger mode failed:{0:x8}", nRet);
break;
}
// ch:获取流通道个数 | en:Get number of stream
uint nStreamNum = 0;
nRet = cDevice.GetNumStreams(ref nStreamNum);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Get stream number failed:{0:x8}", nRet);
break;
}
if (0 == nStreamNum)
{
Console.WriteLine("No stream available");
break;
}
// ch:打开流通道(目前只支持单个通道) | en:Open stream(Only a single stream is supported now)
nRet = cDevice.OpenStream(0, out cStream);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Open stream failed:{0:x8}", nRet);
break;
}
// ch:设置SDK内部缓存数量 | en:Set internal buffer number
const uint nBufNum = 3;
nRet = cStream.SetBufferNum(nBufNum);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Set buffer number failed:{0:x8}", nRet);
break;
}
// ch:开始取流 | en:Start Acquisition
nRet = cStream.StartAcquisition();
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Start acquistion failed:{0:x8}", nRet);
break;
}
const uint nTimeOut = 1000;
MV_FG_BUFFER_INFO stFrameInfo = new MV_FG_BUFFER_INFO();
MV_FG_CONVERT_PIXEL_INFO stConvertPixelInfo = new MV_FG_CONVERT_PIXEL_INFO();
// ch:获取一帧图像 | en:Get one frame info
nRet = cStream.GetFrameBuffer(ref stFrameInfo, nTimeOut);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Get frame buffer failed:{0:x8}", nRet);
}
else
{
Console.WriteLine("FrameNumber: " + stFrameInfo.nFrameID.ToString() +
", Width: " + stFrameInfo.nWidth.ToString() + ", Height: " + stFrameInfo.nHeight.ToString());
MV_FG_PIXEL_TYPE enDstPixelType = MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_Undefined;
uint nChannelNum = 0; // ch:像素通道数 | en:Channel number of pixel
string strFileName = "Cvt.raw";
IntPtr pDstConvertBuf = IntPtr.Zero;
// ch:彩色转成RGB8 | en:Convert color format to RGB8
if (IsColorPixelFormat(stFrameInfo.enPixelType))
{
nChannelNum = 3;
enDstPixelType = MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_RGB8_Packed;
strFileName = "Cvt2RGB_w" + stFrameInfo.nWidth + "_h" + stFrameInfo.nHeight + ".raw";
}
// ch:黑白则换成Mono8 | en:Convert gray to Mono8
else if (IsMonoPixelFormat(stFrameInfo.enPixelType))
{
nChannelNum = 1;
enDstPixelType = MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_Mono8;
strFileName = "Cvt2Mono_w" + stFrameInfo.nWidth + "_h" + stFrameInfo.nHeight + ".raw";
}
else
{
Console.WriteLine("Don't need to convert!");
}
if (MV_FG_PIXEL_TYPE.MV_FG_PIXEL_TYPE_Undefined != enDstPixelType)
{
if (IntPtr.Zero == pDstConvertBuf)
{
pDstConvertBuf = Marshal.AllocHGlobal((int)(stFrameInfo.nWidth * stFrameInfo.nHeight * nChannelNum));
}
if (IntPtr.Zero != pDstConvertBuf)
{
// 配置参数
stConvertPixelInfo.stInputImageInfo.pImageBuf = stFrameInfo.pBuffer;
stConvertPixelInfo.stInputImageInfo.nImageBufLen = stFrameInfo.nFilledSize;
stConvertPixelInfo.stInputImageInfo.nHeight = stFrameInfo.nHeight;
stConvertPixelInfo.stInputImageInfo.nWidth = stFrameInfo.nWidth;
stConvertPixelInfo.stInputImageInfo.enPixelType = stFrameInfo.enPixelType;
stConvertPixelInfo.stOutputImageInfo.enPixelType = enDstPixelType;
stConvertPixelInfo.stOutputImageInfo.pImageBuf = pDstConvertBuf;
stConvertPixelInfo.stOutputImageInfo.nImageBufSize = (uint)(stFrameInfo.nWidth * stFrameInfo.nHeight * nChannelNum);
stConvertPixelInfo.enCfaMethod = MV_FG_CFA_METHOD.MV_FG_CFA_METHOD_OPTIMAL;
// ch:像素格式转换 | en:Pixel format conversion
CImageProcess cImgProc = new CImageProcess(cStream);
nRet = cImgProc.ConvertPixelType(ref stConvertPixelInfo);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Convert pixel type failed:{0:x8}", nRet);
}
else
{
// ch:将图像数据保存到本地文件 | en:Save image data to local file
byte[] byteData = new byte[stConvertPixelInfo.stOutputImageInfo.nImageBufLen];
Marshal.Copy(stConvertPixelInfo.stOutputImageInfo.pImageBuf, byteData, 0, (int)stConvertPixelInfo.stOutputImageInfo.nImageBufLen);
FileStream pFile = null;
try
{
pFile = new FileStream(strFileName, FileMode.Create);
pFile.Write(byteData, 0, byteData.Length);
}
catch
{
Console.WriteLine("Save image failed");
}
finally
{
pFile.Close();
pFile = null;
}
}
}
else
{
Console.WriteLine("Malloc memery failed");
}
// ch:将缓存放回输入队列 | en:Put the buffer back into the input queue
nRet = cStream.ReleaseFrameBuffer(stFrameInfo);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Release frame buffer failed:{0:x8}", nRet);
}
else
{
Console.WriteLine("Convert pixel format success!");
}
}
if (IntPtr.Zero != pDstConvertBuf)
{
Marshal.FreeHGlobal(pDstConvertBuf);
}
}
// ch:停止取流 | en:Stop Acquisition
nRet = cStream.StopAcquisition();
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Stop acquistion failed:{0:x8}", nRet);
break;
}
} while (false);
// ch:关闭流通道 | en:Close Stream
if (null != cStream)
{
nRet = cStream.CloseStream();
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Close stream failed:{0:x8}", nRet);
}
cStream = null;
}
// ch:关闭设备 | en:Close device
if (null != cDevice)
{
nRet = cDevice.CloseDevice();
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Close device failed:{0:x8}", nRet);
}
cDevice = null;
}
// ch:关闭采集卡 | en:Close interface
if (null != cInterface)
{
nRet = cInterface.CloseInterface();
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Close interface failed:{0:x8}", nRet);
}
cInterface = null;
}
Console.WriteLine("Press enter to exit.");
Console.ReadKey();
}
}
}


主动取图

该示例程序说明如何通过主动取图的方式获取相机图像。打开采集卡，打开相机，打开流通道，设置内部缓存数量，创建取流线程，开始取流，停止取流，关闭流通道，关闭相机，关闭采集卡。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MvFGCtrlC.NET;
using System.Runtime.InteropServices;
using System.IO;
using System.Threading;
namespace GrabImage
{
class GrabImage
{
static bool g_bExit = false;
public static void GrabbingThread(object obj)
{
if (null != obj)
{
int nRet = 0;
const uint nTimeout = 1000;
CStream cStream = obj as CStream;
MV_FG_BUFFER_INFO stFrameInfo = new MV_FG_BUFFER_INFO(); // 图像信息
// ch:开始取流 | en:Start Acquisition
nRet = cStream.StartAcquisition();
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Start acquistion failed:{0:x8}", nRet);
return;
}
g_bExit = false;
while (!g_bExit)
{
// ch:获取一帧图像缓存信息 | en:Get one frame buffer's info
nRet = cStream.GetFrameBuffer(ref stFrameInfo, nTimeout);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Get frame buffer failed:{0:x8}", nRet);
continue;
}
else
{
Console.WriteLine("FrameNumber: " + stFrameInfo.nFrameID.ToString() +
", Width: " + stFrameInfo.nWidth.ToString() + ", Height: " + stFrameInfo.nHeight.ToString());
}
// ch:释放缓存信息 | en:Release buffer info
nRet = cStream.ReleaseFrameBuffer(stFrameInfo);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Release frame buffer failed:{0:x8}", nRet);
break;
}
}
}
}
static void Main(string[] args)
{
int nRet = CErrorCode.MV_FG_SUCCESS;
CSystem cSystem = new CSystem(); // ch:操作采集卡 | en:Interface operations
CInterface cInterface = null; // ch:操作采集卡和设备 | en:Interface and device operation
CDevice cDevice = null; // ch:操作设备和流 | en:Device and stream operation
CStream cStream = null; // ch:操作流和缓存 | en:Stream and buffer operation
do
{
// ch:枚举采集卡 | en:Enum interface
bool bChanged = false;
nRet = cSystem.UpdateInterfaceList(
CParamDefine.MV_FG_CAMERALINK_INTERFACE | CParamDefine.MV_FG_GEV_INTERFACE | CParamDefine.MV_FG_CXP_INTERFACE,
ref bChanged);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Enum interface failed:{0:x8}", nRet);
break;
}
// ch:获取采集卡数量 | en:Get interface num
uint nInterfaceNum = 0; // ch:采集卡数量 | en:Interface number
nRet = cSystem.GetNumInterfaces(ref nInterfaceNum);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Get interface number failed:{0:x8}", nRet);
break;
}
if (0 == nInterfaceNum)
{
Console.WriteLine("No interface found");
break;
}
// ch:显示采集卡信息 | en:Show interface info
MV_FG_INTERFACE_INFO stIfInfo = new MV_FG_INTERFACE_INFO();
for (uint i = 0; i < nInterfaceNum; i++)
{
// ch:获取采集卡信息 | en:Get interface info
nRet = cSystem.GetInterfaceInfo(i, ref stIfInfo);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Get interface info failed:{0:x8}", nRet);
break;
}
if (CParamDefine.MV_FG_GEV_INTERFACE == stIfInfo.nTLayerType)
{
// Byte数组转换为结构体
MV_GEV_INTERFACE_INFO stGevIFInfo = (MV_GEV_INTERFACE_INFO)CAdditional.ByteToStruct(
stIfInfo.SpecialInfo.stGevIfInfo, typeof(MV_GEV_INTERFACE_INFO));
Console.WriteLine("[GEV]No." + i.ToString() + " Interface:");
Console.WriteLine("\tDisplayName: " + stGevIFInfo.chDisplayName);
Console.WriteLine("\tInterfaceID: " + stGevIFInfo.chInterfaceID);
Console.WriteLine("\tSerialNumber: " + stGevIFInfo.chSerialNumber);
}
else if (CParamDefine.MV_FG_CXP_INTERFACE == stIfInfo.nTLayerType)
{
// Byte数组转换为结构体
MV_CXP_INTERFACE_INFO stCxpIFInfo = (MV_CXP_INTERFACE_INFO)CAdditional.ByteToStruct(
stIfInfo.SpecialInfo.stCXPIfInfo, typeof(MV_CXP_INTERFACE_INFO));
Console.WriteLine("[CXP]No." + i.ToString() + " Interface:");
Console.WriteLine("\tDisplayName: " + stCxpIFInfo.chDisplayName);
Console.WriteLine("\tInterfaceID: " + stCxpIFInfo.chInterfaceID);
Console.WriteLine("\tSerialNumber: " + stCxpIFInfo.chSerialNumber);
}
else if (CParamDefine.MV_FG_CAMERALINK_INTERFACE == stIfInfo.nTLayerType)
{
// Byte数组转换为结构体
MV_CML_INTERFACE_INFO stCmlIFInfo = (MV_CML_INTERFACE_INFO)CAdditional.ByteToStruct(
stIfInfo.SpecialInfo.stCMLIfInfo, typeof(MV_CML_INTERFACE_INFO));
Console.WriteLine("[CML]No." + i.ToString() + " Interface:");
Console.WriteLine("\tDisplayName: " + stCmlIFInfo.chDisplayName);
Console.WriteLine("\tInterfaceID: " + stCmlIFInfo.chInterfaceID);
Console.WriteLine("\tSerialNumber: " + stCmlIFInfo.chSerialNumber);
}
else
{
Console.WriteLine("Unknown interface type.");
nRet = CErrorCode.MV_FG_ERR_INVALID_VALUE;
break;
}
}
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
break;
}
// ch:选择采集卡 | en:Select interface
int nInterfaceIndex = -1;
Console.Write("Please input index(0-{0:d}):", nInterfaceNum - 1);
try
{
nInterfaceIndex = Convert.ToInt32(Console.ReadLine());
}
catch
{
Console.WriteLine("Invalid Index!");
break;
}
if (nInterfaceIndex < 0 || nInterfaceIndex >= nInterfaceNum)
{
Console.WriteLine("Error Index!");
break;
}
// ch:打开采集卡，获得采集卡句柄 | en:Open interface, get handle
nRet = cSystem.OpenInterface((uint)nInterfaceIndex, out cInterface);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Open Interface failed:{0:x8}", nRet);
break;
}
// ch:枚举采集卡上的相机 | en:Enum camera of interface
nRet = cInterface.UpdateDeviceList(ref bChanged);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Enum device failed:{0:x8}", nRet);
break;
}
// ch:获取设备数量 | en:Get device number
uint nDeviceNum = 0; // ch:设备数量 | en:Device number
nRet = cInterface.GetNumDevices(ref nDeviceNum);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Get device number failed:{0:x8}", nRet);
break;
}
if (0 == nDeviceNum)
{
Console.WriteLine("No device found");
break;
}
// ch:显示设备信息 | en:Show device info
MV_FG_DEVICE_INFO stDeviceInfo = new MV_FG_DEVICE_INFO();
for (uint i = 0; i < nDeviceNum; i++)
{
// ch:获取设备信息 | en:Get device info
nRet = cInterface.GetDeviceInfo(i, ref stDeviceInfo);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Get device info failed:{0:x8}", nRet);
break;
}
if (CParamDefine.MV_FG_GEV_DEVICE == stDeviceInfo.nDevType)
{
// Byte数组转换为结构体
MV_GEV_DEVICE_INFO stGevDevInfo = (MV_GEV_DEVICE_INFO)CAdditional.ByteToStruct(
stDeviceInfo.DevInfo.stGEVDevInfo, typeof(MV_GEV_DEVICE_INFO));
Console.WriteLine("[GEV]No." + i.ToString() + " Device:");
Console.WriteLine("\tUserDefinedName: " + stGevDevInfo.chUserDefinedName);
Console.WriteLine("\tModelName: " + stGevDevInfo.chModelName);
Console.WriteLine("\tSerialNumber: " + stGevDevInfo.chSerialNumber);
}
else if (CParamDefine.MV_FG_CXP_DEVICE == stDeviceInfo.nDevType)
{
// Byte数组转换为结构体
MV_CXP_DEVICE_INFO stCxpDevInfo = (MV_CXP_DEVICE_INFO)CAdditional.ByteToStruct(
stDeviceInfo.DevInfo.stCXPDevInfo, typeof(MV_CXP_DEVICE_INFO));
Console.WriteLine("[CXP]No." + i.ToString() + " Device:");
Console.WriteLine("\tUserDefinedName: " + stCxpDevInfo.chUserDefinedName);
Console.WriteLine("\tModelName: " + stCxpDevInfo.chModelName);
Console.WriteLine("\tSerialNumber: " + stCxpDevInfo.chSerialNumber);
}
else if (CParamDefine.MV_FG_CAMERALINK_DEVICE == stDeviceInfo.nDevType)
{
// Byte数组转换为结构体
MV_CML_DEVICE_INFO stCmlDevInfo = (MV_CML_DEVICE_INFO)CAdditional.ByteToStruct(
stDeviceInfo.DevInfo.stCMLDevInfo, typeof(MV_CML_DEVICE_INFO));
Console.WriteLine("[CML]No." + i.ToString() + " Device:");
Console.WriteLine("\tUserDefinedName: " + stCmlDevInfo.chUserDefinedName);
Console.WriteLine("\tModelName: " + stCmlDevInfo.chModelName);
Console.WriteLine("\tSerialNumber: " + stCmlDevInfo.chSerialNumber);
}
else
{
Console.WriteLine("Unknown device type.");
nRet = CErrorCode.MV_FG_ERR_INVALID_VALUE;
break;
}
}
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
break;
}
// ch:选择设备 | en:Select device
int nDeviceIndex = -1;
Console.Write("Please input index(0-{0:d}):", nDeviceNum - 1);
try
{
nDeviceIndex = Convert.ToInt32(Console.ReadLine());
}
catch
{
Console.WriteLine("Invalid Index!");
break;
}
if (nDeviceIndex < 0 || nDeviceIndex >= nDeviceNum)
{
Console.WriteLine("Error Index!");
break;
}
// ch:打开设备，获得设备句柄 | en:Open device, get handle
nRet = cInterface.OpenDevice((uint)nDeviceIndex, out cDevice);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Open device failed:{0:x8}", nRet);
break;
}
CParam cDeviceParam = new CParam(cDevice); // ch:操作采集卡或设备参数配置 | en:Interface or device config operation
// ch:关闭触发模式 | en:Close trigger mode
nRet = cDeviceParam.SetEnumValueByString("TriggerMode", "Off");
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Turn off trigger mode failed:{0:x8}", nRet);
break;
}
// ch:获取流通道个数 | en:Get number of stream
uint nStreamNum = 0;
nRet = cDevice.GetNumStreams(ref nStreamNum);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Get stream number failed:{0:x8}", nRet);
break;
}
if (0 == nStreamNum)
{
Console.WriteLine("No stream available");
break;
}
// ch:打开流通道(目前只支持单个通道) | en:Open stream(Only a single stream is supported now)
nRet = cDevice.OpenStream(0, out cStream);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Open stream failed:{0:x8}", nRet);
break;
}
// ch:设置SDK内部缓存数量 | en:Set internal buffer number
const uint nBufNum = 3;
nRet = cStream.SetBufferNum(nBufNum);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Set buffer number failed:{0:x8}", nRet);
break;
}
// ch:创建取流线程 | en:Create acquistion thread
Thread hGrabThread = new Thread(GrabbingThread);
if (null == hGrabThread)
{
Console.WriteLine("Create thread failed");
break;
}
hGrabThread.Start(cStream);
Console.WriteLine("Press enter to exit.");
Console.ReadKey();
g_bExit = true;
Thread.Sleep(1000); // 确保线程正常结束
// ch:停止取流 | en:Stop Acquisition
nRet = cStream.StopAcquisition();
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Stop acquistion failed:{0:x8}", nRet);
break;
}
} while (false);
// ch:关闭流通道 | en:Close Stream
if (null != cStream)
{
nRet = cStream.CloseStream();
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Close stream failed:{0:x8}", nRet);
}
cStream = null;
}
// ch:关闭设备 | en:Close device
if (null != cDevice)
{
nRet = cDevice.CloseDevice();
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Close device failed:{0:x8}", nRet);
}
cDevice = null;
}
// ch:关闭采集卡 | en:Close interface
if (null != cInterface)
{
nRet = cInterface.CloseInterface();
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Close interface failed:{0:x8}", nRet);
}
cInterface = null;
}
Console.WriteLine("Press enter to exit.");
Console.ReadKey();
}
}
}


回调取图

该示例程序说明如何通过回调取图的方式获取相机图像。打开采集卡，打开相机，打开流通道，设置内部缓存数量，注册回调函数，开始取流，停止取流，关闭流通道，关闭相机，关闭采集卡。
using System;
using System.Collections.Generic;
using MvFGCtrlC.NET;
using System.Runtime.InteropServices;
using System.IO;
namespace GrabImage_Callback
{
class GrabImage_Callback
{
// ch:帧信息回调函数 | en:Frame info callback
static void ImageCallbackFunc(ref MV_FG_BUFFER_INFO stBufferInfo, IntPtr pUser)
{
if (null != stBufferInfo.pBuffer)
{
Console.WriteLine("FrameNumber: " + Convert.ToInt64(stBufferInfo.nFrameID).ToString() + ", Width: " +
stBufferInfo.nWidth.ToString() + ", Height: " + stBufferInfo.nHeight.ToString());
}
}
static void Main(string[] args)
{
int nRet = CErrorCode.MV_FG_SUCCESS;
CSystem cSystem = new CSystem(); // ch:操作采集卡 | en:Interface operations
CInterface cInterface = null; // ch:操作采集卡和设备 | en:Interface and device operation
CDevice cDevice = null; // ch:操作设备和流 | en:Device and stream operation
CStream cStream = null; // ch:操作流和缓存 | en:Stream and buffer operation
do
{
// ch:枚举采集卡 | en:Enum interface
bool bChanged = false;
nRet = cSystem.UpdateInterfaceList(
CParamDefine.MV_FG_CAMERALINK_INTERFACE | CParamDefine.MV_FG_GEV_INTERFACE | CParamDefine.MV_FG_CXP_INTERFACE,
ref bChanged);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Enum interface failed:{0:x8}", nRet);
break;
}
// ch:获取采集卡数量 | en:Get interface num
uint nInterfaceNum = 0; // ch:采集卡数量 | en:Interface number
nRet = cSystem.GetNumInterfaces(ref nInterfaceNum);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Get interface number failed:{0:x8}", nRet);
break;
}
if (0 == nInterfaceNum)
{
Console.WriteLine("No interface found");
break;
}
// ch:显示采集卡信息 | en:Show interface info
MV_FG_INTERFACE_INFO stIfInfo = new MV_FG_INTERFACE_INFO();
for (uint i = 0; i < nInterfaceNum; i++)
{
// ch:获取采集卡信息 | en:Get interface info
nRet = cSystem.GetInterfaceInfo(i, ref stIfInfo);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Get interface info failed:{0:x8}", nRet);
break;
}
if (CParamDefine.MV_FG_GEV_INTERFACE == stIfInfo.nTLayerType)
{
// Byte数组转换为结构体
MV_GEV_INTERFACE_INFO stGevIFInfo = (MV_GEV_INTERFACE_INFO)CAdditional.ByteToStruct(
stIfInfo.SpecialInfo.stGevIfInfo, typeof(MV_GEV_INTERFACE_INFO));
Console.WriteLine("[GEV]No." + i.ToString() + " Interface:");
Console.WriteLine("\tDisplayName: " + stGevIFInfo.chDisplayName);
Console.WriteLine("\tInterfaceID: " + stGevIFInfo.chInterfaceID);
Console.WriteLine("\tSerialNumber: " + stGevIFInfo.chSerialNumber);
}
else if (CParamDefine.MV_FG_CXP_INTERFACE == stIfInfo.nTLayerType)
{
// Byte数组转换为结构体
MV_CXP_INTERFACE_INFO stCxpIFInfo = (MV_CXP_INTERFACE_INFO)CAdditional.ByteToStruct(
stIfInfo.SpecialInfo.stCXPIfInfo, typeof(MV_CXP_INTERFACE_INFO));
Console.WriteLine("[CXP]No." + i.ToString() + " Interface:");
Console.WriteLine("\tDisplayName: " + stCxpIFInfo.chDisplayName);
Console.WriteLine("\tInterfaceID: " + stCxpIFInfo.chInterfaceID);
Console.WriteLine("\tSerialNumber: " + stCxpIFInfo.chSerialNumber);
}
else if (CParamDefine.MV_FG_CAMERALINK_INTERFACE == stIfInfo.nTLayerType)
{
// Byte数组转换为结构体
MV_CML_INTERFACE_INFO stCmlIFInfo = (MV_CML_INTERFACE_INFO)CAdditional.ByteToStruct(
stIfInfo.SpecialInfo.stCMLIfInfo, typeof(MV_CML_INTERFACE_INFO));
Console.WriteLine("[CML]No." + i.ToString() + " Interface:");
Console.WriteLine("\tDisplayName: " + stCmlIFInfo.chDisplayName);
Console.WriteLine("\tInterfaceID: " + stCmlIFInfo.chInterfaceID);
Console.WriteLine("\tSerialNumber: " + stCmlIFInfo.chSerialNumber);
}
else
{
Console.WriteLine("Unknown interface type.");
nRet = CErrorCode.MV_FG_ERR_INVALID_VALUE;
break;
}
}
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
break;
}
// ch:选择采集卡 | en:Select interface
int nInterfaceIndex = -1;
Console.Write("Please input index(0-{0:d}):", nInterfaceNum - 1);
try
{
nInterfaceIndex = Convert.ToInt32(Console.ReadLine());
}
catch
{
Console.WriteLine("Invalid Index!");
break;
}
if (nInterfaceIndex < 0 || nInterfaceIndex >= nInterfaceNum)
{
Console.WriteLine("Error Index!");
break;
}
// ch:打开采集卡，获得采集卡句柄 | en:Open interface, get handle
nRet = cSystem.OpenInterface((uint)nInterfaceIndex, out cInterface);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Open Interface failed:{0:x8}", nRet);
break;
}
// ch:枚举采集卡上的相机 | en:Enum camera of interface
nRet = cInterface.UpdateDeviceList(ref bChanged);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Enum device failed:{0:x8}", nRet);
break;
}
// ch:获取设备数量 | en:Get device number
uint nDeviceNum = 0; // ch:设备数量 | en:Device number
nRet = cInterface.GetNumDevices(ref nDeviceNum);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Get device number failed:{0:x8}", nRet);
break;
}
if (0 == nDeviceNum)
{
Console.WriteLine("No device found");
break;
}
// ch:显示设备信息 | en:Show device info
MV_FG_DEVICE_INFO stDeviceInfo = new MV_FG_DEVICE_INFO();
for (uint i = 0; i < nDeviceNum; i++)
{
// ch:获取设备信息 | en:Get device info
nRet = cInterface.GetDeviceInfo(i, ref stDeviceInfo);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Get device info failed:{0:x8}", nRet);
break;
}
if (CParamDefine.MV_FG_GEV_DEVICE == stDeviceInfo.nDevType)
{
// Byte数组转换为结构体
MV_GEV_DEVICE_INFO stGevDevInfo = (MV_GEV_DEVICE_INFO)CAdditional.ByteToStruct(
stDeviceInfo.DevInfo.stGEVDevInfo, typeof(MV_GEV_DEVICE_INFO));
Console.WriteLine("[GEV]No." + i.ToString() + " Device:");
Console.WriteLine("\tUserDefinedName: " + stGevDevInfo.chUserDefinedName);
Console.WriteLine("\tModelName: " + stGevDevInfo.chModelName);
Console.WriteLine("\tSerialNumber: " + stGevDevInfo.chSerialNumber);
}
else if (CParamDefine.MV_FG_CXP_DEVICE == stDeviceInfo.nDevType)
{
// Byte数组转换为结构体
MV_CXP_DEVICE_INFO stCxpDevInfo = (MV_CXP_DEVICE_INFO)CAdditional.ByteToStruct(
stDeviceInfo.DevInfo.stCXPDevInfo, typeof(MV_CXP_DEVICE_INFO));
Console.WriteLine("[CXP]No." + i.ToString() + " Device:");
Console.WriteLine("\tUserDefinedName: " + stCxpDevInfo.chUserDefinedName);
Console.WriteLine("\tModelName: " + stCxpDevInfo.chModelName);
Console.WriteLine("\tSerialNumber: " + stCxpDevInfo.chSerialNumber);
}
else if (CParamDefine.MV_FG_CAMERALINK_DEVICE == stDeviceInfo.nDevType)
{
// Byte数组转换为结构体
MV_CML_DEVICE_INFO stCmlDevInfo = (MV_CML_DEVICE_INFO)CAdditional.ByteToStruct(
stDeviceInfo.DevInfo.stCMLDevInfo, typeof(MV_CML_DEVICE_INFO));
Console.WriteLine("[CML]No." + i.ToString() + " Device:");
Console.WriteLine("\tUserDefinedName: " + stCmlDevInfo.chUserDefinedName);
Console.WriteLine("\tModelName: " + stCmlDevInfo.chModelName);
Console.WriteLine("\tSerialNumber: " + stCmlDevInfo.chSerialNumber);
}
else
{
Console.WriteLine("Unknown device type.");
nRet = CErrorCode.MV_FG_ERR_INVALID_VALUE;
break;
}
}
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
break;
}
// ch:选择设备 | en:Select device
int nDeviceIndex = -1;
Console.Write("Please input index(0-{0:d}):", nDeviceNum - 1);
try
{
nDeviceIndex = Convert.ToInt32(Console.ReadLine());
}
catch
{
Console.WriteLine("Invalid Index!");
break;
}
if (nDeviceIndex < 0 || nDeviceIndex >= nDeviceNum)
{
Console.WriteLine("Error Index!");
break;
}
// ch:打开设备，获得设备句柄 | en:Open device, get handle
nRet = cInterface.OpenDevice((uint)nDeviceIndex, out cDevice);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Open device failed:{0:x8}", nRet);
break;
}
CParam cDeviceParam = new CParam(cDevice); // ch:操作采集卡或设备参数配置 | en:Interface or device config operation
// ch:关闭触发模式 | en:Close trigger mode
nRet = cDeviceParam.SetEnumValueByString("TriggerMode", "Off");
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Turn off trigger mode failed:{0:x8}", nRet);
break;
}
// ch:获取流通道个数 | en:Get number of stream
uint nStreamNum = 0;
nRet = cDevice.GetNumStreams(ref nStreamNum);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Get stream number failed:{0:x8}", nRet);
break;
}
if (0 == nStreamNum)
{
Console.WriteLine("No stream available");
break;
}
// ch:打开流通道(目前只支持单个通道) | en:Open stream(Only a single stream is supported now)
nRet = cDevice.OpenStream(0, out cStream);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Open stream failed:{0:x8}", nRet);
break;
}
// ch:设置SDK内部缓存数量 | en:Set internal buffer number
const uint nBufNum = 3;
nRet = cStream.SetBufferNum(nBufNum);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Set buffer number failed:{0:x8}", nRet);
break;
}
// ch:注册帧缓存信息回调函数 | en:Register frame info callback
nRet = cStream.RegisterImageCallBack(new CStream.ImageDelegate(ImageCallbackFunc), IntPtr.Zero);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Register image callback failed:{0:x8}", nRet);
break;
}
// ch:开始取流 | en:Start Acquisition
nRet = cStream.StartAcquisition();
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Start acquistion failed:{0:x8}", nRet);
break;
}
Console.WriteLine("Press enter to exit.");
Console.ReadKey();
// ch:停止取流 | en:Stop Acquisition
nRet = cStream.StopAcquisition();
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Stop acquistion failed:{0:x8}", nRet);
break;
}
} while (false);
// ch:关闭流通道 | en:Close Stream
if (null != cStream)
{
nRet = cStream.CloseStream();
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Close stream failed:{0:x8}", nRet);
}
cStream = null;
}
// ch:关闭设备 | en:Close device
if (null != cDevice)
{
nRet = cDevice.CloseDevice();
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Close device failed:{0:x8}", nRet);
}
cDevice = null;
}
// ch:关闭采集卡 | en:Close interface
if (null != cInterface)
{
nRet = cInterface.CloseInterface();
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Close interface failed:{0:x8}", nRet);
}
cInterface = null;
}
Console.WriteLine("Press enter to exit.");
Console.ReadKey();
}
}
}


获取采集卡事件

该示例程序说明了如何配置相机事件功能、如何注册事件回调以及如何在事件回调函数中处理获取到的事件信息。Event事件例如：ExposureEnd。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MvFGCtrlC.NET;
using System.Runtime.InteropServices;
using System.IO;
using System.Threading;
namespace Event
{
class Event
{
static bool g_bExit = false;
static int nEventNum = 0;
static void EventCallBack(ref MV_FG_EVENT_INFO stEventInfo, IntPtr pUser)
{
nEventNum++;
if (null != stEventInfo.pEventData)
{
Console.WriteLine("{0} Event: name {1} id {2:x} time {3} \r\n", nEventNum, stEventInfo.strEventName, stEventInfo.nEventID, stEventInfo.nTimestamp);
}
}
//取线程例程
static void GrabbingThread(object obj)
{
if (null != obj)
{
int nRet = 0;
const uint nTimeout = 1000;
CStream cStream = obj as CStream;
MV_FG_BUFFER_INFO stFrameInfo = new MV_FG_BUFFER_INFO(); // 图像信息
// ch:开始取流 | en:Start Acquisition
nRet = cStream.StartAcquisition();
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Start acquistion failed:{0:x8}", nRet);
return;
}
g_bExit = false;
while (!g_bExit)
{
// ch:获取一帧图像缓存信息 | en:Get one frame buffer's info
nRet = cStream.GetFrameBuffer(ref stFrameInfo, nTimeout);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Get frame buffer failed:{0:x8}", nRet);
continue;
}
else
{
Console.WriteLine("FrameNumber: " + stFrameInfo.nFrameID.ToString() +
", Width: " + stFrameInfo.nWidth.ToString() + ", Height: " + stFrameInfo.nHeight.ToString());
}
// ch:释放缓存信息 | en:Release buffer info
nRet = cStream.ReleaseFrameBuffer(stFrameInfo);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Release frame buffer failed:{0:x8}", nRet);
break;
}
}
}
}
static void Main(string[] args)
{
int nRet = CErrorCode.MV_FG_SUCCESS;
CSystem cSystem = new CSystem(); // ch:操作采集卡 | en:Interface operations
CInterface cInterface = null; // ch:操作采集卡和设备 | en:Interface and device operation
CDevice cDevice = null; // ch:操作设备和流 | en:Device and stream operation
CStream cStream = null; // ch:操作流和缓存 | en:Stream and buffer operation
do
{
// ch:枚举采集卡 | en:Enum interface
bool bChanged = false;
nRet = cSystem.UpdateInterfaceList(
CParamDefine.MV_FG_CAMERALINK_INTERFACE | CParamDefine.MV_FG_GEV_INTERFACE | CParamDefine.MV_FG_CXP_INTERFACE,
ref bChanged);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Enum interface failed:{0:x8}", nRet);
break;
}
// ch:获取采集卡数量 | en:Get interface num
uint nInterfaceNum = 0; // ch:采集卡数量 | en:Interface number
nRet = cSystem.GetNumInterfaces(ref nInterfaceNum);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Get interface number failed:{0:x8}", nRet);
break;
}
if (0 == nInterfaceNum)
{
Console.WriteLine("No interface found");
break;
}
// ch:显示采集卡信息 | en:Show interface info
MV_FG_INTERFACE_INFO stIfInfo = new MV_FG_INTERFACE_INFO();
for (uint i = 0; i < nInterfaceNum; i++)
{
// ch:获取采集卡信息 | en:Get interface info
nRet = cSystem.GetInterfaceInfo(i, ref stIfInfo);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Get interface info failed:{0:x8}", nRet);
break;
}
if (CParamDefine.MV_FG_GEV_INTERFACE == stIfInfo.nTLayerType)
{
// Byte数组转换为结构体
MV_GEV_INTERFACE_INFO stGevIFInfo = (MV_GEV_INTERFACE_INFO)CAdditional.ByteToStruct(
stIfInfo.SpecialInfo.stGevIfInfo, typeof(MV_GEV_INTERFACE_INFO));
Console.WriteLine("[GEV]No." + i.ToString() + " Interface:");
Console.WriteLine("\tDisplayName: " + stGevIFInfo.chDisplayName);
Console.WriteLine("\tInterfaceID: " + stGevIFInfo.chInterfaceID);
Console.WriteLine("\tSerialNumber: " + stGevIFInfo.chSerialNumber);
}
else if (CParamDefine.MV_FG_CXP_INTERFACE == stIfInfo.nTLayerType)
{
// Byte数组转换为结构体
MV_CXP_INTERFACE_INFO stCxpIFInfo = (MV_CXP_INTERFACE_INFO)CAdditional.ByteToStruct(
stIfInfo.SpecialInfo.stCXPIfInfo, typeof(MV_CXP_INTERFACE_INFO));
Console.WriteLine("[CXP]No." + i.ToString() + " Interface:");
Console.WriteLine("\tDisplayName: " + stCxpIFInfo.chDisplayName);
Console.WriteLine("\tInterfaceID: " + stCxpIFInfo.chInterfaceID);
Console.WriteLine("\tSerialNumber: " + stCxpIFInfo.chSerialNumber);
}
else if (CParamDefine.MV_FG_CAMERALINK_INTERFACE == stIfInfo.nTLayerType)
{
// Byte数组转换为结构体
MV_CML_INTERFACE_INFO stCmlIFInfo = (MV_CML_INTERFACE_INFO)CAdditional.ByteToStruct(
stIfInfo.SpecialInfo.stCMLIfInfo, typeof(MV_CML_INTERFACE_INFO));
Console.WriteLine("[CML]No." + i.ToString() + " Interface:");
Console.WriteLine("\tDisplayName: " + stCmlIFInfo.chDisplayName);
Console.WriteLine("\tInterfaceID: " + stCmlIFInfo.chInterfaceID);
Console.WriteLine("\tSerialNumber: " + stCmlIFInfo.chSerialNumber);
}
else
{
Console.WriteLine("Unknown interface type.");
nRet = CErrorCode.MV_FG_ERR_INVALID_VALUE;
break;
}
}
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
break;
}
// ch:选择采集卡 | en:Select interface
int nInterfaceIndex = -1;
Console.Write("Please input index(0-{0:d}):", nInterfaceNum - 1);
try
{
nInterfaceIndex = Convert.ToInt32(Console.ReadLine());
}
catch
{
Console.WriteLine("Invalid Index!");
break;
}
if (nInterfaceIndex < 0 || nInterfaceIndex >= nInterfaceNum)
{
Console.WriteLine("Error Index!");
break;
}
// ch:打开采集卡，获得采集卡句柄 | en:Open interface, get handle
nRet = cSystem.OpenInterface((uint)nInterfaceIndex, out cInterface);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Open Interface failed:{0:x8}", nRet);
break;
}
// 注册采集卡帧开始事件回调
CCallback cCallBack = new CCallback(cInterface);
nRet = cCallBack.RegisterEventCallBack("ReceiveImageFrameStart0", new CCallback.EventDelegate(EventCallBack), IntPtr.Zero);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("RegisterEventCallBack event ReceiveImageFrameStart0 failed:{0:x8}", nRet);
break;
}
// 设置事件类型为流事件(可自行设置EventCategory相机节点下的其他事件类型)
CParam cParam = new CParam(cInterface);
nRet = cParam.SetEnumValueByString("EventCategory", "StreamEvent");
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("SetEnumValueByString EventCategory failed:{0:x8}", nRet);
break;
}
// 设置事件通道(Channel0-Channel3)
nRet = cParam.SetEnumValueByString("ChannelSelector", "Channel0");
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("SetEnumValueByString ChannelSelector failed:{0:x8}", nRet);
break;
}
// 设置具体事件(可自行设置EventSelector相机节点下的其他具体事件)
nRet = cParam.SetEnumValueByString("EventSelector", "ReceiveImageFrameStart0");
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("SetEnumValueByString EventSelector failed:{0:x8}", nRet);
break;
}
// 打开事件通知
nRet = cParam.SetEnumValueByString("EventNotification", "On");
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("SetEnumValueByString EventNotification failed:{0:x8}", nRet);
break;
}
// ch:枚举采集卡上的相机 | en:Enum camera of interface
nRet = cInterface.UpdateDeviceList(ref bChanged);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Enum device failed:{0:x8}", nRet);
break;
}
// ch:获取设备数量 | en:Get device number
uint nDeviceNum = 0; // ch:设备数量 | en:Device number
nRet = cInterface.GetNumDevices(ref nDeviceNum);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Get device number failed:{0:x8}", nRet);
break;
}
if (0 == nDeviceNum)
{
Console.WriteLine("No device found");
break;
}
// ch:显示设备信息 | en:Show device info
MV_FG_DEVICE_INFO stDeviceInfo = new MV_FG_DEVICE_INFO();
for (uint i = 0; i < nDeviceNum; i++)
{
// ch:获取设备信息 | en:Get device info
nRet = cInterface.GetDeviceInfo(i, ref stDeviceInfo);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Get device info failed:{0:x8}", nRet);
break;
}
if (CParamDefine.MV_FG_GEV_DEVICE == stDeviceInfo.nDevType)
{
// Byte数组转换为结构体
MV_GEV_DEVICE_INFO stGevDevInfo = (MV_GEV_DEVICE_INFO)CAdditional.ByteToStruct(
stDeviceInfo.DevInfo.stGEVDevInfo, typeof(MV_GEV_DEVICE_INFO));
Console.WriteLine("[GEV]No." + i.ToString() + " Device:");
Console.WriteLine("\tUserDefinedName: " + stGevDevInfo.chUserDefinedName);
Console.WriteLine("\tModelName: " + stGevDevInfo.chModelName);
Console.WriteLine("\tSerialNumber: " + stGevDevInfo.chSerialNumber);
}
else if (CParamDefine.MV_FG_CXP_DEVICE == stDeviceInfo.nDevType)
{
// Byte数组转换为结构体
MV_CXP_DEVICE_INFO stCxpDevInfo = (MV_CXP_DEVICE_INFO)CAdditional.ByteToStruct(
stDeviceInfo.DevInfo.stCXPDevInfo, typeof(MV_CXP_DEVICE_INFO));
Console.WriteLine("[CXP]No." + i.ToString() + " Device:");
Console.WriteLine("\tUserDefinedName: " + stCxpDevInfo.chUserDefinedName);
Console.WriteLine("\tModelName: " + stCxpDevInfo.chModelName);
Console.WriteLine("\tSerialNumber: " + stCxpDevInfo.chSerialNumber);
}
else if (CParamDefine.MV_FG_CAMERALINK_DEVICE == stDeviceInfo.nDevType)
{
// Byte数组转换为结构体
MV_CML_DEVICE_INFO stCmlDevInfo = (MV_CML_DEVICE_INFO)CAdditional.ByteToStruct(
stDeviceInfo.DevInfo.stCMLDevInfo, typeof(MV_CML_DEVICE_INFO));
Console.WriteLine("[CML]No." + i.ToString() + " Device:");
Console.WriteLine("\tUserDefinedName: " + stCmlDevInfo.chUserDefinedName);
Console.WriteLine("\tModelName: " + stCmlDevInfo.chModelName);
Console.WriteLine("\tSerialNumber: " + stCmlDevInfo.chSerialNumber);
}
else
{
Console.WriteLine("Unknown device type.");
nRet = CErrorCode.MV_FG_ERR_INVALID_VALUE;
break;
}
}
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
break;
}
// ch:选择设备 | en:Select device
int nDeviceIndex = -1;
Console.Write("Please input index(0-{0:d}):", nDeviceNum - 1);
try
{
nDeviceIndex = Convert.ToInt32(Console.ReadLine());
}
catch
{
Console.WriteLine("Invalid Index!");
break;
}
if (nDeviceIndex < 0 || nDeviceIndex >= nDeviceNum)
{
Console.WriteLine("Error Index!");
break;
}
// ch:打开设备，获得设备句柄 | en:Open device, get handle
nRet = cInterface.OpenDevice((uint)nDeviceIndex, out cDevice);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Open device failed:{0:x8}", nRet);
break;
}
CParam cDeviceParam = new CParam(cDevice); // ch:操作采集卡或设备参数配置 | en:Interface or device config operation
// ch:关闭触发模式 | en:Close trigger mode
nRet = cDeviceParam.SetEnumValueByString("TriggerMode", "Off");
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Turn off trigger mode failed:{0:x8}", nRet);
break;
}
// ch:获取流通道个数 | en:Get number of stream
uint nStreamNum = 0;
nRet = cDevice.GetNumStreams(ref nStreamNum);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Get stream number failed:{0:x8}", nRet);
break;
}
if (0 == nStreamNum)
{
Console.WriteLine("No stream available");
break;
}
// ch:打开流通道(目前只支持单个通道) | en:Open stream(Only a single stream is supported now)
nRet = cDevice.OpenStream(0, out cStream);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Open stream failed:{0:x8}", nRet);
break;
}
// ch:设置SDK内部缓存数量 | en:Set internal buffer number
const uint nBufNum = 3;
nRet = cStream.SetBufferNum(nBufNum);
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Set buffer number failed:{0:x8}", nRet);
break;
}
// ch:创建取流线程 | en:Create acquistion thread
Thread hGrabThread = new Thread(GrabbingThread);
if (null == hGrabThread)
{
Console.WriteLine("Create thread failed");
break;
}
hGrabThread.Start(cStream);
Console.WriteLine("Press enter to exit.");
Console.ReadKey();
g_bExit = true;
Thread.Sleep(1000); // 确保线程正常结束
// ch:停止取流 | en:Stop Acquisition
nRet = cStream.StopAcquisition();
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Stop acquistion failed:{0:x8}", nRet);
break;
}
} while (false);
// ch:关闭流通道 | en:Close Stream
if (null != cStream)
{
nRet = cStream.CloseStream();
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Close stream failed:{0:x8}", nRet);
}
cStream = null;
}
// ch:关闭设备 | en:Close device
if (null != cDevice)
{
nRet = cDevice.CloseDevice();
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Close device failed:{0:x8}", nRet);
}
cDevice = null;
}
// ch:关闭采集卡 | en:Close interface
if (null != cInterface)
{
nRet = cInterface.CloseInterface();
if (CErrorCode.MV_FG_SUCCESS != nRet)
{
Console.WriteLine("Close interface failed:{0:x8}", nRet);
}
cInterface = null;
}
Console.WriteLine("Press enter to exit.");
Console.ReadKey();
}
}
}


错误码定义
正确码
名称 | 值 | 说明
MV_FG_SUCCESS | 0x00000000 | 成功，无错误
通用错误码：范围0x80190000-0x801900FF
名称 | 值 | 说明
MV_FG_ERR_ERROR | 0x80190001 | 未知错误
MV_FG_ERR_NOT_INITIALIZED | 0x80190002 | 未初始化
MV_FG_ERR_NOT_IMPLEMENTED | 0x80190003 | 未实现
MV_FG_ERR_RESOURCE_IN_USE | 0x80190004 | 资源被占用
MV_FG_ERR_ACCESS_DENIED | 0x80190005 | 无权限
MV_FG_ERR_INVALID_HANDLE | 0x80190006 | 无效句柄
MV_FG_ERR_INVALID_ID | 0x80190007 | 无效ID
MV_FG_ERR_NO_DATA | 0x80190008 | 无数据
MV_FG_ERR_INVALID_PARAMETER | 0x80190009 | 无效参数
MV_FG_ERR_IO | 0x80190010 | IO错误
MV_FG_ERR_TIMEOUT | 0x80190011 | 超时
MV_FG_ERR_ABORT | 0x80190012 | 操作被中断
MV_FG_ERR_INVALID_BUFFER | 0x80190013 | 无效缓存
MV_FG_ERR_NOT_AVAILABLE | 0x80190014 | 不可达
MV_FG_ERR_INVALID_ADDRESS | 0x80190015 | 无效地址
MV_FG_ERR_BUFFER_TOO_SMALL | 0x80190016 | 缓存太小
MV_FG_ERR_INVALID_INDEX | 0x80190017 | 无效索引
MV_FG_ERR_PARSING_CHUNK_DATA | 0x80190018 | 解析Chunk失败
MV_FG_ERR_INVALID_VALUE | 0x80190019 | 无效的值
MV_FG_ERR_RESOURCE_EXHAUSTED | 0x80190020 | 资源耗尽
MV_FG_ERR_OUT_OF_MEMORY | 0x80190021 | 内存申请失败
MV_FG_ERR_BUSY | 0x80190022 | 忙碌
MV_FG_ERR_LOADLIBRARY | 0x80190023 | 动态库加载失败
MV_FG_ERR_CALLORDER | 0x80190024 | 函数调用错误
GenICam错误码：范围0x80190100-0x801901FF
名称 | 值 | 说明
MV_FG_ERR_GC_GENERIC | 0x80190100 | GenICam通用错误
MV_FG_ERR_GC_ARGUMENT | 0x80190101 | GenICam参数错误
MV_FG_ERR_GC_RANGE | 0x80190102 | GenICam参数范围错误
MV_FG_ERR_GC_PROPERTY | 0x80190103 | GenICam属性错误
MV_FG_ERR_GC_RUNTIME | 0x80190104 | GenICam运行环境错误
MV_FG_ERR_GC_LOGICAL | 0x80190105 | GenICam逻辑错误
MV_FG_ERR_GC_ACCESS | 0x80190106 | GenICam权限错误
MV_FG_ERR_GC_TIMEOUT | 0x80190107 | GenICam超时
MV_FG_ERR_GC_DYNAMICCAST | 0x80190108 | GenICam转换异常
MV_FG_ERR_GC_UNKNOW | 0x801901FF | GenICam未知错误
图像处理错误：范围0x80190200-0x801902FF
名称 | 值 | 说明
MV_FG_ERR_IMG_HANDLE | 0x80190200 | 图像处理库句柄错误
MV_FG_ERR_IMG_SUPPORT | 0x80190201 | 图像处理库不支持
MV_FG_ERR_IMG_PARAMETER | 0x80190202 | 图像处理库参数错误
MV_FG_ERR_IMG_OVERFLOW | 0x80190203 | 图像处理库内存溢出
MV_FG_ERR_IMG_INITIALIZED | 0x80190204 | 图像处理库操作未初始化
MV_FG_ERR_IMG_RESOURCE | 0x80190205 | 图像处理库资源申请释放失败
MV_FG_ERR_IMG_ENCRYPT | 0x80190206 | 图像加密错误
MV_FG_ERR_IMG_FORMAT | 0x80190207 | 图像格式不正确或者不支持
MV_FG_ERR_IMG_SIZE | 0x80190208 | 图像宽高不正确或者超出范围
MV_FG_ERR_IMG_STEP | 0x80190209 | 图像宽高与step参数不匹配
MV_FG_ERR_IMG_DATA_NULL | 0x80190210 | 图像数据存储地址为空(某个分量)
MV_FG_ERR_IMG_ABILITY_ARG | 0x80190211 | 图像算法ABILITY存在无效参数
MV_FG_ERR_IMG_UNKNOW | 0x801902FF | 图像处理未知错误


抠图参数

读码器SDK中可设置的抠图参数如下表所示。
参数名 | 参数说明 | 默认值 | 取值范围
KEY_WAYBILL_ABILITY | 算法能力集，1为含面单提取，2为图像增强，4为码提取，8为Box拷贝模块，16为面单提取模块 | 31 | 1-31


CAdditional 成员列表

成员的完整列表，这些成员属于 CAdditional,包括所有继承而来的类成员

ByteToStruct(Byte[] bytes, Type type) CAdditional static


CBuffer 成员列表

成员的完整列表，这些成员属于 CBuffer,包括所有继承而来的类成员

CBuffer(IntPtr bufferHandle) | CBuffer
GetBufferInfo(ref MV_FG_BUFFER_INFO stBufferInfo) | CBuffer


CCallback 成员列表

成员的完整列表，这些成员属于 CCallback,包括所有继承而来的类成员

CCallback(CInterface cInterface) | CCallback
CCallback(CDevice cDevice) | CCallback
CCallback(CStream cStream) | CCallback
EventDelegate(ref MV_FG_EVENT_INFO stBufferInfo, IntPtr pUser) | CCallback
ExceptionDelegate(MV_FG_EXCEPTION_TYPE enExceptionType, IntPtr pUser) | CCallback
RegisterEventCallBack(String strEventName, EventDelegate eventDelegate, IntPtr pUser) | CCallback
RegisterExceptionCallBack(ExceptionDelegate exceptionDelegate, IntPtr pUser) | CCallback


CDevice 成员列表

成员的完整列表，这些成员属于 CDevice,包括所有继承而来的类成员

CDevice(IntPtr ptrDevcie) | CDevice
CloseDevice() | CDevice
GetHandle() | CDevice
GetNumStreams(ref uint nNumStreams) | CDevice
OpenStream(uint nIndex, out CStream cStream) | CDevice


CImageProcess 成员列表

成员的完整列表，这些成员属于 CImageProcess,包括所有继承而来的类成员

CImageProcess(CDevice cDevice) | CImageProcess
CImageProcess(CInterface cInterface) | CImageProcess
CImageProcess(CStream cStream) | CImageProcess
ConvertPixelType(ref MV_FG_CONVERT_PIXEL_INFO stConvertPixelInfo) | CImageProcess
DisplayOneFrame(IntPtr hWnd, ref MV_FG_INPUT_IMAGE_INFO stFrameInfo) | CImageProcess
HB_Decode(ref MV_FG_HB_DECODE_PARAM stDecodeParam) | CImageProcess
ReconstructImage(ref MV_FG_RECONSTRUCT_INFO stReconstructInfo) | CImageProcess
SaveBitmap(ref MV_FG_SAVE_BITMAP_INFO stSaveBitmapInfo) | CImageProcess
SaveJpeg(ref MV_FG_SAVE_JPEG_INFO stSaveJpegInfo) | CImageProcess
SavePngToFile(ref MV_FG_SAVE_PNG_TO_FILE_INFO stSavePngInfo) | CImageProcess
SaveTiffToFile(ref MV_FG_SAVE_TIFF_TO_FILE_INFO stSaveTiffInfo) | CImageProcess


CInterface 成员列表

成员的完整列表，这些成员属于 CInterface,包括所有继承而来的类成员

CInterface(IntPtr ptrHandle) | CInterface
CloseDevice() | CInterface
CloseInterface() | CInterface
GetDeviceInfo(uint nIndex, ref MV_FG_DEVICE_INFO stDevInfo) | CInterface
GetHandle() | CInterface
GetNumDevices(ref uint nNumDevices) | CInterface
OpenDevice(uint nIndex, out CDevice cDevice) | CInterface
OpenDeviceByID(String strDeviceID, out CDevice cDevice) | CInterface
UpdateDeviceList(ref bool bChanged) | CInterface


CMultiBuffer 成员列表

成员的完整列表，这些成员属于 CMultiBuffer,包括所有继承而来的类成员

Announce() | CMultiBuffer
BufferCount | CMultiBuffer
CMultiBuffer() | CMultiBuffer
Contains(CBuffer cBuffer) | CMultiBuffer
GetByte() | CMultiBuffer
Init() | CMultiBuffer
PayloadSize | CMultiBuffer
QueueBuffer() | CMultiBuffer
Revoke() | CMultiBuffer
SetStreamHandle(CStream cStream) | CMultiBuffer


CParam 成员列表

成员的完整列表，这些成员属于 CParam,包括所有继承而来的类成员

CParam(CDevice cDevice) | CParam
CParam(CInterface cInterface) | CParam
FeatureLoad(String strFilePath) | CParam
FeatureSave(String strFilePath) | CParam
GetBoolValue(String strValue, ref Boolean pBoolValue) | CParam
GetEnumValue(String strValue, ref MV_FG_ENUMVALUE pEnumValue) | CParam
GetFloatValue(String strValue, ref MV_FG_FLOATVALUE pFloatValue) | CParam
GetIntValue(String strValue, ref MV_FG_INTVALUE pIntValue) | CParam
GetNodeAccessMode(String pstrName, ref MV_FG_NODE_ACCESS_MODE pAccessMode) | CParam
GetNodeInterfaceType(String pstrName, ref MV_FG_NODE_INTERFACE_TYPE pInterfaceType) | CParam
GetStringValue(String strKey, ref MV_FG_STRINGVALUE pStringValue) | CParam
GetXmlFile(ref Byte[] xmlData, UInt32 nDataSize, ref uint nDataLen) | CParam
SetBoolValue(String strValue, Boolean bValue) | CParam
SetCommandValue(String strValue) | CParam
SetEnumValue(String strValue, UInt32 nValue) | CParam
SetEnumValueByString(String strValue, String sValue) | CParam
SetFloatValue(String strValue, Single fValue) | CParam
SetIntValue(String strValue, Int64 nValue) | CParam
SetStringValue(String strKey, String sValue) | CParam


CStream 成员列表

成员的完整列表，这些成员属于 CStream,包括所有继承而来的类成员

AllocAndAnnounceBuffer(uint nImageCountPerBuffer, out CMultiBuffer cMultiBuffer) | CStream
AnnounceBuffer(IntPtr pBuffer, uint nSize, IntPtr pPrivate, out CBuffer cBuffer) | CStream
CloseStream() CStream
CStream(IntPtr streamHandle) | CStream
FlushQueue(MV_FG_BUFFER_QUEUE_TYPE enQueueType) | CStream
GetBufferChunkData(MV_FG_BUFFER_INFO stBufferInfo, uint nIndex, ref MV_FG_CHUNK_DATA_INFO stChunkData) | CStream
GetFrameBuffer(ref MV_FG_BUFFER_INFO stBufferInfo, uint nTimeout) | CStream
GetHandle() CStream
GetImageBuffer(out CBuffer cBuffer, uint nTimeout) | CStream
GetImageBuffer(uint nImageCountPerBuffer, out CMultiBuffer cMultiBuffer, uint nTimeout) | CStream
GetPayloadSize(ref uint nPayloadSize) | CStream
ImageDelegate(ref MV_FG_BUFFER_INFO stBufferInfo, IntPtr pUser) | CStream
RegisterImageCallBack(ImageDelegate imageDelegate, IntPtr pUser) | CStream
ReleaseFrameBuffer(MV_FG_BUFFER_INFO stBufferInfo) | CStream
RevokeBuffer(CBuffer cBuffer, ref IntPtr pBuffer, ref IntPtr pPrivate) | CStream
RevokeBuffer(CMultiBuffer cMultiBuffer) | CStream
SetBufferNum(uint nBufferNum) | CStream


CSystem 成员列表

成员的完整列表，这些成员属于 CSystem,包括所有继承而来的类成员

GetInterfaceInfo(uint nIndex, ref MV_FG_INTERFACE_INFO stIfaceInfo) | CSystem |
GetNumInterfaces(ref uint nNumIfaces) | CSystem |
GetSDKVersion() | CSystem |
MV_MEM_Alloc(uint nSize, uint nAlign) | CSystem | static
MV_MEM_Free(IntPtr ptrBuffer) | CSystem | static
OpenInterface(uint nIndex, out CInterface cInterface) | CSystem |
OpenInterface(uint nIndex, int nAccess, out CInterface cInterface) | CSystem |
OpenInterfaceByID(String strInterfaceID, int nAccess, out CInterface cInterface) | CSystem |
ReleaseTLayerResource(uint nTLayer) | CSystem |
UpdateInterfaceList(uint nTLayerType, ref bool bChanged) | CSystem |


  • MvFGCtrlC
  • NET
  • CErrorCode
Public 属性 | 所有成员列表
MvFGCtrlC.NET.CErrorCode类 参考

错误码定义类 更多...

Public 属性

const Int32 | MV_FG_SUCCESS = unchecked((Int32)0x00000000)
成功，无错误 更多...
const Int32 | MV_FG_ERR_ERROR = unchecked((Int32)0x80190001)
未知错误 更多...
const Int32 | MV_FG_ERR_NOT_INITIALIZED = unchecked((Int32)0x80190002)
未初始化 更多...
const Int32 | MV_FG_ERR_NOT_IMPLEMENTED = unchecked((Int32)0x80190003)
未实现 更多...
const Int32 | MV_FG_ERR_RESOURCE_IN_USE = unchecked((Int32)0x80190004)
资源被占用 更多...
const Int32 | MV_FG_ERR_ACCESS_DENIED = unchecked((Int32)0x80190005)
无权限 更多...
const Int32 | MV_FG_ERR_INVALID_HANDLE = unchecked((Int32)0x80190006)
无效句柄 更多...
const Int32 | MV_FG_ERR_INVALID_ID = unchecked((Int32)0x80190007)
无效ID 更多...
const Int32 | MV_FG_ERR_NO_DATA = unchecked((Int32)0x80190008)
无数据 更多...
const Int32 | MV_FG_ERR_INVALID_PARAMETER = unchecked((Int32)0x80190009)
无效参数 更多...
const Int32 | MV_FG_ERR_IO = unchecked((Int32)0x80190010)
IO错误 更多...
const Int32 | MV_FG_ERR_TIMEOUT = unchecked((Int32)0x80190011)
超时 更多...
const Int32 | MV_FG_ERR_ABORT = unchecked((Int32)0x80190012)
操作被中断 更多...
const Int32 | MV_FG_ERR_INVALID_BUFFER = unchecked((Int32)0x80190013)
无效缓存 更多...
const Int32 | MV_FG_ERR_NOT_AVAILABLE = unchecked((Int32)0x801900014)
不可达 更多...
const Int32 | MV_FG_ERR_INVALID_ADDRESS = unchecked((Int32)0x80190015)
无效地址 更多...
const Int32 | MV_FG_ERR_BUFFER_TOO_SMALL = unchecked((Int32)0x80190016)
缓存太小 更多...
const Int32 | MV_FG_ERR_INVALID_INDEX = unchecked((Int32)0x80190017)
无效索引 更多...
const Int32 | MV_FG_ERR_PARSING_CHUNK_DATA = unchecked((Int32)0x80190018)
解析Chunk失败 更多...
const Int32 | MV_FG_ERR_INVALID_VALUE = unchecked((Int32)0x80190019)
无效的值 更多...
const Int32 | MV_FG_ERR_RESOURCE_EXHAUSTED = unchecked((Int32)0x80190020)
资源耗尽 更多...
const Int32 | MV_FG_ERR_OUT_OF_MEMORY = unchecked((Int32)0x80190021)
内存申请失败 更多...
const Int32 | MV_FG_ERR_BUSY = unchecked((Int32)0x80190022)
忙碌 更多...
const Int32 | MV_FG_ERR_LOADLIBRARY = unchecked((Int32)0x80190023)
动态库加载失败 更多...
const Int32 | MV_FG_ERR_CALLORDER = unchecked((Int32)0x80190024)
函数调用错误 更多...
const Int32 | MV_FG_ERR_GC_GENERIC = unchecked((Int32)0x80190100)
通用错误 更多...
const Int32 | MV_FG_ERR_GC_ARGUMENT = unchecked((Int32)0x80190101)
参数错误 更多...
const Int32 | MV_FG_ERR_GC_RANGE = unchecked((Int32)0x80190102)
参数范围错误 更多...
const Int32 | MV_FG_ERR_GC_PROPERTY = unchecked((Int32)0x80190103)
属性错误 更多...
const Int32 | MV_FG_ERR_GC_RUNTIME = unchecked((Int32)0x80190104)
运行环境错误 更多...
const Int32 | MV_FG_ERR_GC_LOGICAL = unchecked((Int32)0x80190105)
逻辑错误 更多...
const Int32 | MV_FG_ERR_GC_ACCESS = unchecked((Int32)0x80190106)
权限错误 更多...
const Int32 | MV_FG_ERR_GC_TIMEOUT = unchecked((Int32)0x80190107)
超时 更多...
const Int32 | MV_FG_ERR_GC_DYNAMICCAST = unchecked((Int32)0x80190108)
转换异常 更多...
const Int32 | MV_FG_ERR_GC_UNKNOW = unchecked((Int32)0x801901FF)
未知错误 更多...
const Int32 | MV_FG_ERR_IMG_HANDLE = unchecked((Int32)0x80190200)
图像处理库句柄错误 更多...
const Int32 | MV_FG_ERR_IMG_SUPPORT = unchecked((Int32)0x80190201)
图像处理库不支持 更多...
const Int32 | MV_FG_ERR_IMG_PARAMETER = unchecked((Int32)0x80190202)
图像处理库参数错误 更多...
const Int32 | MV_FG_ERR_IMG_OVERFLOW = unchecked((Int32)0x80190203)
图像处理库内存溢出 更多...
const Int32 | MV_FG_ERR_IMG_INITIALIZED = unchecked((Int32)0x80190204)
图像处理库操作未初始化 更多...
const Int32 | MV_FG_ERR_IMG_RESOURCE = unchecked((Int32)0x80190205)
图像处理库资源申请释放失败 更多...
const Int32 | MV_FG_ERR_IMG_ENCRYPT = unchecked((Int32)0x80190206)
图像加密错误 更多...
const Int32 | MV_FG_ERR_IMG_FORMAT = unchecked((Int32)0x80190207)
图像格式不正确或者不支持 更多...
const Int32 | MV_FG_ERR_IMG_SIZE = unchecked((Int32)0x80190208)
图像宽高不正确或者超出范围 更多...
const Int32 | MV_FG_ERR_IMG_STEP = unchecked((Int32)0x80190209)
图像宽高与step参数不匹配 更多...
const Int32 | MV_FG_ERR_IMG_DATA_NULL = unchecked((Int32)0x80190210)
图像数据存储地址为空(某个分量) 更多...
const Int32 | MV_FG_ERR_IMG_ABILITY_ARG = unchecked((Int32)0x80190211)
图像算法ABILITY存在无效参数 更多...
const Int32 | MV_FG_ERR_IMG_UNKNOW = unchecked((Int32)0x801902FF)
图像处理未知错误 更多...

详细描述

错误码定义类

类成员变量说明

◆ MV_FG_SUCCESS

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_SUCCESS = unchecked((Int32)0x00000000)

成功，无错误

◆ MV_FG_ERR_ERROR

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_ERROR = unchecked((Int32)0x80190001)

未知错误

◆ MV_FG_ERR_NOT_INITIALIZED

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_NOT_INITIALIZED = unchecked((Int32)0x80190002)

未初始化

◆ MV_FG_ERR_NOT_IMPLEMENTED

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_NOT_IMPLEMENTED = unchecked((Int32)0x80190003)

未实现

◆ MV_FG_ERR_RESOURCE_IN_USE

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_RESOURCE_IN_USE = unchecked((Int32)0x80190004)

资源被占用

◆ MV_FG_ERR_ACCESS_DENIED

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_ACCESS_DENIED = unchecked((Int32)0x80190005)

无权限

◆ MV_FG_ERR_INVALID_HANDLE

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_INVALID_HANDLE = unchecked((Int32)0x80190006)

无效句柄

◆ MV_FG_ERR_INVALID_ID

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_INVALID_ID = unchecked((Int32)0x80190007)

无效ID

◆ MV_FG_ERR_NO_DATA

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_NO_DATA = unchecked((Int32)0x80190008)

无数据

◆ MV_FG_ERR_INVALID_PARAMETER

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_INVALID_PARAMETER = unchecked((Int32)0x80190009)

无效参数

◆ MV_FG_ERR_IO

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_IO = unchecked((Int32)0x80190010)

IO错误

◆ MV_FG_ERR_TIMEOUT

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_TIMEOUT = unchecked((Int32)0x80190011)

超时

◆ MV_FG_ERR_ABORT

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_ABORT = unchecked((Int32)0x80190012)

操作被中断

◆ MV_FG_ERR_INVALID_BUFFER

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_INVALID_BUFFER = unchecked((Int32)0x80190013)

无效缓存

◆ MV_FG_ERR_NOT_AVAILABLE

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_NOT_AVAILABLE = unchecked((Int32)0x801900014)

不可达

◆ MV_FG_ERR_INVALID_ADDRESS

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_INVALID_ADDRESS = unchecked((Int32)0x80190015)

无效地址

◆ MV_FG_ERR_BUFFER_TOO_SMALL

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_BUFFER_TOO_SMALL = unchecked((Int32)0x80190016)

缓存太小

◆ MV_FG_ERR_INVALID_INDEX

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_INVALID_INDEX = unchecked((Int32)0x80190017)

无效索引

◆ MV_FG_ERR_PARSING_CHUNK_DATA

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_PARSING_CHUNK_DATA = unchecked((Int32)0x80190018)

解析Chunk失败

◆ MV_FG_ERR_INVALID_VALUE

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_INVALID_VALUE = unchecked((Int32)0x80190019)

无效的值

◆ MV_FG_ERR_RESOURCE_EXHAUSTED

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_RESOURCE_EXHAUSTED = unchecked((Int32)0x80190020)

资源耗尽

◆ MV_FG_ERR_OUT_OF_MEMORY

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_OUT_OF_MEMORY = unchecked((Int32)0x80190021)

内存申请失败

◆ MV_FG_ERR_BUSY

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_BUSY = unchecked((Int32)0x80190022)

忙碌

◆ MV_FG_ERR_LOADLIBRARY

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_LOADLIBRARY = unchecked((Int32)0x80190023)

动态库加载失败

◆ MV_FG_ERR_CALLORDER

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_CALLORDER = unchecked((Int32)0x80190024)

函数调用错误

◆ MV_FG_ERR_GC_GENERIC

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_GC_GENERIC = unchecked((Int32)0x80190100)

通用错误

◆ MV_FG_ERR_GC_ARGUMENT

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_GC_ARGUMENT = unchecked((Int32)0x80190101)

参数错误

◆ MV_FG_ERR_GC_RANGE

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_GC_RANGE = unchecked((Int32)0x80190102)

参数范围错误

◆ MV_FG_ERR_GC_PROPERTY

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_GC_PROPERTY = unchecked((Int32)0x80190103)

属性错误

◆ MV_FG_ERR_GC_RUNTIME

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_GC_RUNTIME = unchecked((Int32)0x80190104)

运行环境错误

◆ MV_FG_ERR_GC_LOGICAL

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_GC_LOGICAL = unchecked((Int32)0x80190105)

逻辑错误

◆ MV_FG_ERR_GC_ACCESS

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_GC_ACCESS = unchecked((Int32)0x80190106)

权限错误

◆ MV_FG_ERR_GC_TIMEOUT

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_GC_TIMEOUT = unchecked((Int32)0x80190107)

超时

◆ MV_FG_ERR_GC_DYNAMICCAST

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_GC_DYNAMICCAST = unchecked((Int32)0x80190108)

转换异常

◆ MV_FG_ERR_GC_UNKNOW

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_GC_UNKNOW = unchecked((Int32)0x801901FF)

未知错误

◆ MV_FG_ERR_IMG_HANDLE

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_IMG_HANDLE = unchecked((Int32)0x80190200)

图像处理库句柄错误

◆ MV_FG_ERR_IMG_SUPPORT

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_IMG_SUPPORT = unchecked((Int32)0x80190201)

图像处理库不支持

◆ MV_FG_ERR_IMG_PARAMETER

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_IMG_PARAMETER = unchecked((Int32)0x80190202)

图像处理库参数错误

◆ MV_FG_ERR_IMG_OVERFLOW

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_IMG_OVERFLOW = unchecked((Int32)0x80190203)

图像处理库内存溢出

◆ MV_FG_ERR_IMG_INITIALIZED

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_IMG_INITIALIZED = unchecked((Int32)0x80190204)

图像处理库操作未初始化

◆ MV_FG_ERR_IMG_RESOURCE

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_IMG_RESOURCE = unchecked((Int32)0x80190205)

图像处理库资源申请释放失败

◆ MV_FG_ERR_IMG_ENCRYPT

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_IMG_ENCRYPT = unchecked((Int32)0x80190206)

图像加密错误

◆ MV_FG_ERR_IMG_FORMAT

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_IMG_FORMAT = unchecked((Int32)0x80190207)

图像格式不正确或者不支持

◆ MV_FG_ERR_IMG_SIZE

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_IMG_SIZE = unchecked((Int32)0x80190208)

图像宽高不正确或者超出范围

◆ MV_FG_ERR_IMG_STEP

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_IMG_STEP = unchecked((Int32)0x80190209)

图像宽高与step参数不匹配

◆ MV_FG_ERR_IMG_DATA_NULL

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_IMG_DATA_NULL = unchecked((Int32)0x80190210)

图像数据存储地址为空(某个分量)

◆ MV_FG_ERR_IMG_ABILITY_ARG

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_IMG_ABILITY_ARG = unchecked((Int32)0x80190211)

图像算法ABILITY存在无效参数

◆ MV_FG_ERR_IMG_UNKNOW

const Int32 MvFGCtrlC.NET.CErrorCode.MV_FG_ERR_IMG_UNKNOW = unchecked((Int32)0x801902FF)

图像处理未知错误


  • MvFGCtrlC
  • NET
  • CErrorCode
MvFGCtrlC.NET.CErrorCode 成员列表

成员的完整列表，这些成员属于 MvFGCtrlC.NET.CErrorCode,包括所有继承而来的类成员

MV_FG_ERR_ABORT | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_ACCESS_DENIED | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_BUFFER_TOO_SMALL | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_BUSY | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_CALLORDER | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_ERROR | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_GC_ACCESS | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_GC_ARGUMENT | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_GC_DYNAMICCAST | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_GC_GENERIC | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_GC_LOGICAL | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_GC_PROPERTY | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_GC_RANGE | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_GC_RUNTIME | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_GC_TIMEOUT | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_GC_UNKNOW | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_IMG_ABILITY_ARG | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_IMG_DATA_NULL | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_IMG_ENCRYPT | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_IMG_FORMAT | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_IMG_HANDLE | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_IMG_INITIALIZED | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_IMG_OVERFLOW | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_IMG_PARAMETER | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_IMG_RESOURCE | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_IMG_SIZE | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_IMG_STEP | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_IMG_SUPPORT | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_IMG_UNKNOW | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_INVALID_ADDRESS | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_INVALID_BUFFER | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_INVALID_HANDLE | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_INVALID_ID | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_INVALID_INDEX | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_INVALID_PARAMETER | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_INVALID_VALUE | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_IO | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_LOADLIBRARY | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_NO_DATA | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_NOT_AVAILABLE | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_NOT_IMPLEMENTED | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_NOT_INITIALIZED | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_OUT_OF_MEMORY | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_PARSING_CHUNK_DATA | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_RESOURCE_EXHAUSTED | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_RESOURCE_IN_USE | MvFGCtrlC.NET.CErrorCode
MV_FG_ERR_TIMEOUT | MvFGCtrlC.NET.CErrorCode
MV_FG_SUCCESS | MvFGCtrlC.NET.CErrorCode


  • 01 枚举模块
01 枚举模块 目录参考

文件

文件 CSystem.cs


  • 07 缓存模块
07 缓存模块 目录参考

文件

文件 CBuffer.cs


  • 02 采集卡模块
02 采集卡模块 目录参考

文件

文件 CInterface.cs


  • 06 图像处理模块
06 图像处理模块 目录参考

文件

文件 CImageProcess.cs


  • 03 设备控制模块
03 设备控制模块 目录参考

文件

文件 CDevice.cs


  • 05 参数模块
05 参数模块 目录参考

文件

文件 CParam.cs


  • 09 回调模块
09 回调模块 目录参考

文件

文件 CCallback.cs


  • 04 流控制
04 流控制 目录参考

文件

文件 CStream.cs


  • 08 附加模块
08 附加模块 目录参考

文件

文件 CAdditional.cs


命名空间
MvFGCtrlC 命名空间参考

命名空间

namespace NET


  • MvFGCtrlC
  • NET
类
MvFGCtrlC.NET 命名空间参考

类

class CErrorCode
错误码定义类 更多...