カテゴリー: Camera

Implementing High-Speed Burst Capture with the Basler pylon SDK (C# / .NET 8)

In machine vision and inspection systems, it’s often not enough to capture a single frame—you frequently need to capture multiple images in rapid succession, also known as burst capture or continuous acquisition.

In this article, we walk through how to implement burst capture using the Basler pylon SDK in C#, including:

A basic capture loop
Controlling frame interval
Saving images with timestamps
Practical performance considerations

✔ What You Will Learn

How to implement a burst capture loop
How to control acquisition interval using frame-rate settings
How to save frames with timestamps for later analysis
How to avoid dropped frames and performance bottlenecks

✔ Environment

Item	Details
Camera	Basler acA2500-14gm
SDK	Basler pylon Camera Software Suite
Lang	C# / .NET 8 (Windows)

🔄 Basic Burst Capture: Capturing N Consecutive Frames

Before implementing burst capture, define a helper method to control trigger mode:

public bool SetTriggerMode(string mode)
    => SetPLCameraParameter(PLCamera.TriggerMode, mode);

1 2	public bool SetTriggerMode(string mode) => SetPLCameraParameter(PLCamera.TriggerMode, mode);

The following method performs a free-run (trigger-off) burst capture, saving each frame with both an index and elapsed time. Including timestamps makes later debugging and performance analysis much easier.

public void BurstCapture(int count, string baseName = “burst”)
{
    SetTriggerMode(PLCamera.TriggerMode.Off); // Free-run mode

    if (Camera == null || !IsConnected)
        throw new InvalidOperationException(“Camera is not connected.”);

    if (Camera.StreamGrabber == null)
        throw new InvalidOperationException(“Camera StreamGrabber is not available.”);

    var sw = new Stopwatch();
    Camera.StreamGrabber.Start();
    sw.Start();

    for (int i = 0; i < count; i++)
    {
        using IGrabResult? result =
            Camera.StreamGrabber.RetrieveResult(5000, TimeoutHandling.ThrowException);

        var elapsed = sw.ElapsedMilliseconds;

        if (result?.GrabSucceeded ?? false)
        {
            var bmp = ConvertGrabResultToBitmap(result);
            string filename = $”{baseName}_{i:D3}_{elapsed}ms.bmp”;
            SaveBitmap(bmp, filename);
        }
    }

    sw.Stop();
    Camera.StreamGrabber.Stop();
}

public void BurstCapture(int count, string baseName = “burst”)

{

SetTriggerMode(PLCamera.TriggerMode.Off); // Free-run mode

if (Camera == null || !IsConnected)

throw new InvalidOperationException(“Camera is not connected.”);

if (Camera.StreamGrabber == null)

throw new InvalidOperationException(“Camera StreamGrabber is not available.”);

var sw = new Stopwatch();

Camera.StreamGrabber.Start();

sw.Start();

for (int i = 0; i < count; i++)

{

using IGrabResult? result =

Camera.StreamGrabber.RetrieveResult(5000, TimeoutHandling.ThrowException);

var elapsed = sw.ElapsedMilliseconds;

if (result?.GrabSucceeded ?? false)

{

var bmp = ConvertGrabResultToBitmap(result);

string filename = $“{baseName}_{i:D3}_{elapsed}ms.bmp”;

SaveBitmap(bmp, filename);

}

sw.Stop();

Camera.StreamGrabber.Stop();

}

🕒 Controlling the Capture Interval

Burst capture does not automatically enforce timing. To control the interval—for example, 10 fps—enable and set AcquisitionFrameRate:

AcquisitionFrameRateEnable = true  
AcquisitionFrameRate = desired fps

AcquisitionFrameRateEnable = true

AcquisitionFrameRate = desired fps

Reference: How to Control and Verify Frame Rate Using the Basler pylon SDK (C# / .NET 8)

📷 Example: Capturing 10 Frames at 10 fps

[TestMethod()]
public void BurstCaptureTest_10times()
{
    if (!_baslerCameraSample.IsConnected)
        _baslerCameraSample.Connect();

    _baslerCameraSample.EnableFrameRate(true);
    _baslerCameraSample.SetFrameRate(10); // 10 fps (100 ms/frame)

    _baslerCameraSample.BurstCapture(10, “BurstCaptureTest”);

    for (int i = 0; i < 10; i++)
    {
        string filename = $”BurstCaptureTest_{i:D3}_*.bmp”;
        var files = System.IO.Directory.GetFiles(“.”, filename);
        Assert.IsTrue(files.Length > 0, $”File {filename} not found.”);
    }
}

[TestMethod()]

public void BurstCaptureTest_10times()

{

if (!_baslerCameraSample.IsConnected)

_baslerCameraSample.Connect();

_baslerCameraSample.EnableFrameRate(true);

_baslerCameraSample.SetFrameRate(10); // 10 fps (100 ms/frame)

_baslerCameraSample.BurstCapture(10, “BurstCaptureTest”);

for (int i = 0; i < 10; i++)

{

string filename = $“BurstCaptureTest_{i:D3}_*.bmp”;

var files = System.IO.Directory.GetFiles(“.”, filename);

Assert.IsTrue(files.Length > 0, $“File {filename} not found.”);

}

📊 Example Output

Captured images at 10 fps while the object was rotating:

45ms	143ms	243ms	343ms	443ms

543ms	643ms	743ms	843ms	943ms

⚠️ Common Problems & How to Fix Them

Issue	Cause / Solution
Missing frames	Saving images takes too long → save in a background thread using `ConcurrentQueue`
CPU load too high	Full-resolution images are heavy → reduce ROI
First-frame timestamp inconsistent	Trigger mode behavior → use hardware/software trigger for strict timing

🔁 Slow Burst Capture at Full Resolution?

→ Reduce ROI to Increase Frame Rate

Full-resolution capture (e.g., 2592×1944) can bottleneck both bandwidth and processing time. Reducing the Region of Interest (ROI) often dramatically improves:

Frame rate
Latency
Stability

ROI-based optimization will be covered in the next article.

📝 Summary

Burst capture in pylon is implemented with StreamGrabber.Start() + a loop
Frame rate control determines capture timing
Image saving can become a bottleneck—offload saving to another thread if necessary
Combining ROI with burst capture greatly improves performance

筆者: @MilleVision

📦 Full Sample Code Package

A complete working version of all code shown in this article (including burst capture templates) is available here:

👉 https://millevision.booth.pm/items/7316233

2025-12-07

How to Control and Verify Frame Rate Using the Basler pylon SDK (C# / .NET 8)

When developing vision applications—especially for real-time inspection or production environments—one of the most important performance metrics is frame rate (fps). You may need to know:

Can the camera actually capture frames at the rate I’ve set?
What limits the maximum achievable frame rate?
How do I read both the requested and the actual frame rate?

This article explains how to set frame rate, enable frame-rate control, and check the actual resulting fps using the Basler pylon SDK in C#.

✔ Environment

Item	Details
Camera	Basler acA2500-14gm
SDK	Basler pylon Camera Software Suite
Lang	C# / .NET 8 (Windows)

💡 `AcquisitionFrameRate` vs. `ResultingFrameRate`

Parameter	Meaning
AcquisitionFrameRate	The requested frame rate (user setting)
ResultingFrameRate	The actual achievable frame rate calculated by the camera

Even if you set 30 fps, the resulting fps may be lower depending on exposure time, ROI, interface bandwidth, etc.

🔧 Enabling Frame Rate Control

Frame-rate control must be explicitly enabled:

/// <summary>
/// Enable or disable frame-rate control.  
/// When enabled, the camera attempts to acquire images at the specified frame rate.
/// When disabled, the camera operates at the maximum possible fps.
/// </summary>
public bool EnableFrameRate(bool enable)
    => SetPLCameraParameter(PLCamera.AcquisitionFrameRateEnable, enable);

/// <summary>

/// Enable or disable frame-rate control.

/// When enabled, the camera attempts to acquire images at the specified frame rate.

/// When disabled, the camera operates at the maximum possible fps.

/// </summary>

public bool EnableFrameRate(bool enable)

=> SetPLCameraParameter(PLCamera.AcquisitionFrameRateEnable, enable);

Helper method for Boolean parameters

AcquisitionFrameRateEnable is a boolean parameter (IBoolean), so we define:

public bool SetPLCameraParameter(BooleanName parameter, bool value)
{
    if (Camera == null || !IsConnected)
        return false;

    if (Camera.Parameters[parameter].IsWritable)
    {
        Camera.Parameters[parameter].SetValue(value);
        Console.WriteLine($”{parameter} set to {value}.”);
        return true;
    }

    Console.WriteLine($”{parameter} is not writable.”);
    return false;
}

public bool SetPLCameraParameter(BooleanName parameter, bool value)

{

if (Camera == null || !IsConnected)

return false;

if (Camera.Parameters[parameter].IsWritable)

{

Camera.Parameters[parameter].SetValue(value);

Console.WriteLine($“{parameter} set to {value}.”);

return true;

}

Console.WriteLine($“{parameter} is not writable.”);

return false;

}

🔧 Setting the Desired Frame Rate

public bool SetFrameRate(double frameRate)
    => SetPLCameraParameter(PLCamera.AcquisitionFrameRateAbs, frameRate);

1 2	public bool SetFrameRate(double frameRate) => SetPLCameraParameter(PLCamera.AcquisitionFrameRateAbs, frameRate);

💡 Depending on the camera model, the parameter name may be:

AcquisitionFrameRate
AcquisitionFrameRateAbs

Verify via pylon Viewer or by checking:

Camera.Parameters.Contains(PLCamera.AcquisitionFrameRateAbs)

1	Camera.Parameters.Contains(PLCamera.AcquisitionFrameRateAbs)

📏 Reading the Requested and Actual Frame Rate

Requested (user-set) frame rate:

public double GetFrameRate()
    => GetPLCameraParameter(PLCamera.AcquisitionFrameRateAbs);

1 2	public double GetFrameRate() => GetPLCameraParameter(PLCamera.AcquisitionFrameRateAbs);

Actual achievable rate:

public double GetResultingFrameRate()
    => GetPLCameraParameter(PLCamera.ResultingFrameRateAbs);

1 2	public double GetResultingFrameRate() => GetPLCameraParameter(PLCamera.ResultingFrameRateAbs);

ResultingFrameRate is essential—it tells you whether your settings are physically achievable given the exposure time, bandwidth, and ROI.

🚧 What Limits Maximum Frame Rate?

1. Image Size / ROI

Smaller ROI = fewer pixels = higher possible fps.

2. Exposure Time

If exposure is too long, the sensor cannot start the next frame.

Example: ExposureTime = 50,000 µs (50 ms) → max possible fps is 20 fps.

3. Interface Bandwidth (USB3 / GigE)

High-resolution images or 24-bit RGB increase bandwidth usage, lowering achievable fps.

📝 When Your Frame Rate Setting Is Ignored

If you set AcquisitionFrameRate but nothing changes, check:

✔ Is `AcquisitionFrameRateEnable` set to true?

If false, the camera ignores your setting and runs at the highest allowable frame rate.

_baslerCameraSample.EnableFrameRate(false); // Disabled
_baslerCameraSample.SetFrameRate(15);      // Has no effect

double fps = _baslerCameraSample.GetResultingFrameRate();

_baslerCameraSample.EnableFrameRate(false); // Disabled

_baslerCameraSample.SetFrameRate(15); // Has no effect

double fps = _baslerCameraSample.GetResultingFrameRate();

🧪 Example Test: 5 fps → 15 fps → 30 fps

[TestMethod()]
public void SetFrameRateTest()
{
    _baslerCameraSample.Connect();
    _baslerCameraSample.EnableFrameRate(true);

    // 5 fps
    Assert.IsTrue(_baslerCameraSample.SetFrameRate(5));
    Assert.IsTrue(Math.Abs(_baslerCameraSample.GetFrameRate() – 5) < 0.1);

    // 15 fps
    Assert.IsTrue(_baslerCameraSample.SetFrameRate(15));
    Assert.IsTrue(Math.Abs(_baslerCameraSample.GetFrameRate() – 15) < 0.1);

    // 30 fps
    Assert.IsTrue(_baslerCameraSample.SetFrameRate(30));
    Assert.IsTrue(Math.Abs(_baslerCameraSample.GetFrameRate() – 30) < 0.1);

    // Check actual achievable fps
    var resulting = _baslerCameraSample.GetResultingFrameRate();
    Console.WriteLine($”Requested: 30 fps, Resulting: {resulting:F2} fps”);
}

[TestMethod()]

public void SetFrameRateTest()

{

_baslerCameraSample.Connect();

_baslerCameraSample.EnableFrameRate(true);

// 5 fps

Assert.IsTrue(_baslerCameraSample.SetFrameRate(5));

Assert.IsTrue(Math.Abs(_baslerCameraSample.GetFrameRate() – 5) < 0.1);

// 15 fps

Assert.IsTrue(_baslerCameraSample.SetFrameRate(15));

Assert.IsTrue(Math.Abs(_baslerCameraSample.GetFrameRate() – 15) < 0.1);

// 30 fps

Assert.IsTrue(_baslerCameraSample.SetFrameRate(30));

Assert.IsTrue(Math.Abs(_baslerCameraSample.GetFrameRate() – 30) < 0.1);

// Check actual achievable fps

var resulting = _baslerCameraSample.GetResultingFrameRate();

Console.WriteLine($“Requested: 30 fps, Resulting: {resulting:F2} fps”);

}

Example output on my machine:

Frame Rate: 30.00 fps, Resulting Frame Rate: 14.59 fps

1 2	Frame Rate: 30.00 fps, Resulting Frame Rate: 14.59 fps

Even though 30 fps was requested, the actual fps dropped to ~14.6 fps due to bandwidth or exposure constraints.

🧭 Troubleshooting

Symptom	Likely Cause
Frame rate does not increase	Exposure too long / ROI too large
Cannot set AcquisitionFrameRate	`AcquisitionFrameRateEnable` is false
ResultingFrameRate reads 0	Camera not streaming or not initialized

📝 Summary

Enable frame-rate control via AcquisitionFrameRateEnable = true
Set target fps with AcquisitionFrameRateAbs
Verify actual achievable fps via ResultingFrameRateAbs
Exposure time, ROI size, and bandwidth all influence the maximum fps

Understanding both the requested and actual frame rate is essential for designing stable, real-time machine vision systems.

🔜 Next Article

Next, we will build on frame-rate control by implementing continuous acquisition (burst capture) for high-speed inspections and inline processing.

筆者: @MilleVision

2025-12-06

Manual Gain Control with the Basler pylon SDK (C# / .NET 8)

筆者: [@MilleVision](https://qiita.com/MilleVision)

Manual Gain Control with the Basler pylon SDK (C# / .NET 8)

When working with industrial cameras such as those from Basler, exposure time alone is not always enough to achieve the brightness you need. This is especially true when:

The subject moves quickly
You must keep exposure time short
The lighting environment limits the available exposure

In these situations, manual gain control becomes an important tool.

This article explains how to read, set, and validate gain values in C# using the Basler pylon SDK. We will also examine how gain affects noise and how to balance exposure vs. gain using practical example images.

✔ Environment

Item	Details
Camera	Basler acA2500-14gm
Lens	VS Technology VS-LD25N (25 mm C-mount)
SDK	Basler pylon Camera Software Suite
Lang	C# / .NET 8 (Windows)

💡 What Is Gain?

Gain represents electronic amplification of the sensor signal.

Increasing gain brightens the image
But it also amplifies noise, reducing image quality

Because of this trade-off, gain should be balanced with exposure time rather than used alone. Exposure increases brightness with lower noise, but may blur moving objects. Gain brightens the image without changing shutter time but introduces noise.

🔧 Code: Setting and Reading Gain

Below are simple helper methods for manual gain control.

Set Gain (manual mode)

public bool SetGain(double gainValue)
{
    if (!SetGainAutoMode(PLCamera.GainAuto.Off))
        return false;

    return SetPLCameraParamter(PLCamera.Gain, gainValue);
}

public bool SetGain(double gainValue)

{

if (!SetGainAutoMode(PLCamera.GainAuto.Off))

return false;

return SetPLCameraParamter(PLCamera.Gain, gainValue);

}

Auto Gain Mode

public bool SetGainAutoMode(string mode)
    => SetPLCameraParamter(PLCamera.GainAuto, mode);

1 2	public bool SetGainAutoMode(string mode) => SetPLCameraParamter(PLCamera.GainAuto, mode);

Read Gain

public double GetGain()
    => GetPLCameraParamter(PLCamera.Gain);

1 2	public double GetGain() => GetPLCameraParamter(PLCamera.Gain);

📷 Gain in Practice: Image Comparisons

① Exposure Fixed, Gain Increased

In this test, exposure time is constant while only gain is changed. You can clearly see how higher gain results in brighter images but more noise.

Gain 0 dB	Gain 12 dB	Gain 24 dB

② Same Brightness, Different Gain (Exposure Adjusted)

Here, exposure time was adjusted so that the brightness remained approximately constant, allowing you to see just the difference in noise.

Gain 0 dB (60ms)	Gain 12 dB (24ms)	Gain 24 dB (12ms)

💡 GainRaw ↔ Gain (dB) Conversion

Basler cameras often expose two gain parameters:

Gain (in dB) — user-friendly
GainRaw — internal integer register value

The mapping between them varies by camera model, but it can typically be approximated by a linear transform:

double ConvertGainRawToDb(long rawValue)
{
    var rawMin = Camera.Parameters[PLCamera.GainRaw].GetMinimum();
    var rawMax = Camera.Parameters[PLCamera.GainRaw].GetMaximum();
    var dbMin = Camera.Parameters[PLCamera.Gain].GetMinimum();
    var dbMax = Camera.Parameters[PLCamera.Gain].GetMaximum();

    return dbMin + (dbMax – dbMin) * (rawValue – rawMin) / (double)(rawMax – rawMin);
}

long ConvertGainDbToRaw(double dbValue)
{
    var rawMin = Camera.Parameters[PLCamera.GainRaw].GetMinimum();
    var rawMax = Camera.Parameters[PLCamera.GainRaw].GetMaximum();
    var dbMin = Camera.Parameters[PLCamera.Gain].GetMinimum();
    var dbMax = Camera.Parameters[PLCamera.Gain].GetMaximum();

    return (long)Math.Round(rawMin + (rawMax – rawMin) * (dbValue – dbMin) / (dbMax – dbMin));
}

double ConvertGainRawToDb(long rawValue)

{

var rawMin = Camera.Parameters[PLCamera.GainRaw].GetMinimum();

var rawMax = Camera.Parameters[PLCamera.GainRaw].GetMaximum();

var dbMin = Camera.Parameters[PLCamera.Gain].GetMinimum();

var dbMax = Camera.Parameters[PLCamera.Gain].GetMaximum();

return dbMin + (dbMax – dbMin) * (rawValue – rawMin) / (double)(rawMax – rawMin);

}

long ConvertGainDbToRaw(double dbValue)

{

var rawMin = Camera.Parameters[PLCamera.GainRaw].GetMinimum();

var rawMax = Camera.Parameters[PLCamera.GainRaw].GetMaximum();

var dbMin = Camera.Parameters[PLCamera.Gain].GetMinimum();

var dbMax = Camera.Parameters[PLCamera.Gain].GetMaximum();

return (long)Math.Round(rawMin + (rawMax – rawMin) * (dbValue – dbMin) / (dbMax – dbMin));

}

This is useful when a camera supports only GainRaw or when you need precise dB control.

🧭 Troubleshooting Common Gain Issues

Issue	Cause / Solution
Gain does not change	`GainAuto` is not set to Off
Parameter write error	Value outside the allowed range — check `GetMin()` / `GetMax()`
Noise becomes excessive	Gain too high — prefer exposure when possible
Cannot write to `Gain`	Parameter not writable → likely because auto gain is active

When Gain Cannot Be Set

If GainAuto is not disabled, the parameter:

Camera.Parameters[PLCamera.Gain].IsWritable

1 2	Camera.Parameters[PLCamera.Gain].IsWritable

will be false, preventing manual writes.

Always check IsWritable before writing to avoid runtime exceptions.

📝 Summary

Gain amplifies brightness and noise — unlike exposure, which brightens with less noise
Set GainAuto = Off to enable manual gain control
The balance between exposure and gain is crucial:
- Exposure = cleaner images, but motion blur risk
- Gain = no blur, but increased noise

By comparing images side-by-side, we can see why most machine-vision systems prioritize exposure first, then use gain sparingly.

🔜 Next Article

With exposure and gain under control, the next major topic is trigger modes and frame synchronization. We’ll explore hardware triggers, software triggers, and best practices for synchronized acquisition.

筆者: @MilleVision

2025-12-05

How to Manually Control Exposure Time Using the Basler pylon SDK (C# / .NET 8)

Have you ever felt that your industrial camera images look too dark, too bright, or fluctuate unexpectedly?
Automatic exposure (auto-exposure) can be useful, but in many machine-vision or inspection systems, consistent lighting is essential, and automatic adjustments can cause instability.

With the Basler pylon SDK, you can switch exposure control to manual mode and specify an exact exposure time (in microseconds), enabling stable and predictable imaging.

This article explains how to set, read, and validate exposure time manually using C# and the pylon SDK.

✔ Environment

Item	Details
Camera	Basler acA2500-14gm
SDK	Basler pylon Camera Software Suite
Lang	C# / .NET 8.0 (Windows)

💡 Background: GenICam and Camera Parameters

Parameters such as ExposureTimeAbs used in this article follow GenICam (Generic Interface for Cameras) — an industry standard used by Basler, FLIR, IDS, JAI, and many other industrial camera manufacturers.

With GenICam SFNC (Standard Features Naming Convention), you can access:

Exposure
Gain
ROI / image size
Trigger settings
Acquisition modes

all using a common parameter model.

👉 GenICam SFNC specification:
https://www.emva.org/standards-technology/genicam/

This article focuses on practical usage, but knowing that pylon follows GenICam helps when switching between camera brands.

🔧 Setting Exposure Time Manually

Below is an extension to the BaslerCameraSample class from the previous article.

Method: Set Exposure Time (manual mode)

// Set exposure time manually (unit: microseconds)
public bool SetExposure(double exposureTimeUs)
{
    // Disable auto exposure (switch to manual)
    if (!SetExposureMode(PLCamera.ExposureAuto.Off))
        return false;

    // Set exposure time (e.g., 5000 µs = 5 ms)
    if (!SetPLCameraParamter(PLCamera.ExposureTimeAbs, exposureTimeUs))
        return false;

    Console.WriteLine($”Exposure time set to {exposureTimeUs} μs.”);
    return true;
}

// Set exposure time manually (unit: microseconds)

public bool SetExposure(double exposureTimeUs)

{

// Disable auto exposure (switch to manual)

if (!SetExposureMode(PLCamera.ExposureAuto.Off))

return false;

// Set exposure time (e.g., 5000 µs = 5 ms)

if (!SetPLCameraParamter(PLCamera.ExposureTimeAbs, exposureTimeUs))

return false;

Console.WriteLine($“Exposure time set to {exposureTimeUs} μs.”);

return true;

}

Helper Functions

Set auto-exposure mode (Off / Once / Continuous)

public bool SetExposureMode(string mode)
    => SetPLCameraParamter(PLCamera.ExposureAuto, mode);

1 2	public bool SetExposureMode(string mode) => SetPLCameraParamter(PLCamera.ExposureAuto, mode);

Set an enum parameter

public bool SetPLCameraParamter(ParameterListEnum parameter, string value)
{
    if (Camera == null || !IsConnected)
        return false;

    if (Camera.Parameters[parameter].IsWritable)
    {
        Camera.Parameters[parameter].SetValue(value);
        Console.WriteLine($”{parameter} set to {value}.”);
        return true;
    }
    Console.WriteLine($”{parameter} is not writable.”);
    return false;
}

public bool SetPLCameraParamter(ParameterListEnum parameter, string value)

{

if (Camera == null || !IsConnected)

return false;

if (Camera.Parameters[parameter].IsWritable)

{

Camera.Parameters[parameter].SetValue(value);

Console.WriteLine($“{parameter} set to {value}.”);

return true;

}

Console.WriteLine($“{parameter} is not writable.”);

return false;

}

Set a floating-point parameter (e.g., ExposureTimeAbs)

public bool SetPLCameraParamter(FloatName parameter, double value)
{
    if (Camera == null || !IsConnected)
        return false;

    if (Camera.Parameters[parameter].IsWritable)
    {
        Camera.Parameters[parameter].SetValue(value);
        Console.WriteLine($”{parameter} set to {value}.”);
        return true;
    }
    Console.WriteLine($”{parameter} is not writable.”);
    return false;
}

public bool SetPLCameraParamter(FloatName parameter, double value)

{

if (Camera == null || !IsConnected)

return false;

if (Camera.Parameters[parameter].IsWritable)

{

Camera.Parameters[parameter].SetValue(value);

Console.WriteLine($“{parameter} set to {value}.”);

return true;

}

Console.WriteLine($“{parameter} is not writable.”);

return false;

}

🔍 Reading the Current Exposure Time

Use GetValue() to read exposure parameters from the camera.

// Read exposure time in microseconds
public double GetExposureTime()
    => GetPLCameraParamter(PLCamera.ExposureTimeAbs);

public double GetPLCameraParamter(FloatName parameter)
{
    if (Camera == null || !IsConnected)
        throw new InvalidOperationException(“Camera is not connected.”);

    if (Camera.Parameters[parameter].IsReadable)
    {
        double value = Camera.Parameters[parameter].GetValue();
        Console.WriteLine($”{parameter} value: {value}”);
        return value;
    }
    throw new InvalidOperationException($”{parameter} is not readable.”);
}

// Read exposure time in microseconds

public double GetExposureTime()

=> GetPLCameraParamter(PLCamera.ExposureTimeAbs);

public double GetPLCameraParamter(FloatName parameter)

{

if (Camera == null || !IsConnected)

throw new InvalidOperationException(“Camera is not connected.”);

if (Camera.Parameters[parameter].IsReadable)

{

double value = Camera.Parameters[parameter].GetValue();

Console.WriteLine($“{parameter} value: {value}”);

return value;

}

throw new InvalidOperationException($“{parameter} is not readable.”);

}

💡 About ExposureAuto Modes

Value	Behavior
Off	Manual exposure (used in this article)
Once	Adjusts exposure once, then fixes it
Continuous	Continuously adjusts to maintain brightness

📷 Example: Change Exposure and Capture Images

The test below captures images at 5 ms, 20 ms, and 50 ms.

[TestMethod()]
public void SetExposureTest()
{
    _baslerCameraSample.Connect();

    // 5 ms
    _baslerCameraSample.SetExposure(5000);
    var img1 = _baslerCameraSample.SnapToBitmapSource();
    BaslerCameraSample.SaveBitmap(img1, “Exposure_5ms.bmp”);
    Assert.IsTrue(Math.Abs(_baslerCameraSample.GetExposureTime() – 5000) < 100);

    // 20 ms
    _baslerCameraSample.SetExposure(20000);
    var img2 = _baslerCameraSample.SnapToBitmapSource();
    BaslerCameraSample.SaveBitmap(img2, “Exposure_20ms.bmp”);
    Assert.IsTrue(Math.Abs(_baslerCameraSample.GetExposureTime() – 20000) < 100);

    // 50 ms
    _baslerCameraSample.SetExposure(50000);
    var img3 = _baslerCameraSample.SnapToBitmapSource();
    BaslerCameraSample.SaveBitmap(img3, “Exposure_50ms.bmp”);
    Assert.IsTrue(Math.Abs(_baslerCameraSample.GetExposureTime() – 50000) < 100);
}

[TestMethod()]

public void SetExposureTest()

{

_baslerCameraSample.Connect();

// 5 ms

_baslerCameraSample.SetExposure(5000);

var img1 = _baslerCameraSample.SnapToBitmapSource();

BaslerCameraSample.SaveBitmap(img1, “Exposure_5ms.bmp”);

Assert.IsTrue(Math.Abs(_baslerCameraSample.GetExposureTime() – 5000) < 100);

// 20 ms

_baslerCameraSample.SetExposure(20000);

var img2 = _baslerCameraSample.SnapToBitmapSource();

BaslerCameraSample.SaveBitmap(img2, “Exposure_20ms.bmp”);

Assert.IsTrue(Math.Abs(_baslerCameraSample.GetExposureTime() – 20000) < 100);

// 50 ms

_baslerCameraSample.SetExposure(50000);

var img3 = _baslerCameraSample.SnapToBitmapSource();

BaslerCameraSample.SaveBitmap(img3, “Exposure_50ms.bmp”);

Assert.IsTrue(Math.Abs(_baslerCameraSample.GetExposureTime() – 50000) < 100);

}

📊 Exposure Comparison

5 ms (darker)	20 ms (balanced)	50 ms (brighter)

🧭 Common Issues & Troubleshooting

Issue	Cause / Solution
Exposure does not change	`ExposureAuto` is still On
Value outside valid range	Exposure too long or too short for the camera model
Image too dark/bright	Lighting or gain settings are insufficient
Exposure fluctuates	External lighting or auto exposure still enabled

📝 Summary

Set ExposureAuto = Off to enable manual exposure control
Exposure time is specified in microseconds (μs)
pylon SDK accesses all parameters through Camera.Parameters[...], following GenICam SFNC

🔜 Coming Up Next

Exposure alone may not give enough brightness range depending on your lighting environment.
The next article will cover manual gain control using the pylon SDK.

2025-12-04

How to Capture a Single Image from Basler ace Camera using pylon SDK in C#

Basler industrial cameras can be controlled easily using the pylon Camera Software Suite.
In this article, I’ll show you how to connect to a camera, grab a single frame, convert it to a BitmapSource, and save it as a .bmp file—all using C# and .NET 8.

When I first started working with Basler cameras in a .NET environment, I found very few practical code examples.
This guide is based on tested code from my own applications.

This article covers:

Connecting to a camera
Capturing one frame (Snap)
Converting to BitmapSource (WPF-friendly)
Saving the image as .bmp

⚠️ Important Notice

This article demonstrates how to develop custom applications using the Basler pylon Camera Software Suite SDK.

The content here is based on my own testing and implementation
It is not endorsed by Basler AG
The SDK itself is not redistributed here (no DLLs, headers, etc.)

To use the SDK, download it directly from Basler’s official website:

🔗 pylon SDK download
https://www.baslerweb.com/en/products/software/basler-pylon-camera-software-suite/

Make sure to review the EULA, especially if using the SDK in commercial or high-risk environments:
https://www.baslerweb.com/en/service/eula/

The sample code in this article is provided strictly for learning and reference. Use it at your own responsibility.

✔ Environment

Item	Details
SDK	Basler pylon Camera Software Suite
Language	C# (.NET 8.0 — Windows)
Camera	Basler acA2500-14gm
OS	Windows 10 / 11

1. Connecting to the Camera

First, create a simple wrapper class for managing the connection.
You can connect to the first available camera or use a specified camera name (as shown in Basler pylon Viewer).

using System;
using Basler.Pylon;

namespace BaslerSamples
{
    public class BaslerCameraSample
    {
        public Camera? Camera { get; private set; }
        public bool IsConnected => Camera?.IsConnected ?? false;

        public bool Connect()
        {
            var camera = new Camera();
            return ConnectInternal(camera);
        }

        public bool Connect(string cameraName)
        {
            try
            {
                var camera = new Camera(cameraName);
                return ConnectInternal(camera);
            }
            catch (InvalidOperationException e)
            {
                Console.WriteLine($”Failed to create camera. Message: {e.Message}”);
                return false;
            }
        }

        private bool ConnectInternal(Camera camera)
        {
            try
            {
                camera.Open();
                if (camera.IsOpen)
                {
                    Console.WriteLine(“Camera connected successfully.”);
                    Camera = camera;
                    return true;
                }
                else
                {
                    Console.WriteLine(“Failed to open camera.”);
                    return false;
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($”Error connecting to camera: {ex.Message}”);
                return false;
            }
        }
    }
}

using System;

using Basler.Pylon;

namespace BaslerSamples

{

public class BaslerCameraSample

{

public Camera? Camera { get; private set; }

public bool IsConnected => Camera?.IsConnected ?? false;

public bool Connect()

{

var camera = new Camera();

return ConnectInternal(camera);

}

public bool Connect(string cameraName)

{

try

{

var camera = new Camera(cameraName);

return ConnectInternal(camera);

}

catch (InvalidOperationException e)

{

Console.WriteLine($“Failed to create camera. Message: {e.Message}”);

return false;

}

private bool ConnectInternal(Camera camera)

{

try

{

camera.Open();

if (camera.IsOpen)

{

Console.WriteLine(“Camera connected successfully.”);

Camera = camera;

return true;

}

else

{

Console.WriteLine(“Failed to open camera.”);

return false;

}

catch (Exception ex)

{

Console.WriteLine($“Error connecting to camera: {ex.Message}”);

return false;

}

2. Capturing a Single Image

The simplest way to grab one frame is by calling GrabOne() through the Stream Grabber.

public IGrabResult Snap(int timeoutMs = 5000)
{
    if (Camera == null)
        throw new InvalidOperationException(“Camera is not connected.”);

    var streamGrabber = Camera.StreamGrabber 
        ?? throw new InvalidOperationException(“StreamGrabber is not available.”);
    var grabResult = streamGrabber.GrabOne(timeoutMs);

    if (grabResult != null && grabResult.GrabSucceeded)
        return grabResult;
    else
        throw new Exception(“Failed to grab image: ” + (grabResult?.ErrorDescription ?? “Unknown error”));
}

public IGrabResult Snap(int timeoutMs = 5000)

{

if (Camera == null)

throw new InvalidOperationException(“Camera is not connected.”);

var streamGrabber = Camera.StreamGrabber

?? throw new InvalidOperationException(“StreamGrabber is not available.”);

var grabResult = streamGrabber.GrabOne(timeoutMs);

if (grabResult != null && grabResult.GrabSucceeded)

return grabResult;

else

throw new Exception(“Failed to grab image: “ + (grabResult?.ErrorDescription ?? “Unknown error”));

}

3. Converting to `BitmapSource` (for WPF)

IGrabResult cannot be displayed directly in WPF.
We convert it to a BitmapSource using PixelDataConverter.

using System.Windows.Media;
using System.Windows.Media.Imaging;

public BitmapSource SnapToBitmapSource(int timeoutMs = 5000)
{
    using IGrabResult grabResult = Snap(timeoutMs);
    PixelDataConverter converter = new();

    var (outputType, pixelFormat, bytesPerPixel) = grabResult.PixelTypeValue switch
    {
        PixelType.RGB8packed => (PixelType.RGB8packed, PixelFormats.Rgb24, 3),
        PixelType.BGR8packed => (PixelType.BGR8packed, PixelFormats.Bgr24, 3),
        _ => (PixelType.Mono8, PixelFormats.Gray8, 1),
    };

    converter.OutputPixelFormat = outputType;

    int width = grabResult.Width;
    int height = grabResult.Height;
    int stride = width * bytesPerPixel;

    byte[] buffer = new byte[stride * height];
    converter.Convert(buffer, grabResult);

    return BitmapSource.Create(width, height, 96, 96, pixelFormat, null, buffer, stride);
}

using System.Windows.Media;

using System.Windows.Media.Imaging;

public BitmapSource SnapToBitmapSource(int timeoutMs = 5000)

{

using IGrabResult grabResult = Snap(timeoutMs);

PixelDataConverter converter = new();

var (outputType, pixelFormat, bytesPerPixel) = grabResult.PixelTypeValue switch

{

PixelType.RGB8packed => (PixelType.RGB8packed, PixelFormats.Rgb24, 3),

PixelType.BGR8packed => (PixelType.BGR8packed, PixelFormats.Bgr24, 3),

_ => (PixelType.Mono8, PixelFormats.Gray8, 1),

};

converter.OutputPixelFormat = outputType;

int width = grabResult.Width;

int height = grabResult.Height;

int stride = width * bytesPerPixel;

byte[] buffer = new byte[stride * height];

converter.Convert(buffer, grabResult);

return BitmapSource.Create(width, height, 96, 96, pixelFormat, null, buffer, stride);

}

Supports:

RGB8packed
BGR8packed
Mono8 (default fallback)

4. Saving the Image as `.bmp`

A simple helper method using BmpBitmapEncoder:

public static void SaveBitmap(BitmapSource bitmap, string filePath)
{
    using FileStream fileStream = new(filePath, FileMode.Create);
    var encoder = new BmpBitmapEncoder();
    encoder.Frames.Add(BitmapFrame.Create(bitmap));
    encoder.Save(fileStream);
}

public static void SaveBitmap(BitmapSource bitmap, string filePath)

{

using FileStream fileStream = new(filePath, FileMode.Create);

var encoder = new BmpBitmapEncoder();

encoder.Frames.Add(BitmapFrame.Create(bitmap));

encoder.Save(fileStream);

}

5. Example Test Code

You can easily test the entire pipeline (grab → convert → save) using the following:

static BaslerCameraSample _baslerCameraSample = new BaslerCameraSample();

[TestMethod()]
public void SnapToBitmapSourceTest()
{
    if (!_baslerCameraSample.IsConnected)
        _baslerCameraSample.Connect();

    var result = _baslerCameraSample.SnapToBitmapSource(1234);
    Assert.IsNotNull(result);

    BaslerCameraSample.SaveBitmap(result, “SaveBitmapTest.bmp”);
    Assert.IsTrue(File.Exists(“SaveBitmapTest.bmp”));
}

static BaslerCameraSample _baslerCameraSample = new BaslerCameraSample();

[TestMethod()]

public void SnapToBitmapSourceTest()

{

if (!_baslerCameraSample.IsConnected)

_baslerCameraSample.Connect();

var result = _baslerCameraSample.SnapToBitmapSource(1234);

Assert.IsNotNull(result);

BaslerCameraSample.SaveBitmap(result, “SaveBitmapTest.bmp”);

Assert.IsTrue(File.Exists(“SaveBitmapTest.bmp”));

}

✔ Output Example

The captured image will be saved as:SaveBitmapTest.bmp

Example output:

(Image from the original article)

✨ Conclusion

Although official documentation covers the basics, hands-on .NET examples for pylon are still relatively rare.
Fortunately, pylon’s .NET API is clean and integrates smoothly with Windows desktop applications such as WPF.

2025-12-03

カテゴリー: Camera

Implementing High-Speed Burst Capture with the Basler pylon SDK (C# / .NET 8)

Implementing High-Speed Burst Capture with the Basler pylon SDK (C# / .NET 8)

✔ What You Will Learn

✔ Environment

🔄 Basic Burst Capture: Capturing N Consecutive Frames

🕒 Controlling the Capture Interval

📷 Example: Capturing 10 Frames at 10 fps

📊 Example Output

⚠️ Common Problems & How to Fix Them

🔁 Slow Burst Capture at Full Resolution?

→ Reduce ROI to Increase Frame Rate

📝 Summary

📦 Full Sample Code Package

How to Control and Verify Frame Rate Using the Basler pylon SDK (C# / .NET 8)

How to Control and Verify Frame Rate Using the Basler pylon SDK (C# / .NET 8)

✔ Environment

💡 AcquisitionFrameRate vs. ResultingFrameRate

🔧 Enabling Frame Rate Control

Helper method for Boolean parameters

🔧 Setting the Desired Frame Rate

📏 Reading the Requested and Actual Frame Rate

Requested (user-set) frame rate:

Actual achievable rate:

🚧 What Limits Maximum Frame Rate?

1. Image Size / ROI

2. Exposure Time

3. Interface Bandwidth (USB3 / GigE)

📝 When Your Frame Rate Setting Is Ignored

✔ Is AcquisitionFrameRateEnable set to true?

🧪 Example Test: 5 fps → 15 fps → 30 fps

🧭 Troubleshooting

📝 Summary

🔜 Next Article

Manual Gain Control with the Basler pylon SDK (C# / .NET 8)

Manual Gain Control with the Basler pylon SDK (C# / .NET 8)

✔ Environment

💡 What Is Gain?

🔧 Code: Setting and Reading Gain

Set Gain (manual mode)

Auto Gain Mode

Read Gain

📷 Gain in Practice: Image Comparisons

① Exposure Fixed, Gain Increased

② Same Brightness, Different Gain (Exposure Adjusted)

💡 GainRaw ↔ Gain (dB) Conversion

🧭 Troubleshooting Common Gain Issues

When Gain Cannot Be Set

📝 Summary

🔜 Next Article

How to Manually Control Exposure Time Using the Basler pylon SDK (C# / .NET 8)

How to Manually Control Exposure Time Using the Basler pylon SDK (C# / .NET 8)

✔ Environment

💡 Background: GenICam and Camera Parameters

🔧 Setting Exposure Time Manually

Method: Set Exposure Time (manual mode)

Helper Functions

Set auto-exposure mode (Off / Once / Continuous)

Set an enum parameter

Set a floating-point parameter (e.g., ExposureTimeAbs)

🔍 Reading the Current Exposure Time

💡 About ExposureAuto Modes

📷 Example: Change Exposure and Capture Images

📊 Exposure Comparison

🧭 Common Issues & Troubleshooting

📝 Summary

🔜 Coming Up Next

How to Capture a Single Image from Basler ace Camera using pylon SDK in C#

How to Capture a Single Image from Basler ace Camera using pylon SDK in C#

⚠️ Important Notice

✔ Environment

1. Connecting to the Camera

2. Capturing a Single Image

3. Converting to BitmapSource (for WPF)

4. Saving the Image as .bmp

5. Example Test Code

✔ Output Example

✨ Conclusion

💡 `AcquisitionFrameRate` vs. `ResultingFrameRate`

✔ Is `AcquisitionFrameRateEnable` set to true?

3. Converting to `BitmapSource` (for WPF)

4. Saving the Image as `.bmp`