タグ: Camera

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);

📷 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

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

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

3. Converting to `BitmapSource` (for WPF)

4. Saving the Image as `.bmp`