AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Baumer工业相机堡盟相机如何使用JPEG图像压缩功能（LXT.JP系列相机图像压缩功能的使用和优点以及行业应用）（C#）

2023-08-10 92
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
数据传输服务 DTS，数据迁移 small 3个月
推荐场景：
MySQL数据库上云
数据传输服务 DTS，数据同步 small 3个月
推荐场景：
数据库上云
数据传输服务 DTS，数据同步 1个月
简介： Baumer工业相机堡盟相机如何使用JPEG图像压缩功能（LXT.JP系列相机图像压缩功能的使用和优点以及行业应用）（C#）

项目场景

Baumer工业相机堡盟相机是一种高性能、高质量的工业相机，可用于各种应用场景，如物体检测、计数和识别、运动分析和图像处理。  


Baumer的万兆网相机拥有出色的图像处理性能，可以实时传输高分辨率图像。此外，该相机还具有快速数据传输、低功耗、易于集成以及高度可扩展性等特点。  


Baumer万兆网相机中LXT.JP图像压缩系列相机是一种预处理相机，在相机内部对图像进行JPEG算法压缩然后再传输到处理器中。

技术背景

Baumer工业相机的JPEG图像压缩功能有助于减少图像文件的大小，同时保持图像质量，同时它是一种有损压缩。这种压缩功能是基于JPEG（联合摄影专家组）压缩标准，该标准被广泛用于数字摄影和图像编辑。


具有JPEG压缩功能的工业相机可以捕捉高分辨率的图像，并将其压缩成较小的文件，从而使图像的存储、传输和处理更加容易。压缩水平和质量可以根据用户的具体需求进行调整。


在工业相机中使用JPEG压缩的一个优点是，它可以帮助减少数据传输时间，这在需要高速图像处理的机器视觉应用中特别重要。此外，较小的文件大小允许更有效地存储和检索图像，这在工业环境中可以节省时间和金钱。


总的来说，JPEG图像压缩功能是工业相机的一个重要功能，有助于提高高分辨率图像的效率、存储和处理。

5.png

4.png

代码分析

Baumer工业相机堡盟相机SDK示例中022_JPEGCapture.cs详细介绍了如何配置相机偏振功能。


软件SDK示例地址如下所示：Baumer_GAPI_SDK_2.12.0_win_x86_64_cs\examples\src\0_Common\022_JPEGCapture\022_JPEGCapture.cs


3.png


本例描述了对堡盟JPEG相机的处理。给出的源代码适用于处理一个系统、一台相机和十幅图像。


代码整体结构相对简单，在相机初始化后进行工业相机的JPEG图像压缩功能使用，部分核心代码如下：

/*
    This example describes the the handling of Baumer JPEG cameras.
    The given source code applies to handling one system, one camera and ten images.
    Please see "Baumer-GAPI SDK Programmer's Guide" chapter 5.1 and chapter 5.2
*/
// ###############################
// Baumer JPEG Capture Example
// -------------------------------
// - the following description includes these tags: JPEGTAGxx, which are makers for the relevant code snippets
// -------------------------------
// - the example shows the work flow for Baumer JPEG cameras --> JPEGTAG01
// - How does the camera work?
//  o the camera is capable to stream compressed image when setting 'ImageCompressionMode' to 'JPEG'
//  o JPEG compression is only possible for Mono8 and YCbCr pixel formats
//  o the size of the image buffer is set to the uncompressed payload size of the full frame image
//    (same like a camera without image compression support), because the size of compressed image data
//    are always smaller
// - How to implement?
//  o set the feature 'PixelFormat' of the camera to 'Mono8' or 'YCbCr' --> JPEGTAG02
//  o set the feature 'ImageCompressionMode' to the value 'JPEG' to switch on image compression --> JPEGTAG03
//  o this example use internal allocated image buffers that use the maximum payload size of the camera --> JPEGTAG04
//  o use function Buffer::GetImageLength to directly save the buffer
//    as JPEG into the current working directory --> JPEGTAG05
//  o restore JPEG setting --> JPEGTAG06
// ###############################
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
namespace _022_JPEGCapture
{
  class Program
  {
    const string kImageCompressionMode = "ImageCompressionMode";
    const string kImageCompressionModeJPEG = "JPEG";
    static int Main(string[] args)
    {
      //DECLARATIONS OF VARIABLES
      BGAPI2.SystemList systemList = null;
      BGAPI2.System mSystem = null;
      string sSystemID = "";
      BGAPI2.InterfaceList interfaceList = null;
      BGAPI2.Interface mInterface = null;
      string sInterfaceID = "";
      BGAPI2.DeviceList deviceList = null;
      BGAPI2.Device mDevice = null;
      string sDeviceID = "";
      BGAPI2.DataStreamList datastreamList = null;
      BGAPI2.DataStream mDataStream = null;
      string sDataStreamID = "";
      BGAPI2.BufferList bufferList = null;
      BGAPI2.Buffer mBuffer = null;
      int returnCode = 0;
      bool jpeg_streaming_capable = false;
      bool unsafe_code_allowed = true;
      System.Console.Write("\r\n");
      System.Console.Write("#################################################\r\n");
      System.Console.Write("# PROGRAMMER'S GUIDE Example 022_JPEGCapture.cs #\r\n");
      System.Console.Write("#################################################\r\n");
      System.Console.Write("\r\n\r\n");
      System.Console.Write("SYSTEM LIST\r\n");
      System.Console.Write("###########\r\n\r\n");
      //COUNTING AVAILABLE SYSTEMS (TL producers)
      try
      {
        systemList = BGAPI2.SystemList.Instance;
        systemList.Refresh();
        System.Console.Write("5.1.2   Detected systems:  {0}\r\n", systemList.Count);
        //SYSTEM DEVICE INFORMATION
        foreach (KeyValuePair<string, BGAPI2.System> sys_pair in BGAPI2.SystemList.Instance)
        {
          System.Console.Write("  5.2.1   System Name:     {0}\r\n", sys_pair.Value.FileName);
          System.Console.Write("          System Type:     {0}\r\n", sys_pair.Value.TLType);
          System.Console.Write("          System Version:  {0}\r\n", sys_pair.Value.Version);
          System.Console.Write("          System PathName: {0}\r\n\r\n", sys_pair.Value.PathName);
        }
      }
      catch (BGAPI2.Exceptions.IException ex)
      {
        returnCode = (0 == returnCode) ? 1 : returnCode;
        System.Console.Write("ExceptionType:    {0} \r\n", ex.GetType());
        System.Console.Write("ErrorDescription: {0} \r\n", ex.GetErrorDescription());
        System.Console.Write("in function:      {0} \r\n", ex.GetFunctionName());
      }
      //OPEN THE FIRST SYSTEM IN THE LIST WITH A CAMERA CONNECTED
      try
      {
        foreach (KeyValuePair<string, BGAPI2.System> sys_pair in BGAPI2.SystemList.Instance)
        {
          System.Console.Write("SYSTEM\r\n");
          System.Console.Write("######\r\n\r\n");
          try
          {
            sys_pair.Value.Open();
            System.Console.Write("5.1.3   Open next system \r\n");
            System.Console.Write("  5.2.1   System Name:     {0}\r\n", sys_pair.Value.FileName);
            System.Console.Write("          System Type:     {0}\r\n", sys_pair.Value.TLType);
            System.Console.Write("          System Version:  {0}\r\n", sys_pair.Value.Version);
            System.Console.Write("          System PathName: {0}\r\n\r\n", sys_pair.Value.PathName);
            sSystemID = sys_pair.Key;
            System.Console.Write("        Opened system - NodeList Information \r\n");
            System.Console.Write("          GenTL Version:   {0}.{1}\r\n\r\n", (long)sys_pair.Value.NodeList["GenTLVersionMajor"].Value, (long)sys_pair.Value.NodeList["GenTLVersionMinor"].Value);
            System.Console.Write("INTERFACE LIST\r\n");
            System.Console.Write("##############\r\n\r\n");
            try
            {
              interfaceList = sys_pair.Value.Interfaces;
              //COUNT AVAILABLE INTERFACES
              interfaceList.Refresh(100); // timeout of 100 msec
              System.Console.Write("5.1.4   Detected interfaces: {0}\r\n", interfaceList.Count);
              //INTERFACE INFORMATION
              foreach (KeyValuePair<string, BGAPI2.Interface> ifc_pair in interfaceList)
              {
                System.Console.Write("  5.2.2   Interface ID:      {0}\r\n", ifc_pair.Value.Id);
                System.Console.Write("          Interface Type:    {0}\r\n", ifc_pair.Value.TLType);
                System.Console.Write("          Interface Name:    {0}\r\n\r\n", ifc_pair.Value.DisplayName);
              }
            }
            catch (BGAPI2.Exceptions.IException ex)
            {
              returnCode = (0 == returnCode) ? 1 : returnCode;
              System.Console.Write("ExceptionType:    {0} \r\n", ex.GetType());
              System.Console.Write("ErrorDescription: {0} \r\n", ex.GetErrorDescription());
              System.Console.Write("in function:      {0} \r\n", ex.GetFunctionName());
            }
            System.Console.Write("INTERFACE\r\n");
            System.Console.Write("#########\r\n\r\n");
            //OPEN THE NEXT INTERFACE IN THE LIST
            try
            {
              foreach (KeyValuePair<string, BGAPI2.Interface> ifc_pair in interfaceList)
              {
                try
                {
                  System.Console.Write("5.1.5   Open interface \r\n");
                  System.Console.Write("  5.2.2   Interface ID:      {0}\r\n", ifc_pair.Key);
                  System.Console.Write("          Interface Type:    {0}\r\n", ifc_pair.Value.TLType);
                  System.Console.Write("          Interface Name:    {0}\r\n", ifc_pair.Value.DisplayName);
                  ifc_pair.Value.Open();
                  //search for any camera is connected to this interface
                  deviceList = ifc_pair.Value.Devices;
                  deviceList.Refresh(100);
                  if (deviceList.Count == 0)
                  {
                    System.Console.Write("5.1.13   Close interface ({0} cameras found) \r\n\r\n", deviceList.Count);
                    ifc_pair.Value.Close();
                  }
                  else
                  {
                    sInterfaceID = ifc_pair.Key;
                    System.Console.Write("  \r\n");
                    System.Console.Write("        Opened interface - NodeList Information \r\n");
                    if (ifc_pair.Value.TLType == "GEV")
                    {
                      long iIPAddress = (long)ifc_pair.Value.NodeList["GevInterfaceSubnetIPAddress"].Value;
                      System.Console.Write("          GevInterfaceSubnetIPAddress: {0}.{1}.{2}.{3}\r\n", (iIPAddress & 0xff000000) >> 24,
                                                                                                      (iIPAddress & 0x00ff0000) >> 16,
                                                                                                      (iIPAddress & 0x0000ff00) >> 8,
                                                                                                      (iIPAddress & 0x000000ff));
                      long iSubnetMask = (long)ifc_pair.Value.NodeList["GevInterfaceSubnetMask"].Value;
                      System.Console.Write("          GevInterfaceSubnetMask:      {0}.{1}.{2}.{3}\r\n", (iSubnetMask & 0xff000000) >> 24,
                                                                                                      (iSubnetMask & 0x00ff0000) >> 16,
                                                                                                      (iSubnetMask & 0x0000ff00) >> 8,
                                                                                                      (iSubnetMask & 0x000000ff));
                    }
                    System.Console.Write("  \r\n");
                    break;
                  }
                }
                catch (BGAPI2.Exceptions.ResourceInUseException ex)
                {
                  returnCode = (0 == returnCode) ? 1 : returnCode;
                  System.Console.Write(" Interface {0} already opened \r\n", ifc_pair.Key);
                  System.Console.Write(" ResourceInUseException {0} \r\n", ex.GetErrorDescription());
                }
              }
            }
            catch (BGAPI2.Exceptions.IException ex)
            {
              returnCode = (0 == returnCode) ? 1 : returnCode;
              System.Console.Write("ExceptionType:    {0} \r\n", ex.GetType());
              System.Console.Write("ErrorDescription: {0} \r\n", ex.GetErrorDescription());
              System.Console.Write("in function:      {0} \r\n", ex.GetFunctionName());
            }
            //if a camera is connected to the system interface then leave the system loop
            if (sInterfaceID != "")
            {
              break;
            }
          }
          catch (BGAPI2.Exceptions.ResourceInUseException ex)
          {
            returnCode = (0 == returnCode) ? 1 : returnCode;
            System.Console.Write(" System {0} already opened \r\n", sys_pair.Key);
            System.Console.Write(" ResourceInUseException {0} \r\n", ex.GetErrorDescription());
          }
        }
      }
      catch (BGAPI2.Exceptions.IException ex)
      {
        returnCode = (0 == returnCode) ? 1 : returnCode;
        System.Console.Write("ExceptionType:    {0} \r\n", ex.GetType());
        System.Console.Write("ErrorDescription: {0} \r\n", ex.GetErrorDescription());
        System.Console.Write("in function:      {0} \r\n", ex.GetFunctionName());
      }
      if (sSystemID == "")
      {
        System.Console.Write(" No System found \r\n");
        System.Console.Write(" Input any number to close the program:\r\n");
        Console.Read();
        return returnCode;
      }
      else
      {
        mSystem = systemList[sSystemID];
      }
      if (sInterfaceID == "")
      {
        System.Console.Write(" No Interface of TLType 'GEV' found \r\n");
        System.Console.Write("\r\nEnd\r\nInput any number to close the program:\r\n");
        Console.Read();
        mSystem.Close();
        return returnCode;
      }
      else
      {
        mInterface = interfaceList[sInterfaceID];
      }
      System.Console.Write("DEVICE LIST\r\n");
      System.Console.Write("###########\r\n\r\n");
      try
      {
        //COUNTING AVAILABLE CAMERAS
        deviceList = mInterface.Devices;
        deviceList.Refresh(100);
        System.Console.Write("5.1.6   Detected devices:         {0}\r\n", deviceList.Count);
        //DEVICE INFORMATION BEFORE OPENING
        foreach (KeyValuePair<string, BGAPI2.Device> dev_pair in deviceList)
        {
          System.Console.Write("  5.2.3   Device DeviceID:        {0}\r\n", dev_pair.Key);
          System.Console.Write("          Device Model:           {0}\r\n", dev_pair.Value.Model);
          System.Console.Write("          Device SerialNumber:    {0}\r\n", dev_pair.Value.SerialNumber);
          System.Console.Write("          Device Vendor:          {0}\r\n", dev_pair.Value.Vendor);
          System.Console.Write("          Device TLType:          {0}\r\n", dev_pair.Value.TLType);
          System.Console.Write("          Device AccessStatus:    {0}\r\n", dev_pair.Value.AccessStatus);
          System.Console.Write("          Device UserID:          {0}\r\n\r\n", dev_pair.Value.DisplayName);
        }
      }
      catch (BGAPI2.Exceptions.IException ex)
      {
        returnCode = (0 == returnCode) ? 1 : returnCode;
        System.Console.Write("ExceptionType:    {0} \r\n", ex.GetType());
        System.Console.Write("ErrorDescription: {0} \r\n", ex.GetErrorDescription());
        System.Console.Write("in function:      {0} \r\n", ex.GetFunctionName());
      }
      System.Console.Write("DEVICE\r\n");
      System.Console.Write("######\r\n\r\n");
      //OPEN THE FIRST CAMERA IN THE LIST
      try
      {
        foreach (KeyValuePair<string, BGAPI2.Device> dev_pair in deviceList)
        {
          try
          {
            System.Console.Write("5.1.7   Open first device \r\n");
            System.Console.Write("          Device DeviceID:        {0}\r\n", dev_pair.Value.Id);
            System.Console.Write("          Device Model:           {0}\r\n", dev_pair.Value.Model);
            System.Console.Write("          Device SerialNumber:    {0}\r\n", dev_pair.Value.SerialNumber);
            System.Console.Write("          Device Vendor:          {0}\r\n", dev_pair.Value.Vendor);
            System.Console.Write("          Device TLType:          {0}\r\n", dev_pair.Value.TLType);
            System.Console.Write("          Device AccessStatus:    {0}\r\n", dev_pair.Value.AccessStatus);
            System.Console.Write("          Device UserID:          {0}\r\n\r\n", dev_pair.Value.DisplayName);
            dev_pair.Value.Open();
            sDeviceID = dev_pair.Key;
            System.Console.Write("        Opened device - RemoteNodeList Information \r\n");
            System.Console.Write("          Device AccessStatus:    {0}\r\n", dev_pair.Value.AccessStatus);
            //SERIAL NUMBER
            if (dev_pair.Value.RemoteNodeList.GetNodePresent("DeviceSerialNumber") == true)
              System.Console.Write("          DeviceSerialNumber:     {0}\r\n", (string)dev_pair.Value.RemoteNodeList["DeviceSerialNumber"].Value);
            else if (dev_pair.Value.RemoteNodeList.GetNodePresent("DeviceID") == true)
              System.Console.Write("          DeviceID (SN):          {0}\r\n", (string)dev_pair.Value.RemoteNodeList["DeviceID"].Value);
            else
              System.Console.Write("          SerialNumber:           Not Available.\r\n");
            //DISPLAY DEVICEMANUFACTURERINFO
            if (dev_pair.Value.RemoteNodeList.GetNodePresent("DeviceManufacturerInfo") == true)
              System.Console.Write("          DeviceManufacturerInfo: {0}\r\n", (string)dev_pair.Value.RemoteNodeList["DeviceManufacturerInfo"].Value);
            //DISPLAY DEVICEFIRMWAREVERSION OR DEVICEVERSION
            if (dev_pair.Value.RemoteNodeList.GetNodePresent("DeviceFirmwareVersion") == true)
              System.Console.Write("          DeviceFirmwareVersion:  {0}\r\n", (string)dev_pair.Value.RemoteNodeList["DeviceFirmwareVersion"].Value);
            else if (dev_pair.Value.RemoteNodeList.GetNodePresent("DeviceVersion") == true)
              System.Console.Write("          DeviceVersion:          {0}\r\n", (string)dev_pair.Value.RemoteNodeList["DeviceVersion"].Value);
            else
              System.Console.Write("          DeviceVersion:          Not Available.\r\n");
            if (dev_pair.Value.TLType == "GEV")
            {
              System.Console.Write("          GevCCP:                 {0}\r\n", (string)dev_pair.Value.RemoteNodeList["GevCCP"].Value);
              System.Console.Write("          GevCurrentIPAddress:    {0}.{1}.{2}.{3}\r\n", ((long)dev_pair.Value.RemoteNodeList["GevCurrentIPAddress"].Value & 0xff000000) >> 24, ((long)dev_pair.Value.RemoteNodeList["GevCurrentIPAddress"].Value & 0x00ff0000) >> 16, ((long)dev_pair.Value.RemoteNodeList["GevCurrentIPAddress"].Value & 0x0000ff00) >> 8, ((long)dev_pair.Value.RemoteNodeList["GevCurrentIPAddress"].Value & 0x000000ff));
              System.Console.Write("          GevCurrentSubnetMask:   {0}.{1}.{2}.{3}\r\n", ((long)dev_pair.Value.RemoteNodeList["GevCurrentSubnetMask"].Value & 0xff000000) >> 24, ((long)dev_pair.Value.RemoteNodeList["GevCurrentSubnetMask"].Value & 0x00ff0000) >> 16, ((long)dev_pair.Value.RemoteNodeList["GevCurrentSubnetMask"].Value & 0x0000ff00) >> 8, ((long)dev_pair.Value.RemoteNodeList["GevCurrentSubnetMask"].Value & 0x000000ff));
            }
            System.Console.Write("          \r\n");
            break;
          }
          catch (BGAPI2.Exceptions.ResourceInUseException ex)
          {
            returnCode = (0 == returnCode) ? 1 : returnCode;
            System.Console.Write(" Device {0} already opened \r\n", dev_pair.Key);
            System.Console.Write(" ResourceInUseException {0} \r\n", ex.GetErrorDescription());
          }
          catch (BGAPI2.Exceptions.AccessDeniedException ex)
          {
            returnCode = (0 == returnCode) ? 1 : returnCode;
            System.Console.Write(" Device {0} already opened \r\n", dev_pair.Key);
            System.Console.Write(" AccessDeniedException {0} \r\n", ex.GetErrorDescription());
          }
        }
      }
      catch (BGAPI2.Exceptions.IException ex)
      {
        returnCode = (0 == returnCode) ? 1 : returnCode;
        System.Console.Write("ExceptionType:    {0} \r\n", ex.GetType());
        System.Console.Write("ErrorDescription: {0} \r\n", ex.GetErrorDescription());
        System.Console.Write("in function:      {0} \r\n", ex.GetFunctionName());
      }
      if (sDeviceID == "")
      {
        System.Console.Write(" No Device found \r\n");
        System.Console.Write("\r\nEnd\r\nInput any number to close the program:\r\n");
        Console.Read();
        mInterface.Close();
        mSystem.Close();
        return returnCode;
      }
      else
      {
        mDevice = deviceList[sDeviceID];
      }
      System.Console.Write("DEVICE PARAMETER SETUP\r\n");
      System.Console.Write("######################\r\n\r\n");
      try
      {
        //SET TRIGGER MODE OFF (FreeRun)
        mDevice.RemoteNodeList["TriggerMode"].Value = "Off";
        System.Console.Write("         TriggerMode:             {0}\r\n", (string)mDevice.RemoteNodeList["TriggerMode"].Value);
        System.Console.Write("  \r\n");
        // JPEGTAG01 (see description on top)
        // check for JPEG capable camera
        if (mDevice.RemoteNodeList.GetNodePresent(kImageCompressionMode))
        {
          BGAPI2.NodeMap image_compression_map = mDevice.RemoteNodeList[kImageCompressionMode].EnumNodeList;
          if (image_compression_map.GetNodePresent(kImageCompressionModeJPEG))
          {
            jpeg_streaming_capable = true;
            System.Console.Write("         JPEG Supported:          Yes\r\n");
          }
          else
          {
            System.Console.Write("         JPEG Supported:          No, Feature '{0}' has no element {1}\r\n",
              kImageCompressionMode, kImageCompressionModeJPEG);
          }
        }
        else
        {
          System.Console.Write("         JPEG Supported:          Feature '{0}' not found.\r\n", kImageCompressionMode);
        }
        if (jpeg_streaming_capable) {
            // JPEGTAG02 (see description on top)
            // AND SET PIXELFORMAT (Mono8, YCbCr) IF AVAILABLE
            BGAPI2.NodeMap pixel_format_enum_map = mDevice.RemoteNodeList["PixelFormat"].EnumNodeList;
            string pixel_format = "YCbCr422_8";
            if (!pixel_format_enum_map.GetNodePresent(pixel_format) ||
               (pixel_format_enum_map.GetNodePresent(pixel_format) && !pixel_format_enum_map[pixel_format].IsReadable)) {
               pixel_format = "Mono8";
               if (!pixel_format_enum_map.GetNodePresent(pixel_format) ||
                 (pixel_format_enum_map.GetNodePresent(pixel_format) && !pixel_format_enum_map[pixel_format].IsReadable)) {
                 pixel_format = "";
               }
            }
            if ((pixel_format != "") && mDevice.RemoteNodeList["PixelFormat"].IsWriteable) {
              mDevice.RemoteNodeList["PixelFormat"].Value = pixel_format;
              System.Console.Write("         PixelFormat:             {0}\r\n",
                mDevice.RemoteNodeList["PixelFormat"].Value);
              // JPEGTAG03 (see description on top)
              // set the compression mode to JPEG
              mDevice.RemoteNodeList[kImageCompressionMode].Value = "JPEG";
            } else {
              System.Console.Write("         PixelFormat:             {0} (set to Mono8/YCbCr failed, not supported or no write accees)\r\n",
                mDevice.RemoteNodeList["PixelFormat"].Value);
            }
        }
      }
      catch (BGAPI2.Exceptions.IException ex)
      {
        returnCode = (0 == returnCode) ? 1 : returnCode;
        System.Console.Write("ExceptionType:    {0} \r\n", ex.GetType());
        System.Console.Write("ErrorDescription: {0} \r\n", ex.GetErrorDescription());
        System.Console.Write("in function:      {0} \r\n", ex.GetFunctionName());
      }
      System.Console.Write("DATA STREAM LIST\r\n");
      System.Console.Write("################\r\n\r\n");
      try
      {
        //COUNTING AVAILABLE DATASTREAMS
        datastreamList = mDevice.DataStreams;
        datastreamList.Refresh();
        System.Console.Write("5.1.8   Detected datastreams:     {0}\r\n", datastreamList.Count);
        //DATASTREAM INFORMATION BEFORE OPENING
        foreach (KeyValuePair<string, BGAPI2.DataStream> dst_pair in datastreamList)
        {
          System.Console.Write("  5.2.4   DataStream ID:          {0}\r\n\r\n", dst_pair.Key);
        }
      }
      catch (BGAPI2.Exceptions.IException ex)
      {
        returnCode = (0 == returnCode) ? 1 : returnCode;
        System.Console.Write("ExceptionType:    {0} \r\n", ex.GetType());
        System.Console.Write("ErrorDescription: {0} \r\n", ex.GetErrorDescription());
        System.Console.Write("in function:      {0} \r\n", ex.GetFunctionName());
      }
      System.Console.Write("DATA STREAM\r\n");
      System.Console.Write("###########\r\n\r\n");
      //OPEN THE FIRST DATASTREAM IN THE LIST
      try
      {
        foreach (KeyValuePair<string, BGAPI2.DataStream> dst_pair in datastreamList)
        {
          System.Console.Write("5.1.9   Open first datastream\r\n");
          System.Console.Write("          DataStream ID:          {0}\r\n\r\n", dst_pair.Key);
          dst_pair.Value.Open();
          sDataStreamID = dst_pair.Key;
          System.Console.Write("        Opened datastream - NodeList Information \r\n");
          System.Console.Write("          StreamAnnounceBufferMinimum:  {0}\r\n", dst_pair.Value.NodeList["StreamAnnounceBufferMinimum"].Value);
          if (dst_pair.Value.TLType == "GEV")
          {
            System.Console.Write("          StreamDriverModel:            {0}\r\n", dst_pair.Value.NodeList["StreamDriverModel"].Value);
          }
          System.Console.Write("  \r\n");
          break;
        }
      }
      catch (BGAPI2.Exceptions.IException ex)
      {
        returnCode = (0 == returnCode) ? 1 : returnCode;
        System.Console.Write("ExceptionType:    {0} \r\n", ex.GetType());
        System.Console.Write("ErrorDescription: {0} \r\n", ex.GetErrorDescription());
        System.Console.Write("in function:      {0} \r\n", ex.GetFunctionName());
      }
      if (sDataStreamID == "")
      {
        System.Console.Write(" No DataStream found \r\n");
        System.Console.Write("\r\nEnd\r\nInput any number to close the program:\r\n");
        Console.Read();
        mDevice.Close();
        mInterface.Close();
        mSystem.Close();
        return returnCode;
      }
      else
      {
        mDataStream = datastreamList[sDataStreamID];
      }
      System.Console.Write("BUFFER LIST\r\n");
      System.Console.Write("###########\r\n\r\n");
      try
      {
        //BufferList
        bufferList = mDataStream.BufferList;
        // 4 buffers using internal buffer mode
        for (int i = 0; i < 4; i++)
        {
          // JPEGTAG04 (see description on top)
          // create image buffers with the maximum payload size
          mBuffer = new BGAPI2.Buffer();
          bufferList.Add(mBuffer);
        }
        System.Console.Write("5.1.10   Announced buffers:       {0} using {1} [bytes]\r\n", bufferList.AnnouncedCount, mBuffer.MemSize * bufferList.AnnouncedCount);
      }
      catch (BGAPI2.Exceptions.IException ex)
      {
        returnCode = (0 == returnCode) ? 1 : returnCode;
        System.Console.Write("ExceptionType:    {0} \r\n", ex.GetType());
        System.Console.Write("ErrorDescription: {0} \r\n", ex.GetErrorDescription());
        System.Console.Write("in function:      {0} \r\n", ex.GetFunctionName());
      }
      try
      {
        foreach (KeyValuePair<string, BGAPI2.Buffer> buf_pair in bufferList)
        {
          buf_pair.Value.QueueBuffer();
        }
        System.Console.Write("5.1.11   Queued buffers:          {0}\r\n", bufferList.QueuedCount);
      }
      catch (BGAPI2.Exceptions.IException ex)
      {
        returnCode = (0 == returnCode) ? 1 : returnCode;
        System.Console.Write("ExceptionType:    {0} \r\n", ex.GetType());
        System.Console.Write("ErrorDescription: {0} \r\n", ex.GetErrorDescription());
        System.Console.Write("in function:      {0} \r\n", ex.GetFunctionName());
      }
      System.Console.Write("\r\n");
      System.Console.Write("CAMERA START\r\n");
      System.Console.Write("############\r\n\r\n");
      //START DATASTREAM ACQUISITION
      try
      {
        mDataStream.StartAcquisition();
        System.Console.Write("5.1.12   DataStream started \r\n");
      }
      catch (BGAPI2.Exceptions.IException ex)
      {
        returnCode = (0 == returnCode) ? 1 : returnCode;
        System.Console.Write("ExceptionType:    {0} \r\n", ex.GetType());
        System.Console.Write("ErrorDescription: {0} \r\n", ex.GetErrorDescription());
        System.Console.Write("in function:      {0} \r\n", ex.GetFunctionName());
      }
      //START CAMERA
      try
      {
        mDevice.RemoteNodeList["AcquisitionStart"].Execute();
        System.Console.Write("5.1.12   {0} started \r\n", mDevice.Model);
      }
      catch (BGAPI2.Exceptions.IException ex)
      {
        returnCode = (0 == returnCode) ? 1 : returnCode;
        System.Console.Write("ExceptionType:    {0} \r\n", ex.GetType());
        System.Console.Write("ErrorDescription: {0} \r\n", ex.GetErrorDescription());
        System.Console.Write("in function:      {0} \r\n", ex.GetFunctionName());
      }
      //CAPTURE 12 IMAGES
      System.Console.Write("\r\n");
      System.Console.Write("CAPTURE 12 IMAGES BY IMAGE POLLING\r\n");
      System.Console.Write("##################################\r\n\r\n");
      BGAPI2.Buffer mBufferFilled = null;
      try
      {
        for (int i = 0; i < 12; i++)
        {
          mBufferFilled = mDataStream.GetFilledBuffer(1000); // image polling timeout 1000 msec
          if (mBufferFilled == null)
          {
            System.Console.Write("Error: Buffer Timeout after 1000 msec\r\n");
          }
          else if (mBufferFilled.IsIncomplete == true)
          {
            System.Console.Write("Error: Image is incomplete\r\n");
            // queue buffer again
            mBufferFilled.QueueBuffer();
          }
          else
          {
            System.Console.Write(" Image {0, 5:d} received in memory address {1:X16}\r\n",
              mBufferFilled.FrameID, (ulong)mBufferFilled.MemPtr);
            // JPEGTAG05 (see description on top)
            // save the compressed images to disk if supported
            if (jpeg_streaming_capable)
            {
              ulong jpeg_size = mBufferFilled.ImageLength;
              if (jpeg_size > 0)
              {
                // Save jpeg data to file
                System.IO.FileStream outfile = new System.IO.FileStream(String.Format("022_JPEGCapture_{0:D6}.jpg", mBufferFilled.FrameID),
                  System.IO.FileMode.Create, System.IO.FileAccess.Write);
                if (unsafe_code_allowed)
                {
                  // Use UnmanagedMemoryStream to avoid copy form unmanaged to managed 
                  System.IO.UnmanagedMemoryStream unmanaged_stream;
                  unsafe
                  {
                    unmanaged_stream = new System.IO.UnmanagedMemoryStream((byte*)mBufferFilled.MemPtr.ToPointer() + mBufferFilled.ImageOffset,
                      (long)jpeg_size);
                  }
                  unmanaged_stream.CopyTo(outfile);
                  unmanaged_stream.Close();
                }
                else
                {
                  byte[] jpeg_data = new byte[jpeg_size];
                  Marshal.Copy(mBufferFilled.MemPtr, jpeg_data, (int)mBufferFilled.ImageOffset, (int)jpeg_data.Length);
                  outfile.Write(jpeg_data, 0, jpeg_data.Length);
                }
                outfile.Close();
                System.Console.Write("JPEG Data found. Image saved as JPEG file.\r\n");
              }
              else
              {
                System.Console.Write("JPEG Data not found in image buffer. No JPEG Saved.\r\n");
              }
            }
            // queue buffer again
            mBufferFilled.QueueBuffer();
          }
        }
      }
      catch (BGAPI2.Exceptions.IException ex)
      {
        returnCode = (0 == returnCode) ? 1 : returnCode;
        System.Console.Write("ExceptionType:    {0} \r\n", ex.GetType());
        System.Console.Write("ErrorDescription: {0} \r\n", ex.GetErrorDescription());
        System.Console.Write("in function:      {0} \r\n", ex.GetFunctionName());
      }
      System.Console.Write("\r\n");
      System.Console.Write("CAMERA STOP\r\n");
      System.Console.Write("###########\r\n\r\n");
      //STOP CAMERA
      try
      {
        if (mDevice.RemoteNodeList.GetNodePresent("AcquisitionAbort") == true)
        {
          mDevice.RemoteNodeList["AcquisitionAbort"].Execute();
          System.Console.Write("5.1.12   {0} aborted\r\n", mDevice.Model);
        }
        mDevice.RemoteNodeList["AcquisitionStop"].Execute();
        System.Console.Write("5.1.12   {0} stopped \r\n", mDevice.Model);
        System.Console.Write("\r\n");
        String sExposureNodeName = "";
        if (mDevice.GetRemoteNodeList().GetNodePresent("ExposureTime"))
        {
            sExposureNodeName = "ExposureTime";
        }
        else if (mDevice.GetRemoteNodeList().GetNodePresent("ExposureTimeAbs"))
        {
            sExposureNodeName = "ExposureTimeAbs";
        }
        System.Console.Write("         ExposureTime:                   {0} [{1}]\r\n", (double)mDevice.RemoteNodeList[sExposureNodeName].Value, (string)mDevice.RemoteNodeList[sExposureNodeName].Unit);
        if (mDevice.TLType == "GEV")
        {
          if (mDevice.RemoteNodeList.GetNodePresent("DeviceStreamChannelPacketSize") == true)
            System.Console.Write("         DeviceStreamChannelPacketSize:  {0} [bytes]\r\n", (long)mDevice.RemoteNodeList["DeviceStreamChannelPacketSize"].Value);
          else
            System.Console.Write("         GevSCPSPacketSize:              {0} [bytes]\r\n", (long)mDevice.RemoteNodeList["GevSCPSPacketSize"].Value);
          System.Console.Write("         GevSCPD (PacketDelay):          {0} [tics]\r\n", (long)mDevice.RemoteNodeList["GevSCPD"].Value);
        }
        System.Console.Write("\r\n");
      }
      catch (BGAPI2.Exceptions.IException ex)
      {
        returnCode = (0 == returnCode) ? 1 : returnCode;
        System.Console.Write("ExceptionType:    {0} \r\n", ex.GetType());
        System.Console.Write("ErrorDescription: {0} \r\n", ex.GetErrorDescription());
        System.Console.Write("in function:      {0} \r\n", ex.GetFunctionName());
      }
      //STOP DataStream acquisition & release buffers
      try
      {
          if (mDataStream.TLType == "GEV")
          {
              //DataStream Statistics
              System.Console.Write("         DataStream Statistics \r\n");
              System.Console.Write("           DataBlockComplete:              {0}\r\n", (long)mDataStream.NodeList["DataBlockComplete"].Value);
              System.Console.Write("           DataBlockInComplete:            {0}\r\n", (long)mDataStream.NodeList["DataBlockInComplete"].Value);
              System.Console.Write("           DataBlockMissing:               {0}\r\n", (long)mDataStream.NodeList["DataBlockMissing"].Value);
              System.Console.Write("           PacketResendRequestSingle:      {0}\r\n", (long)mDataStream.NodeList["PacketResendRequestSingle"].Value);
              System.Console.Write("           PacketResendRequestRange:       {0}\r\n", (long)mDataStream.NodeList["PacketResendRequestRange"].Value);
              System.Console.Write("           PacketResendReceive:            {0}\r\n", (long)mDataStream.NodeList["PacketResendReceive"].Value);
              System.Console.Write("           DataBlockDroppedBufferUnderrun: {0}\r\n", (long)mDataStream.NodeList["DataBlockDroppedBufferUnderrun"].Value);
              System.Console.Write("           Bitrate:                        {0}\r\n", (double)mDataStream.NodeList["Bitrate"].Value);
              System.Console.Write("           Throughput:                     {0}\r\n", (double)mDataStream.NodeList["Throughput"].Value);
              System.Console.Write("\r\n");
          }
        if (mDataStream.TLType == "U3V")
        {
          //DataStream Statistics
          System.Console.Write("         DataStream Statistics \r\n");
          System.Console.Write("           GoodFrames:            {0}\r\n", (long)mDataStream.NodeList["GoodFrames"].Value);
          System.Console.Write("           CorruptedFrames:       {0}\r\n", (long)mDataStream.NodeList["CorruptedFrames"].Value);
          System.Console.Write("           LostFrames:            {0}\r\n", (long)mDataStream.NodeList["LostFrames"].Value);
          System.Console.Write("\r\n");
        }
        //BufferList Information
        System.Console.Write("         BufferList Information \r\n");
        System.Console.Write("           DeliveredCount:        {0}\r\n", (long)bufferList.DeliveredCount);
        System.Console.Write("           UnderrunCount:         {0}\r\n", (long)bufferList.UnderrunCount);
        System.Console.Write("\r\n");
        mDataStream.StopAcquisition();
        System.Console.Write("5.1.12   DataStream stopped \r\n");
        bufferList.DiscardAllBuffers();
      }
      catch (BGAPI2.Exceptions.IException ex)
      {
        returnCode = (0 == returnCode) ? 1 : returnCode;
        System.Console.Write("ExceptionType:    {0} \r\n", ex.GetType());
        System.Console.Write("ErrorDescription: {0} \r\n", ex.GetErrorDescription());
        System.Console.Write("in function:      {0} \r\n", ex.GetFunctionName());
      }
      System.Console.Write("\r\n");
      // JPEGTAG06 (see description on top)
      // revert th JPEG settings if they was enabled
      if (jpeg_streaming_capable) {
        // ENABLE IMAGECOMPRESSION MODE
        mDevice.RemoteNodeList[kImageCompressionMode].Value = "Off";
      }
      System.Console.Write("RELEASE\r\n");
      System.Console.Write("#######\r\n\r\n");
      //Release buffers
      System.Console.Write("5.1.13   Releasing the resources\r\n");
      try
      {
        while (bufferList.Count > 0)
        {
          mBuffer = (BGAPI2.Buffer)bufferList.Values.First();
          bufferList.RevokeBuffer(mBuffer);
        }
        System.Console.Write("         buffers after revoke:    {0}\r\n", bufferList.Count);
        mDataStream.Close();
        mDevice.Close();
        mInterface.Close();
        mSystem.Close();
      }
      catch (BGAPI2.Exceptions.IException ex)
      {
        returnCode = (0 == returnCode) ? 1 : returnCode;
        System.Console.Write("ExceptionType:    {0} \r\n", ex.GetType());
        System.Console.Write("ErrorDescription: {0} \r\n", ex.GetErrorDescription());
        System.Console.Write("in function:      {0} \r\n", ex.GetFunctionName());
      }
      System.Console.Write("\r\nEnd\r\n\r\n");
      System.Console.Write("Input any number to close the program:\r\n");
      Console.Read();
      return returnCode;
    }
  }
}

功能优势


2.png

1.JPEG功能

在好的压缩比下能够得到高质量的图片（例如 1:10)

被广泛接受的标准格式，通过MJPEG压缩得到AVI 视频成为可能

2.使处理过程变的简单

不PC软件压缩相比，降低了CPU的负载

在一台PC上可使用多台JPEG相机，有效降低成本

3.传输需要更低的带宽

在更低带宽接口上确保高分辨率和高速的数据传输

通过使用交换机支持远距离传输，有效降低成本

4.存档所需的存储空间更小

更长的存储时间，更低的存储介质成本

5.自由度更高，灵活性得以发挥

对应不同应用的需求更具有灵活性和自由度

场景应用

1.png


JPEG图像压缩技术被广泛用于工业相机的各种应用中。以下是一些场景应用。


1. 质量控制。在高分辨率相机用于质量控制的行业中，JPEG图像压缩技术可以用来压缩大尺寸的图像而不影响图像质量。这样可以更好地存储和传输图像，同时减少数据传输时间。


2. 监视。在安全行业，JPEG图像压缩技术被用来减少摄像机实时捕获的图像的大小。这允许快速传输和存储数据，从而使反应时间更快。


3.自动化。在自动化领域使用的工业相机需要高速的图像捕捉和最小的数据传输时间。JPEG图像压缩技术可用于压缩图像，促进更快的传输时间。


4. 物体识别。在需要识别物体的行业中，例如在机器人或自动驾驶汽车中，JPEG压缩技术可以用来将大的图像文件转换为较小的文件，而不会有明显的质量损失。这允许有效地处理和识别物体。


总的来说，JPEG图像压缩技术在工业相机的应用中提供了显著的好处，包括改善存储和传输时间，更快的处理，以及减少数据的使用。

文章标签：
数据传输服务
C#
开发工具
计算机视觉
机器人
自动驾驶
安全
算法
存储
关键词：
应用C#
相机堡盟图像压缩C#
baumer工业相机堡盟应用C#
堡盟应用C#
baumer工业相机功能应用C#
相关实践学习
如何在云端创建MySQL数据库
开始实验后，系统会自动创建一台自建MySQL的 源数据库 ECS 实例和一台 目标数据库 RDS。
Sqoop 企业级大数据迁移方案实战
Sqoop是一个用于在Hadoop和关系数据库服务器之间传输数据的工具。它用于从关系数据库（如MySQL，Oracle）导入数据到Hadoop HDFS，并从Hadoop文件系统导出到关系数据库。 本课程主要讲解了Sqoop的设计思想及原理、部署安装及配置、详细具体的使用方法技巧与实操案例、企业级任务管理等。结合日常工作实践，培养解决实际问题的能力。本课程由黑马程序员提供。
格林威
目录
相关文章
蓝易云
|
24天前
|
编译器 C#
c# - 运算符＜＜不能应用于long和long类型的操作数
在C#中，左移运算符的第二个操作数必须是 `int`类型，因此需要将 `long`类型的位移计数显式转换为 `int`类型。这种转换需要注意数据丢失和负值处理的问题。通过本文的详细说明和示例代码，相信可以帮助你在实际开发中正确使用左移运算符。
蓝易云
31 3
蓝易云
|
23天前
|
编译器 C#
c# - 运算符＜＜不能应用于long和long类型的操作数
在C#中，左移运算符的第二个操作数必须是 `int`类型，因此需要将 `long`类型的位移计数显式转换为 `int`类型。这种转换需要注意数据丢失和负值处理的问题。通过本文的详细说明和示例代码，相信可以帮助你在实际开发中正确使用左移运算符。
蓝易云
37 1
蓝易云
|
22天前
|
编译器 C#
c# - 运算符＜＜不能应用于long和long类型的操作数
在C#中，左移运算符的第二个操作数必须是 `int`类型，因此需要将 `long`类型的位移计数显式转换为 `int`类型。这种转换需要注意数据丢失和负值处理的问题。通过本文的详细说明和示例代码，相信可以帮助你在实际开发中正确使用左移运算符。
蓝易云
11 0
长梦
|
1月前
|
消息中间件 网络协议 安全
C# 一分钟浅谈：WebSocket 协议应用
【10月更文挑战第6天】在过去的一年中，我参与了一个基于 WebSocket 的实时通信系统项目，该项目不仅提升了工作效率，还改善了用户体验。本文将分享在 C# 中应用 WebSocket 协议的经验和心得，包括基础概念、C# 实现示例、常见问题及解决方案等内容，希望能为广大开发者提供参考。
长梦
105 0
何雨晨
|
1月前
|
Web App开发 网络协议 API
基于C#编写一个远程桌面应用
基于C#编写一个远程桌面应用
何雨晨
42 0
土木林森
|
6月前
|
开发框架 前端开发 .NET
C#编程与Web开发
【4月更文挑战第21天】本文探讨了C#在Web开发中的应用，包括使用ASP.NET框架、MVC模式、Web API和Entity Framework。C#作为.NET框架的主要语言，结合这些工具，能创建动态、高效的Web应用。实际案例涉及企业级应用、电子商务和社交媒体平台。尽管面临竞争和挑战，但C#在Web开发领域的前景将持续拓展。
土木林森
202 3
土木林森
|
6月前
|
SQL 开发框架 安全
C#编程与多线程处理
【4月更文挑战第21天】探索C#多线程处理，提升程序性能与响应性。了解C#中的Thread、Task类及Async/Await关键字，掌握线程同步与安全，实践并发计算、网络服务及UI优化。跟随未来发展趋势，利用C#打造高效应用。
土木林森
199 3
长梦
|
19天前
|
C# 开发者
C# 一分钟浅谈：Code Contracts 与契约编程
【10月更文挑战第26天】本文介绍了 C# 中的 Code Contracts，这是一个强大的工具，用于通过契约编程增强代码的健壮性和可维护性。文章从基本概念入手，详细讲解了前置条件、后置条件和对象不变量的使用方法，并通过具体代码示例进行了说明。同时，文章还探讨了常见的问题和易错点，如忘记启用静态检查、过度依赖契约和性能影响，并提供了相应的解决建议。希望读者能通过本文更好地理解和应用 Code Contracts。
长梦
30 3
小王老师呀
|
1月前
|
安全 C# 数据安全/隐私保护
实现C#编程文件夹加锁保护
【10月更文挑战第16天】本文介绍了两种用 C# 实现文件夹保护的方法：一是通过设置文件系统权限，阻止普通用户访问；二是使用加密技术，对文件夹中的文件进行加密，防止未授权访问。提供了示例代码和使用方法，适用于不同安全需求的场景。
小王老师呀
113 0
长梦
|
2月前
|
API C#
C# 一分钟浅谈：文件系统编程
在软件开发中，文件系统操作至关重要。本文将带你快速掌握C#中文件系统编程的基础知识，涵盖基本概念、常见问题及解决方法。文章详细介绍了`System.IO`命名空间下的关键类库，并通过示例代码展示了路径处理、异常处理、并发访问等技巧，还提供了异步API和流压缩等高级技巧，帮助你写出更健壮的代码。
长梦
44 2