Baumer工业相机
Baumer工业相机堡盟相机是一种高性能、高质量的工业相机，可用于各种应用场景，如物体检测、计数和识别、运动分析和图像处理。
Baumer的万兆网相机拥有出色的图像处理性能，可以实时传输高分辨率图像。此外，该相机还具有快速数据传输、低功耗、易于集成以及高度可扩展性等特点。
Baumer工业相机由于其性能和质量的优越和稳定，常用于高速同步采集领域，通常使用各种图像算法来提高其捕获的图像的质量。
Baumer工业相机BGAPISDK和AutoFocus功能的技术背景
Baumer工业相机的BGAPI SDK是Baumer公司开发的针对其相机产品系列的一套软件开发工具包。该SDK提供了一组API，使开发人员可以编写专业应用程序，从而控制、捕获、处理和显示Baumer相机的图像和数据。BGAPI SDK支持多种编程语言，包括C++、C#、Visual Basic、LabVIEW、Matlab等，并提供了大量示例代码和文档，以帮助用户轻松上手，快速完成应用程序的开发。
BGAPI SDK提供了丰富的功能，可以控制Baumer相机的所有参数，包括曝光时间、增益、白平衡、触发模式等，以及支持各种数据格式，例如Raw、BMP、JPG等，同时还提供了实时显示、数据采集、图像处理等功能，为开发人员提供了高度定制化的解决方案。此外，BGAPI SDK还支持多相机系统的开发，并可支持各种计算机操作系统，如Windows、Linux、Mac OS等。
工业相机的AutoFocus功能是指该相机具备自动对焦功能，可以通过相机自身或外部设备（如光电传感器、激光测距仪等）对物体进行快速、精准的自动对焦。
自动对焦功能可以大大提高相机的拍摄效率和准确性，特别是在工业生产、机器视觉、智能制造等领域中，可以快速、准确地识别物体、测量尺寸和形状等参数，从而实现自动化生产和质量控制。
在选择工业相机时，需要根据具体应用场景考虑是否需要AutoFocus功能，并根据需求选择相应的对焦方式和适合的镜头。
本文介绍的使用BGAPI SDK进行使用AutoFocus功能。
Baumer工业相机通过BGAPISDK使用AutoFocus功能
下面介绍在C++里Baumer工业相机如何通过BGAPISDK使用AutoFocus功能方式
1.引用合适的类文件
代码如下（示例）：
#include <stdio.h> #include <iostream> #include <iomanip> #include <set> #include <vector> #include <algorithm> #include <string> #include "bgapi2_genicam/bgapi2_genicam.hpp"
2.通过BGAPISDK使用AutoFocus自动对焦功能
Baumer工业相机设置自动对焦AutoFucus功能核心代码如下所示：
SystemList Open a System Get the InterfaceList and fill it Open an Interface Get the DeviceList and fill it Open a Device typedef struct _Result { int64_t sharp_value; int64_t lens; int64_t method_value; } Result; std::map<int64_t, Result> result_map; //--------------------------------------------------------------------------------------------------------------------- // This example uses a Software Trigger to get images from the camera. This method will trigger regularly using // a separate thread to trigger and calculate in parallel. void SoftwareTriggerThread(BGAPI2::Device* device, int64_t time_delay) { std::this_thread::sleep_for(std::chrono::milliseconds(time_delay)); device->GetRemoteNode("TriggerSoftware")->Execute(); } void ExampleAutoFocus(BGAPI2::Device* device) { std::thread trigger_thread; const uint64_t lens_delay = 70; // A delay required for settling the liquid lens const int64_t focus_threshold = 85; // Threshold in percent for detection of a peak! BGAPI2::ImageProcessor* image_processor = new BGAPI2::ImageProcessor(); device->GetRemoteNode("AcquisitionStop")->Execute(); // to make sure that camera stopped BGAPI2::Node* lens_focus = device->GetRemoteNode("OpticFeatureValue"); BGAPI2::String pixel_format = device->GetRemoteNode("PixelFormat")->GetString(); const int image_width = static_cast<int>(device->GetRemoteNode("Width")->GetInt()); const int image_height = static_cast<int>(device->GetRemoteNode("Height")->GetInt()); ROI roi = {200, 200, 400, 300}; // We only use a region of the image to set the focus int64_t focus_start_step = 1000; // The step size to jump for next measurement int64_t focus_step = focus_start_step; int64_t lens_focus_max = std::min(static_cast<bo_int64>(40000), lens_focus->GetIntMax()); int64_t lens_focus_min = std::max(static_cast<bo_int64>(10000), lens_focus->GetIntMin()); int64_t focus_value = lens_focus->GetInt(); // the start value for the algorithm // Detect and open the data stream BGAPI2::DataStreamList *datastreamList = device->GetDataStreams(); datastreamList->Refresh(); BGAPI2::DataStream *datastream = datastreamList->begin()->second; datastream->Open(); // Add 4 buffers to the data stream BGAPI2::BufferList *bufferList = datastream->GetBufferList(); for (int i = 0; i < 4; i++) { BGAPI2::Buffer* buffer = new BGAPI2::Buffer(); bufferList->Add(buffer); buffer->QueueBuffer(); } BGAPI2::Buffer* buffer_filled = nullptr; //------------------------------------------------------------------------------------ // A high gain value is bad for a good auto focus (regarding noise)! device->GetRemoteNode(SFNC_GAINSELECTOR)->SetString(SFNC_GAINSELECTORVALUE_ALL); device->GetRemoteNode(SFNC_GAIN)->SetValue("1.0"); datastream->StartAcquisitionContinuous(); // use camera auto function to obtain well balanced images AutoBrightnessWhiteBalance(device, datastream, roi); //------------------------------------------------------------------------------------ device->GetRemoteNode("TriggerSource")->SetString("Software"); device->GetRemoteNode("TriggerMode")->SetString("On"); device->GetRemoteNode("AcquisitionStart")->Execute(); device->GetRemoteNode("TriggerSoftware")->Execute(); int64_t sharp_min = 1L << 30; int64_t sharp_max = 0; int64_t sharp_maxno = 0; const std::chrono::system_clock::time_point start_time = std::chrono::system_clock::now(); bool is_min_focus = false; bool is_max_focus = false; bool is_finished = false; for (int i = 0; !is_finished; i++) { int64_t read_focus_value = lens_focus->GetInt(); buffer_filled = datastream->GetFilledBuffer(1000); if (buffer_filled == nullptr) { std::cout << "Error: Buffer Timeout after 1000 ms" << std::endl; device->GetRemoteNode("TriggerSoftware")->Execute(); } else if (buffer_filled->GetIsIncomplete() == true) { std::cout << "Error: Image is incomplete" << std::endl; buffer_filled->QueueBuffer(); } else { // get a correct picture, check the calculated value and calculate the next step //======================================================= if (lens_focus) { int64_t next_focus = focus_value + focus_step; if (next_focus > lens_focus_max) is_max_focus = true; if (next_focus < lens_focus_min) is_min_focus = true; if (is_min_focus && is_max_focus) { is_finished = true; break; // reached both limits! } if (!is_min_focus && !is_max_focus) { if (focus_step > 0) { focus_step = -focus_step - focus_start_step; if (next_focus + focus_step < lens_focus_min) { is_min_focus = true; focus_step = +focus_start_step; } } else { focus_step = -focus_step + focus_start_step; if (next_focus + focus_step > lens_focus_max) { is_max_focus = true; focus_step = -focus_start_step; } } } else { if (!is_min_focus) { focus_step = -focus_start_step; } else if (!is_max_focus) { focus_step = +focus_start_step; } next_focus = focus_value + focus_step; } focus_value = next_focus; if (focus_value > lens_focus_max) { is_finished = true; } //======================================================= if (!is_finished) { // -> next setting and image lens_focus->SetInt(focus_value); trigger_thread = std::thread(&SoftwareTriggerThread, device, lens_delay); } void* buffer_pointer = buffer_filled->GetMemPtr(); uint64_t buffer_size = buffer_filled->GetSizeFilled(); BGAPI2::Image* image = image_processor->CreateImage(image_width, image_height, pixel_format, buffer_pointer, buffer_size); CheckAndFixRoi(&roi, image_width, image_height); #if USE_OPENCV // Display the image if (pixel_format == "Mono8") { ShowImage(buffer_pointer, image_width, image_height, CV_8UC1, &roi); } else { // Convert to BGR8 const size_t size = static_cast<size_t>(image->GetTransformBufferLength("BGR8")); char* mem_buffer = new char[size]; if (mem_buffer) { image_processor->TransformImageToBuffer(image, "BGR8", mem_buffer, size); ShowImage(mem_buffer, image_width, image_height, CV_8UC3, &roi); delete[] mem_buffer; } } #endif // Convert to Mono8 for measurement sharpness const size_t size = static_cast<size_t>(image->GetTransformBufferLength("Mono8")); uint8_t* mem_buffer = new uint8_t[size]; if (mem_buffer) { image_processor->TransformImageToBuffer(image, "Mono8", mem_buffer, size); int64_t sharpness = 0; //----------------------------------------------------------------- // The algorithm for measurement of sharp: // Here you can use: prewitt, sobel, scharr - or you use an own algorithm like // open_cv laplacian, DFT (FFT), canny or something else // we use Sobel Sharpening! see HelperFuntions -> sobel matrix sharpness = CrossCalculateMono(mem_buffer, image_width, image_height, sobel_x, sobel_y, roi); //----------------------------------------------------------------- result_map[read_focus_value].lens = read_focus_value; result_map[read_focus_value].method_value = sharpness; if (sharpness < sharp_min) { sharp_min = sharpness; } if (sharpness > sharp_max) { sharp_max = sharpness; sharp_maxno = read_focus_value; } if (sharpness < (focus_threshold * sharp_max) / 100) { if (read_focus_value < sharp_maxno) { is_min_focus = true; } else { is_max_focus = true; } } delete[] mem_buffer; } buffer_filled->QueueBuffer(); } } if (trigger_thread.joinable()) trigger_thread.join(); } int64_t meanvalue = 0; int64_t meancount = 0; int64_t auto_focus_value = -1; int64_t new_focus = -1; int64_t max_sharpness = sharp_max; lens_focus_min = lens_focus_max = -1; for (auto result : result_map) { if (lens_focus_min < 0) lens_focus_min = result.first; if (result.second.method_value * 100 > focus_threshold * max_sharpness) { lens_focus_max = result.first; meanvalue += result.second.method_value * (result.first - lens_focus_min); meancount++; } else if (lens_focus_max < 0) lens_focus_min = result.first; } int64_t outside_min = -1; int64_t outside_max = -1; for (auto result : result_map) { if (result.second.method_value * 100 > focus_threshold * max_sharpness) { outside_max = result.first; } else if (outside_max < 0) { outside_min = result.first; } else { outside_max = result.first; break; } } if (outside_min > 0 && outside_max > 0 && (result_map.find(outside_min + 1000) != result_map.end()) && (result_map.find(outside_max - 1000) != result_map.end())) { int64_t threshold = (focus_threshold * max_sharpness) / 100; int64_t min = 1000 * (threshold - result_map[outside_min].method_value) / (result_map[outside_min + 1000].method_value - result_map[outside_min].method_value); outside_min += min; int64_t max = 1000 * (threshold - result_map[outside_min].method_value) / (result_map[outside_max - 1000].method_value - result_map[outside_min].method_value); outside_max -= max; new_focus = (outside_min + outside_max) / 2; } if (new_focus < 0) { new_focus = sharp_maxno; } if (lens_focus && (new_focus > lens_focus_min) && (new_focus < lens_focus_max)) { auto_focus_value = new_focus; lens_focus->SetInt(auto_focus_value); // set the new calculated value to the camera! #if USE_OPENCV // read an image and show it (if you use OpenCV) SoftwareTriggerThread(device, lens_delay); buffer_filled = datastream->GetFilledBuffer(1000); if (buffer_filled) { BGAPI2::Image* image = image_processor->CreateImage(image_width, image_height, buffer_filled->GetPixelFormat(), buffer_filled->GetMemPtr(), buffer_filled->GetSizeFilled()); const size_t size = static_cast<size_t>(image->GetTransformBufferLength("BGR8")); char* mem_buffer = new char[size]; if (mem_buffer) { image_processor->TransformImageToBuffer(image, "BGR8", mem_buffer, size); ShowImage(mem_buffer, image_width, image_height, CV_8UC3, nullptr); } buffer_filled->QueueBuffer(); } else { std::cout << "don't get last buffer!" << std::endl; } #endif std::chrono::duration<double, std::milli> overall_delay = std::chrono::system_clock::now() - start_time; std::cout << "AutoFocus finished after " << overall_delay.count() << "ms and " << result_map.size() << " images, focus value = " << auto_focus_value << "!" << std::endl; } else { std::cout << "The camera couldn't focused correctly!" << std::endl; } // clean up camera and buffers device->GetRemoteNode("AcquisitionAbort")->Execute(); device->GetRemoteNode("AcquisitionStop")->Execute(); device->GetRemoteNode("TriggerMode")->SetString("Off"); datastream->StopAcquisition(); bufferList->DiscardAllBuffers(); while (bufferList->size() > 0) { BGAPI2::Buffer* buffer = bufferList->begin()->second; bufferList->RevokeBuffer(buffer); delete buffer; } datastream->Close(); if (image_processor != nullptr) { delete image_processor; image_processor = nullptr; } }
3.通过BGAPISDK运行测试AutoFocus自动对焦功能
SystemList Open a System Get the InterfaceList and fill it Open an Interface Get the DeviceList and fill it Open a Device int main(int numArgs, char *args[]) { int returncode = 0; int64_t camfound = 0; std::cout << "BGAPI2 Example 503 - AutoFocus" << std::endl; #ifndef USE_OPENCV // OpenCV // this part is use if no matching OpenCV found in CMake! std::cout << "Without OpenCV buffer images are not shown on screen and not saved to files!" << std::endl; std::cout << "Availability of OpenCV is checked while CMake creates this project." << std::endl; std::cout << "Please install OpenCV (version 2.3 or later) or set 'OpenCV_DIR' to the" << std::endl; std::cout << "correct path in the CMakeList.txt script or as a variable in your environment" << std::endl; std::cout << "and run CMake again. " << std::endl; std::cout << "######################################" << std::endl << std::endl; #endif // USE_OPENCV try { // First search for a camera which supports the liquid lens // We use the feature "OpticFeatureValue" to check if the camera supports the liquid lens // Get the list of systems and loop through BGAPI2::SystemList *system_list = BGAPI2::SystemList::GetInstance(); system_list->Refresh(); for (auto system_pair : *system_list) { auto system = system_pair->second; // gige, usb3, .. system->Open(); // Get the list of interfaces on the system and loop through auto interface_list = system->GetInterfaces(); interface_list->Refresh(100); for (auto interface_pair : *interface_list) { auto interface = interface_pair->second; interface->Open(); auto device_list = interface->GetDevices(); device_list->Refresh(100); // Get the list of devices and loop though them to find a camera supporting a liquid lens for (auto device_pair: *device_list) { BGAPI2::Device* device = device_pair->second; device->Open(); std::stringstream camera_name; camera_name << device->GetModel() << "(SN = " << device->GetSerialNumber() << ")"; if (device->GetRemoteNodeList()->GetNodePresent("OpticFeatureValue")) { if (!device->GetRemoteNode("OpticFeatureValue")->IsWriteable()) { continue; } } else { continue; } std::cout << "Camera found!" << std::endl; #ifdef _DEBUG // Switch off the heartbeat in debug mode, otherwise the camera might disconnect during debug! if (device->GetRemoteNodeList()->GetNodePresent("DeviceLinkHeartbeatMode")) device->GetRemoteNode("DeviceLinkHeartbeatMode")->SetString("Off"); #endif // no try to focus the camera ExampleAutoFocus(device); #ifdef _DEBUG // Switch the heartbeat back on if (device->GetRemoteNodeList()->GetNodePresent("DeviceLinkHeartbeatMode")) device->GetRemoteNode("DeviceLinkHeartbeatMode")->SetString("On"); #endif // close the camera device->Close(); camfound = 1; break; // if one camera found! } interface->Close(); if (camfound) break; // if one camera found! } system->Close(); if (camfound) break; // if one camera found! } if (camfound == 0) { std::cout << "No camera found on any system and any interface!" << std::endl; } } catch (BGAPI2::Exceptions::IException& ex) { returncode = (returncode == 0) ? 1 : returncode; std::cout << "Error in function: " << ex.GetFunctionName() << std::endl << "Error description: " << ex.GetErrorDescription() << std::endl << std::endl; } BGAPI2::SystemList::ReleaseInstance(); #ifdef USE_OPENCV // OpenCV // Wait a delay cv::waitKey(10000); // show a little while of 5 seconds the focused image cv::destroyAllWindows(); #else for (int i = 0; i < 5; i++) { // a little while of 5 seconds... std::this_thread::sleep_for(std::chrono::milliseconds(1000)); } #endif return returncode; }
Baumer工业相机使用AutoFocus自动对焦功能的优势
工业相机使用AutoFocus自动对焦功能有以下优势：
提高工作效率：自动对焦功能可以快速、准确地识别并对焦目标物体，避免了手动调节对焦焦距带来的时间浪费。因此，使用自动对焦功能可以提高生产效率，节省时间和人力成本。
提高测量精度：自动对焦功能可以根据不同的拍摄距离和物体大小，自动调整对焦焦距，保证图像清晰度和测量精度。
适应不同场景：自动对焦功能适应范围广泛，可以应用于工业生产、机器视觉、智能制造等多个领域中，对于不同大小、不同形状的目标物体均能有效识别并对焦，具有很高的通用性。
减少使用难度：相对于手动调节对焦焦距，自动对焦功能更易于操作和使用，减少了对操作人员技术水平的要求，也降低了需要培训的成本。
总之，自动对焦功能是现代工业相机的重要功能之一，对于提高工作效率、测量精度和操作便利性都有很大的帮助。
Baumer工业相机使用AutoFocus自动对焦功能的行业应用
工业相机使用AutoFocus自动对焦功能在许多行业具有广泛的应用价值，以下是一些常见的行业应用：
机器视觉检测：自动对焦功能可以帮助机器视觉系统自动识别各种零件，进行尺寸测量、外观检测和定位等。这在制造业、电子行业、汽车行业等领域具有重要价值。
材料科学与无损检测：借助自动对焦功能，工业相机可用于对材料表面进行精确的缺陷检测（如裂纹、气孔等），提高检测的准确性和速度，用于金属制品、塑料制品等行业。
医疗健康：利用自动对焦功能，工业相机可以提供精确的成像数据，辅助进行病理分析、影像诊断等医学应用。例如，在显微镜成像、内窥镜成像等医学设备中进行快速对焦。
生物科技：自动对焦功能可用于生物制品样品检测、显微成像、基因芯片成像等领域，实现高速、高精度的图像处理与分析。
半导体工业：自动对焦可用于芯片制程的检测与质量控制，检查晶圆、封装等组件的缺陷。减少缺陷率，监控生产质量。
能源行业：工业相机的自动对焦功能可以应用于太阳能电池板、核电站等能源设施的检测与维护，保障设备的正常运行与安全。
安防监控：自动对焦功能可用于监控摄像头的调整与控制，确保拍摄到清晰的监控图像，提高安防系统的效果。
总之，在各行业应用中，工业相机使用AutoFocus自动对焦功能可以提高图像处理速度和准确性，实现对目标物体的快速捕捉和检测，提高生产效率和质量。
