### WPF Webcam Streaming and QR Code Integration Example

Source: https://context7.com/francescobonizzi/webcamcontrol-wpf-with-opencv/llms.txt

A comprehensive example demonstrating the integration of webcam streaming with QR code detection within a WPF application. It covers camera selection, starting/stopping the stream, handling QR code detection events, and updating the UI. Requires System, System.Windows, and System.IO namespaces.

```csharp
using System;
using System.Windows;

public partial class MainWindow : Window
{
    private WebcamStreaming _webcamStreaming;

    public MainWindow()
    {
        InitializeComponent();

        // Populate camera dropdown
        cmbCameraDevices.ItemsSource = CameraDevicesEnumerator.GetAllConnectedCameras();
        cmbCameraDevices.SelectedIndex = 0;
    }

    private async void btnStart_Click(object sender, RoutedEventArgs e)
    {
        var selectedCamera = cmbCameraDevices.SelectedItem as CameraDevice;

        // Create or reuse streaming instance
        if (_webcamStreaming == null || _webcamStreaming.CameraDeviceId != selectedCamera.OpenCvId)
        {
            _webcamStreaming?.Dispose();
            _webcamStreaming = new WebcamStreaming(
                imageControlForRendering: webcamPreview,
                frameWidth: 300,
                frameHeight: 300,
                cameraDeviceId: selectedCamera.OpenCvId);
        }

        // Enable QR code detection
        _webcamStreaming.OnQRCodeRead += OnQRCodeDetected;

        try
        {
            await _webcamStreaming.Start();
            btnStart.IsEnabled = false;
            btnStop.IsEnabled = true;
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message, "Camera Error");
        }
    }

    private void OnQRCodeDetected(object sender, EventArgs e)
    {
        var args = e as QRCodeReadEventArgs;

        // Update UI on dispatcher thread
        txtOutput.Dispatcher.Invoke(() =>
        {
            if (!string.IsNullOrWhiteSpace(args.QRCodeData))
            {
                txtOutput.Text = args.QRCodeData;
            }
        });
    }

    private async void btnStop_Click(object sender, RoutedEventArgs e)
    {
        await _webcamStreaming.Stop();

        // Save screenshot if available
        if (_webcamStreaming.LastPngFrame != null)
        {
            System.IO.File.WriteAllBytes("capture.png", _webcamStreaming.LastPngFrame);
        }

        btnStart.IsEnabled = true;
        btnStop.IsEnabled = false;
    }

    private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
    {
        _webcamStreaming?.Dispose();
    }
}
```

--------------------------------

### QR Code Detection Event Arguments and Handling

Source: https://context7.com/francescobonizzi/webcamcontrol-wpf-with-opencv/llms.txt

Defines event arguments for QR code detection, carrying the decoded data. Includes an example of how to subscribe to and handle the QR code read event, processing the decoded string. Requires System namespace.

```csharp
using System;

// Event handler for QR code detection
void HandleQRCodeRead(object sender, EventArgs e)
{
    var args = e as QRCodeReadEventArgs;

    // QRCodeData contains the decoded barcode string
    // Empty or null if no barcode detected in frame
    string data = args.QRCodeData;

    if (!string.IsNullOrWhiteSpace(data))
    {
        // Process detected QR code
        Console.WriteLine($"QR Code Content: {data}");
    }
}

// Subscribe to WebcamStreaming events
webcamStreaming.OnQRCodeRead += HandleQRCodeRead;

// Unsubscribe when no longer needed
webcamStreaming.OnQRCodeRead -= HandleQRCodeRead;
```

--------------------------------

### Webcam Streaming with WPF and OpenCVSharp

Source: https://context7.com/francescobonizzi/webcamcontrol-wpf-with-opencv/llms.txt

Demonstrates how to use the WebcamStreaming class to capture and display video from a webcam in a WPF Image control. It covers initialization, optional features like horizontal flipping and QR code detection, starting/stopping the stream, capturing the last frame as a PNG, and proper disposal. Handles potential camera connection errors.

```csharp
using System;
using System.Windows;
using System.Windows.Controls;

// Create a WPF Image control for rendering
Image webcamPreview = new Image();

// Initialize webcam streaming with frame dimensions and camera ID
var webcamStreaming = new WebcamStreaming(
    imageControlForRendering: webcamPreview,
    frameWidth: 300,
    frameHeight: 300,
    cameraDeviceId: 0  // Use CameraDevicesEnumerator to get valid IDs
);

// Optional: Enable horizontal flip (mirror mode)
webcamStreaming.FlipHorizontally = true;

// Optional: Subscribe to QR code detection events
webcamStreaming.OnQRCodeRead += (sender, e) =>
{
    var args = e as QRCodeReadEventArgs;
    if (!string.IsNullOrWhiteSpace(args.QRCodeData))
    {
        Console.WriteLine($"QR Code detected: {args.QRCodeData}");
    }
};

// Start streaming (async)
try
{
    await webcamStreaming.Start();
    // Camera is now streaming to webcamPreview Image control
}
catch (ApplicationException ex)
{
    // Handle "Cannot connect to camera" error
    MessageBox.Show(ex.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
}

// Stop streaming and capture last frame
await webcamStreaming.Stop();

// Access the last captured frame as PNG byte array
byte[] lastFrame = webcamStreaming.LastPngFrame;
if (lastFrame != null)
{
    // Save screenshot to file
    System.IO.File.WriteAllBytes("screenshot.png", lastFrame);
}

// Dispose when done
webcamStreaming.Dispose();
```

--------------------------------

### WebcamStreaming Event Handling

Source: https://context7.com/francescobonizzi/webcamcontrol-wpf-with-opencv/llms.txt

Manage QR code detection events using the QRCodeReadEventArgs class.

```APIDOC
## OnQRCodeRead Event

### Description
Event triggered when a QR code is successfully detected in the video stream.

### Response
#### Success Response (200)
- **QRCodeData** (string) - The decoded content of the QR code.
```

--------------------------------

### Enumerate Connected Cameras with DirectShow and OpenCV

Source: https://context7.com/francescobonizzi/webcamcontrol-wpf-with-opencv/llms.txt

Shows how to use the CameraDevicesEnumerator static class to list all connected camera devices. It retrieves cameras in the order that OpenCV indexes them, providing their names, OpenCV IDs, and DirectShow device paths. This is useful for selecting a camera for use with the WebcamStreaming class or populating a UI element like a ComboBox.

```csharp
using System.Collections.Generic;

// Get all connected cameras with their OpenCV indices
List<CameraDevice> cameras = CameraDevicesEnumerator.GetAllConnectedCameras();

// Iterate through available cameras
foreach (CameraDevice camera in cameras)
{
    Console.WriteLine($"Camera: {camera.Name}");
    Console.WriteLine($"  OpenCV ID: {camera.OpenCvId}");
    Console.WriteLine($"  Device Path: {camera.DeviceId}");
}

// Use in WPF ComboBox for camera selection
ComboBox cmbCameraDevices = new ComboBox();
cmbCameraDevices.ItemsSource = CameraDevicesEnumerator.GetAllConnectedCameras();
cmbCameraDevices.DisplayMemberPath = "Name";
cmbCameraDevices.SelectedIndex = 0;

// Get selected camera's OpenCV ID for WebcamStreaming
var selectedCamera = cmbCameraDevices.SelectedItem as CameraDevice;
int cameraId = selectedCamera.OpenCvId;
```

--------------------------------

### BitmapExtensions API

Source: https://context7.com/francescobonizzi/webcamcontrol-wpf-with-opencv/llms.txt

Utility methods for converting System.Drawing.Bitmap to WPF-compatible formats.

```APIDOC
## ToBitmapSource

### Description
Converts a System.Drawing.Bitmap object to a WPF BitmapSource for rendering in an Image control.

### Method
Extension Method

### Request Example
BitmapSource wpfImage = bitmap.ToBitmapSource();
wpfImage.Freeze();
```

--------------------------------

### Bitmap to WPF BitmapSource Conversion

Source: https://context7.com/francescobonizzi/webcamcontrol-wpf-with-opencv/llms.txt

Provides extension methods to convert a System.Drawing.Bitmap object into a WPF-compatible BitmapSource. This is essential for displaying images from System.Drawing in WPF Image controls. Requires System.Drawing and System.Windows.Media.Imaging namespaces.

```csharp
using System.Drawing;
using System.Windows.Media.Imaging;

// Convert System.Drawing.Bitmap to WPF BitmapSource
Bitmap bitmap = new Bitmap(640, 480);
// ... populate bitmap with image data ...

BitmapSource wpfImage = bitmap.ToBitmapSource();

// The BitmapSource can be used directly with WPF Image control
// Note: Call Freeze() before cross-thread assignment
wpfImage.Freeze();
imageControl.Source = wpfImage;
```

--------------------------------

### OpenCVQRCodeReader API

Source: https://context7.com/francescobonizzi/webcamcontrol-wpf-with-opencv/llms.txt

The OpenCVQRCodeReader class provides methods to detect and decode barcodes or QR codes from video frames.

```APIDOC
## DetectBarcode

### Description
Performs QR code and barcode detection on a given OpenCV Mat frame using gradient analysis and multiple threshold passes.

### Method
Method Call

### Parameters
#### Request Body
- **frame** (Mat) - Required - The OpenCV frame to process.
- **rotation** (int) - Optional - Rotation parameter for detection.

### Request Example
string barcodeData = qrCodeReader.DetectBarcode(frame, rotation: 0);

### Response
#### Success Response (200)
- **data** (string) - The decoded barcode string, or null/empty if not found.
```

--------------------------------

### OpenCV QR Code Reader for Frame Analysis

Source: https://context7.com/francescobonizzi/webcamcontrol-wpf-with-opencv/llms.txt

Performs QR code and barcode detection on video frames using OpenCV and ZXing.Net. It processes frames by converting to grayscale, applying gradient detection, multiple threshold passes, contour analysis, and adding padding for decoding. Outputs decoded barcode data.

```csharp
using OpenCvSharp;

// Create QR code reader instance
var qrCodeReader = new OpenCVQRCodeReader();

// Detect barcode/QR code from an OpenCV Mat frame
using (var frame = new Mat())
{
    // Assuming frame contains captured video data
    videoCapture.Read(frame);

    // Detect barcode with optional rotation parameter
    string barcodeData = qrCodeReader.DetectBarcode(frame, rotation: 0);

    if (!string.IsNullOrWhiteSpace(barcodeData))
    {
        Console.WriteLine($"Detected: {barcodeData}");
    }
}

// The detector automatically:
// - Converts to grayscale
// - Applies Sobel gradient detection
// - Uses multiple threshold passes (80, 120, 160, 200, 220)
// - Finds contours and extracts largest barcode region
// - Adds white border padding for ZXing compatibility
// - Draws green rectangle around detected barcode on frame
```

--------------------------------

### CameraDevice Data Model for Camera Information

Source: https://context7.com/francescobonizzi/webcamcontrol-wpf-with-opencv/llms.txt

Defines the CameraDevice class, a data model used to represent a connected camera. It includes properties for the index used by OpenCV (OpenCvId), a human-readable name, and the DirectShow device path. This class is used by CameraDevicesEnumerator to return camera information.

```csharp
// CameraDevice properties
public class CameraDevice
{
    public int OpenCvId { get; set; }    // Index used by OpenCV's VideoCapture
    public string Name { get; set; }      // Human-readable camera name
    public string DeviceId { get; set; }  // DirectShow device path
}

// Example camera object values:
// OpenCvId: 0
// Name: "HD Webcam"
// DeviceId: "\\?\usb#vid_046d&pid_0825#..."
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.