C++程式設計人員指南#

using namespace Pylon;
GenApi::INodeMap& nodemap = camera.GetNodeMap();
CIntegerParameter filterStrength(nodemap, "FilterStrength" );
std::cout << "Filter strength: " << filterStrength.GetValue() << std::endl;

#include <pylon/PylonIncludes.h>
using namespace Pylon;

// ....

// Before using any pylon methods, the pylon runtime must be initialized.
PylonInitialize();

try {
  // 1: Create a camera object for the first available blaze camera.
  CBlazeInstantCamera camera(CTlFactory::GetInstance().CreateFirstDevice(
      CDeviceInfo().SetDeviceClass(BaslerGenTlBlazeDeviceClass))
  );

  // 2. Register the default configuration.
  camera.RegisterConfiguration(
    new CBlazeDefaultConfiguration,
    RegistrationMode_ReplaceAll,
    Cleanup_Delete);

  // 3. Open the camera, i.e., establish a connection to the camera device.
  camera.Open();

  // Use the camera.
  std::cout << "Connected to camera "
    << camera.GetDeviceInfo().GetFriendlyName() << std::endl;
  // .....

  // Close the connection.
  camera.Close();
} catch (const GenICam::GenericException& e) {
  std::cerr << "Exception occurred: " << std::endl
    << e.GetDescription() << std::endl;
}

// Releases all pylon resources.
PylonTerminate();

CBlazeInstantCamera camera(CTlFactory::GetInstance().CreateFirstDevice(
    CDeviceInfo().SetDeviceClass(BaslerGenTlBlazeDeviceClass)));
);

CBlazeInstantCamera camera(CTlFactory::GetInstance().CreateFirstDevice(
  CDeviceInfo()
  .SetDeviceClass(BaslerGenTlBlazeDeviceClass)
  .SetSerialNumber("23298299")
));

CBlazeInstantCamera camera(CTlFactory::GetInstance().CreateFirstDevice(
  CDeviceInfo()
  .SetDeviceClass(BaslerGenTlBlazeDeviceClass)
  .SetUserDefinedName("MyCamera")));

#include <pylon/PylonIncludes.h>
#include <ostream>
using namespace Pylon;

// ....

// Before using any pylon methods, the pylon runtime must be initialized.
PylonInitialize();

// ....

// Enumerate all blaze cameras.
CTlFactory& TlFactory = CTlFactory::GetInstance();
DeviceInfoList_t lstDevices;
DeviceInfoList_t filter;
filter.push_back(CDeviceInfo().SetDeviceClass(BaslerGenTlBlazeDeviceClass));
TlFactory.EnumerateDevices(lstDevices, filter);
if (!lstDevices.empty()) {
    DeviceInfoList_t::const_iterator it;
    for (it = lstDevices.begin(); it != lstDevices.end(); ++it) {
        std::cout << it->GetFullName();

    // Open camera, i.e., establish a connection to the camera device.
    CBlazeInstantCamera camera(CTlFactory::GetInstance().CreateDevice(*it));
    camera.RegisterConfiguration(
      new CBlazeDefaultConfiguration,
      RegistrationMode_ReplaceAll, Cleanup_Delete);
    camera.Open();

    // Print out some information.
    std::cout << "Connected to camera "
      << camera.GetDeviceInfo().GetFriendlyName() << std::endl;
    std::cout << "IP Address: "
      << camera.GevCurrentIPAddress.GetValue() << std::endl;
    std::cout << "User-defined name: "
      << camera.DeviceUserID.GetValue() << std::endl;
    std::cout << "Serial Number: "
      << camera.DeviceSerialNumber.GetValue() << std::endl;
}  // The connection will be closed automatically when leaving the scope here.
else {
    std::cerr << "No devices found!" << std::endl;
}

camera.RegisterConfiguration(
      new CBlazeDefaultConfiguration,
      RegistrationMode_ReplaceAll, Cleanup_Delete);

class MyConfigurationHandler : public CBlazeConfigurationEventHandler
{
public:
    // Sets exposure time to minimum possible value.
    void OnOpened(CBlazeInstantCamera& camera) override
    {
        camera.ExposureTime.SetToMinimum();
    }
};

// ....

// Register the default configuration first.
camera.RegisterConfiguration(
      new CBlazeDefaultConfiguration,
      RegistrationMode_ReplaceAll, Cleanup_Delete);

// Then, register additional configuration event handlers.
camera.RegisterConfiguration(
      new MyConfigurationHandler,
      RegistrationMode_Append, Cleanup_Delete);

// ....

camera.Open(); // Configurations will be applied.

// Include files to use the pylon API
#include <pylon/PylonIncludes.h>
#include <pylon/BlazeInstantCamera.h>

// Namespaces for using the pylon API and the blaze camera parameters
using namespace Pylon;
using namespace BlazeCameraParams_Params;

// ...

// Set the operating mode of the camera. The choice you make here
// affects the working range of the camera, i.e., the Minimum Working
// Range and Maximum Working Range parameters.
OperatingModeEnums oldOperatingMode = camera.OperatingMode.GetValue();
camera.OperatingMode.SetValue(OperatingMode_LongRange);

// Exposure time of the camera. If the operating mode is changed, the
// exposure time is set to the recommended default value.
camera.ExposureTime.SetValue(750); // us

// Enable and configure image filtering.

// The spatial noise filter uses the values of neighboring pixels to
// filter out noise in an image.
camera.SpatialFilter.SetValue(true);

// The temporal noise filter uses the values of the same pixel at
// different points in time to filter out noise in an image.
camera.TemporalFilter.SetValue(true);
camera.TemporalFilterStrength.SetValue(220);

// The outlier removal removes pixels that differ significantly from
// their local environment.
camera.OutlierRemoval.SetValue(true);

// Some properties have restrictions.
// We use API functions that automatically perform value corrections.
// Alternatively, you can use GetInc() / GetMin() / GetMax() to make sure you
// set a valid value.
camera.ConfidenceThreshold.SetValue(321, IntegerValueCorrection_Nearest);

// Not all functions are available in older cameras.
// Therefore, we must use "Try" functions that only perform the action
// when parameters are writable. Otherwise, we would get an exception.
camera.MultiCameraChannel.TrySetValue(1);

std::cout << "Operating Mode           : "
    << camera.OperatingMode.GetValue() << std::endl;
std::cout << "Exposure Time            : "
    << camera.ExposureTime.GetValue() << std::endl;
std::cout << "Spatial Filter           : "
    << camera.SpatialFilter.GetValue() << std::endl;
std::cout << "Temporal Filter          : "
    << camera.TemporalFilter.GetValue() << std::endl;
std::cout << "Temporal Filter Strength : "
    << camera.TemporalFilterStrength.GetValue() << std::endl;
std::cout << "Outlier Removal          : "
    << camera.OutlierRemoval.GetValue() << std::endl;
std::cout << "Confidence Threshold     : "
    << camera.ConfidenceThreshold.GetValue() << std::endl;
if (camera.MultiCameraChannel.IsReadable())
    std::cout << "Multi-Camera Channel : "
    << camera.MultiCameraChannel.GetValue() << std::endl;

// Restore the old operating mode.
camera.OperatingMode.SetValue(oldOperatingMode);

// Close the camera.
camera.Close();

// Enable depth maps by enabling the Range component and setting the
// appropriate pixel format.
camera.ComponentSelector.SetValue(ComponentSelector_Range);
camera.ComponentEnable.SetValue(true);
camera.PixelFormat.SetValue(PixelFormat_Coord3D_C16);

// Enable point clouds by enabling the Range component and setting the
// appropriate pixel format.
camera.ComponentSelector.SetValue(ComponentSelector_Range);
camera.ComponentEnable.SetValue(true);
camera.PixelFormat.SetValue(PixelFormat_Coord3D_ABC32f);

#include <pylon/PylonIncludes.h>
#include <pylon/BlazeInstantCamera.h>

using namespace Pylon;
using namespace BlazeCameraParams_Params;

// ....
PylonInitialize();

CBlazeInstantCamera camera(CTlFactory::GetInstance().CreateFirstDevice(
  CDeviceInfo().SetDeviceClass(BaslerGenTlBlazeDeviceClass)));
camera.RegisterConfiguration(
  new CBlazeDefaultConfiguration, RegistrationMode_ReplaceAll, Cleanup_Delete);
camera.Open();

size_t nBuffersGrabbed= 0;

// This smart pointer will receive the grab result data.
CGrabResultPtr ptrGrabResult;

camera.StartGrabbing();

while (camera.IsGrabbing() && nBuffersGrabbed < 10) {
  // Wait for an image and then retrieve it. A timeout of 1000 ms is used.
  camera.RetrieveResult(1000, ptrGrabResult, TimeoutHandling_ThrowException);

  // Data grabbed successfully?
  if (ptrGrabResult->GrabSucceeded()) {
      nBuffersGrabbed++;
      // Access the data.
      // ....
  } else {
    // Error handling
    std::cerr << "Grab error occurred: " << ptrGrabResult->GetErrorDescription() << std::endl;
  }
}
// Clean-up
camera.StopGrabbing();
camera.Close();

#pragma pack(push, 1)
struct Point
{
    float x;
    float y;
    float z;
};
#pragma pack(pop)

// ...

// By registering the CBlazeDefaultConfiguration, depth, intensity, and confidence data will be delivered.
// Depth data is represented as point clouds.
camera.RegisterConfiguration(new CBlazeDefaultConfiguration, RegistrationMode_ReplaceAll, Cleanup_Delete);
camera.Open();

//....

if (ptrGrabResult->GrabSucceeded())
{
  // Get access to the container.
  auto container = ptrGrabResult->GetDataContainer();

  // Access the container's components.
  // Iterate through all components in the container.
  for (size_t i = 0; i < container.GetDataComponentCount(); ++i)
  {
      // Get one component from the container.
      const Pylon::CPylonDataComponent component = container.GetDataComponent(i);
      if ( !component.IsValid() )
          continue;

      // Is this the intensity component?
      if ( component.GetComponentType() == Pylon::ComponentType_Intensity )
      {
          const Pylon::EPixelType pixelType = component.GetPixelType();

          // Get a pointer to the pixel data.
          const void* pPixels = component.GetData();

          // Process intensity values here (pixel data).
          // [...]
      }
  }

  auto rangeComponent = container.GetDataComponent(0);
  auto intensityComponent = container.GetDataComponent(1);
  auto confidenceComponent = container.GetDataComponent(2);

  // Retrieve the 3D coordinates corresponding to the center pixel.
  const auto width = rangeComponent.GetWidth();
  const auto height = rangeComponent.GetHeight();
  const uint32_t u = (int)(0.5 * width);
  const uint32_t v = (int)(0.5 * height);
  auto pPoint =
    reinterpret_cast<const Point*>(rangeComponent.GetData()) + u + v * width;
  uint16_t* pIntensity =
    (uint16_t*)intensityComponent.GetData() +  v * width + u;
  uint16_t* pConfidence
    = (uint16_t*)confidenceComponent.GetData() + v * width + u;
  if (pPoint->z != 0)
      std::cout << "x=" << pPoint->x
        << " y=" << pPoint->y
        << " z=" << pPoint->z << "\n";
  else
      std::cout << "x=   n/a y=   n/a z=   n/a\n";
  std::cout << " intensity=" << *pIntensity
            << " confidence=" << *pConfidence << "\n";
}
else
{
    // Error handling
    std::cerr << "Grab error occurred: " << ptrGrabResult->GetErrorDescription() << std::endl;
}

camera.RetrieveResult(1000, ptrGrabResult, TimeoutHandling_ThrowException);
// Data grabbed successfully?
if (ptrGrabResult->GrabSucceeded()) {
  // Access the data.
  auto container = ptrGrabResult->GetDataContainer();

  CPylonDataComponent rangeComponent;
  CPylonDataComponent intensityComponent;
  CPylonDataComponent confidenceComponent;

  // Iterate through all components in the container.
  for (size_t i = 0; i < container.GetDataComponentCount(); ++i) {
      const Pylon::CPylonDataComponent component = container.GetDataComponent(i);
      if (!component.IsValid())
          continue;
      switch (component.GetComponentType())
      {
      case ComponentType_Intensity:
          intensityComponent = component;
          break;
      case ComponentType_Confidence:
          confidenceComponent = component;
          break;
      case ComponentType_Range:
          rangeComponent = component;
          break;
      }
  }
  if (rangeComponent.IsValid()) {
    const auto width = rangeComponent.GetWidth();
    const auto height = rangeComponent.GetHeight();
    // Process depth data.
  }
  if (intensityComponent.IsValid()) {
    // Process intensity image.
  }
  if (confidenceComponent.IsValid())
  {
    // Process confidence data.
  }
}