?About the author: 2022Blog Rising StarEighth. A Java back-end developer who loves Chinese studies, he cultivates his mind and improves his technology simultaneously.
Personal homepage: Java Fans’ blog
Personal creed: Don’t express your anger and never make mistakes. Little knowledge, great wisdom.
Current column: WPF case and knowledge sharing column
?Featured column: Fun Chinese Studies-The road to cultivating one’s character
Content of this article: WPF implements signature photo function
When you use WPF (Windows Presentation Foundation) technology to write a signature photography software, you need to use C# to handle the interface and camera operations. Here is a simple example showing how to create a WPF application to implement this functionality.
First, make sure you have Visual Studio and .NET Framework installed. Then, create a new WPF application project, which we will call “SignatureCaptureApp”.
In MainWindow.xaml, create an interface layout, including an area to display the camera preview, a signature area, and a button to take a photo and save the signature.
<Window x:Class="SignatureCaptureApp.MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
Title="Signature Capture App" Height="400" Width="600">
<Grid>
<Image Name="CameraPreview" Width="400" Height="300" Stretch="UniformToFill" Margin="10"/>
<InkCanvas Name="SignatureCanvas" Width="400" Height="100" Margin="10"/>
<Button Content="Take a photo and save your signature" Click="CaptureSignature_Click" HorizontalAlignment="Center" VerticalAlignment="Bottom" Margin="0,0,0,10"/>
</Grid>
</Window>
In MainWindow.xaml.cs, add the logic for camera and signature capture.
using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Ink;
using System.Windows.Media.Imaging;
using System.Windows.Media.Imaging;
namespace SignatureCaptureApp
{<!-- -->
public partial class MainWindow : Window
{<!-- -->
private CameraCapture _cameraCapture;
public MainWindow()
{<!-- -->
InitializeComponent();
_cameraCapture = new CameraCapture(CameraPreview);
_cameraCapture.InitializeCamera();
}
private void CaptureSignature_Click(object sender, RoutedEventArgs e)
{<!-- -->
// Photograph
BitmapSource photo = _cameraCapture.CapturePhoto();
//Save signature
if (SignatureCanvas.Strokes.Count > 0 & amp; & amp; photo != null)
{<!-- -->
SaveSignatureAndPhoto(SignatureCanvas.Strokes, photo);
}
}
private void SaveSignatureAndPhoto(StrokeCollection strokes, BitmapSource photo)
{<!-- -->
try
{<!-- -->
//Create a unique filename for the signature
string signatureFileName = $"Signature_{<!-- -->DateTime.Now:yyyyMMddHHmmss}.png";
string photoFileName = $"Photo_{<!-- -->DateTime.Now:yyyyMMddHHmmss}.jpg";
// Get the folder path where signatures and photos are saved
string saveFolderPath = Environment.GetFolderPath(Environment.SpecialFolder.MyPictures);
//Create signature image file
SaveSignatureToFile(strokes, Path.Combine(saveFolderPath, signatureFileName));
//Create photo file
SavePhotoToFile(photo, Path.Combine(saveFolderPath, photoFileName));
}
catch (Exception ex)
{<!-- -->
// Handle errors, such as displaying an error message box
MessageBox.Show($"An error occurred while saving signatures and photos: {<!-- -->ex.Message}");
}
}
private void SaveSignatureToFile(StrokeCollection strokes, string filePath)
{<!-- -->
//Create a RenderTargetBitmap for drawing signatures
RenderTargetBitmap renderTargetBitmap = new RenderTargetBitmap(400, 100, 96, 96, PixelFormats.Default);
renderTargetBitmap.Render(SignatureCanvas);
//Create a PngBitmapEncoder to save the signature
PngBitmapEncoder encoder = new PngBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(renderTargetBitmap));
// Save signature to file
using (FileStream fileStream = new FileStream(filePath, FileMode.Create))
{<!-- -->
encoder.Save(fileStream);
}
}
private void SavePhotoToFile(BitmapSource photo, string filePath)
{<!-- -->
//Create a JpegBitmapEncoder to save the photo
JpegBitmapEncoder encoder = new JpegBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(photo));
// Save photo to file
using (FileStream fileStream = new FileStream(filePath, FileMode.Create))
{<!-- -->
encoder.Save(fileStream);
}
}
}
}
Generate a unique file name, and then get the folder path for saving (here, take the “My Pictures” folder as an example). Next, it uses RenderTargetBitmap to render the signature canvas into a bitmap, and then uses PngBitmapEncoder to save the signature. At the same time, JpegBitmapEncoder is also used to save photos taken by the camera.
Create the CameraCapture.cs class to handle camera operations. You need to use WPF’s MediaElement and System.Windows.Media.Imaging to implement camera preview and photo taking functions. A simplified example is provided here, actual application requires more processing and error handling.
When you need to initialize the camera and take pictures in a WPF application, you can use the MediaCapture class to achieve this. Here’s a more detailed example showing how to initialize the camera and take a picture:
using System;
using System.Windows.Controls;
using System.Windows.Media.Imaging;
using System.Windows.Media;
using System.Windows.Threading;
using System.Windows;
using System.IO;
using System.Threading.Tasks;
using Windows.Media.Capture;
using Windows.Media.MediaProperties;
using Windows.Storage;
using Windows.Storage.Streams;
namespace SignatureCaptureApp
{<!-- -->
public class CameraCapture
{<!-- -->
private MediaElement _cameraPreview;
private MediaCapture _mediaCapture;
public CameraCapture(MediaElement cameraPreview)
{<!-- -->
_cameraPreview = cameraPreview;
}
public async void InitializeCamera()
{<!-- -->
try
{<!-- -->
//Initialize the MediaCapture object
_mediaCapture = new MediaCapture();
await _mediaCapture.InitializeAsync();
// Display camera preview in MediaElement
_cameraPreview.SetMediaPlayer(_mediaCapture);
// Start camera preview
await _mediaCapture.StartPreviewAsync();
}
catch (Exception ex)
{<!-- -->
// Handle errors, such as displaying an error message box
MessageBox.Show($"An error occurred while initializing the camera: {<!-- -->ex.Message}");
}
}
public async Task<BitmapSource> CapturePhoto()
{<!-- -->
try
{<!-- -->
// Create a temporary file to save the photo
StorageFile photoFile = await ApplicationData.Current.TemporaryFolder.CreateFileAsync("TempPhoto.jpg", CreationCollisionOption.GenerateUniqueName);
// Take a photo and save it to a temporary file
ImageEncodingProperties imageProperties = ImageEncodingProperties.CreateJpeg();
await _mediaCapture.CapturePhotoToStorageFileAsync(imageProperties, photoFile);
//Read photo data from temporary file
using (IRandomAccessStream photoStream = await photoFile.OpenReadAsync())
{<!-- -->
//Create a BitmapDecoder to decode photo data
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(photoStream);
// Decode the photo into a BitmapSource
SoftwareBitmap softwareBitmap = await decoder.GetSoftwareBitmapAsync();
SoftwareBitmap softwareBitmapBGR8 = SoftwareBitmap.Convert(softwareBitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);
BitmapSource photo = await ConvertToBitmapSource(softwareBitmapBGR8);
// Delete temporary files
await photoFile.DeleteAsync();
//return photos
return photo;
}
}
catch (Exception ex)
{<!-- -->
// Handle errors, such as displaying an error message box
MessageBox.Show($"An error occurred while taking pictures: {<!-- -->ex.Message}");
return null;
}
}
private async Task<BitmapSource> ConvertToBitmapSource(SoftwareBitmap softwareBitmap)
{<!-- -->
//Create a WriteableBitmap to save photo data
WriteableBitmap bitmap = new WriteableBitmap(softwareBitmap.PixelWidth, softwareBitmap.PixelHeight);
softwareBitmap.CopyToBuffer(bitmap.PixelBuffer);
// Wait for the UI thread to be idle, then create a BitmapSource on the UI thread
await Application.Current.Dispatcher.BeginInvoke(new Action(() =>
{<!-- -->
bitmap.Invalidate();
}), DispatcherPriority.ApplicationIdle);
return bitmap;
}
}
}
In the InitializeCamera method, we use the MediaCapture class to initialize the camera and display the camera preview in the MediaElement. In the CapturePhoto method, we use the CapturePhotoToStorageFileAsync method to take a photo and save the photo to a temporary file. We then use the BitmapDecoder class to decode the photo data and convert it into a BitmapSource object. Finally, we delete the temporary files and return the photos.
Please note that this code uses an asynchronous method, so you need to add the async keyword in front of the method and use the await keyword to wait for the asynchronous operation to complete. In addition, we also used SoftwareBitmap and WriteableBitmap to process photo data.
Code writing is not easy. This article will introduce it here. If you want to learn more Java series knowledge, ClickFollow the blogger, the blogger will guide you Learn Java knowledge from scratch. At the same time, for friends who have troubles in daily life, welcome to read my Fourth Column: “Chinese Studies Weekly Update-The Road to Cultivating the Mind” 》, while learning technology, we also pay attention to the cultivation of character.
