在UWP应用中使用ImageSharp裁剪正方形图片为圆形，是否有更直观方法？

Great question! Your current implementation does the job well for small images, and the core logic (making pixels outside a centered circle transparent) is spot-on. But if you're looking for cleaner, more maintainable approaches that avoid unsafe code and leverage ImageSharp's built-in features, here are a couple of excellent options:

1. Safe Pixel Manipulation (No Unsafe Code) #

Instead of using pointers, we can use ImageSharp's PixelAccessor to safely access and modify pixels. We'll also optimize by precomputing the radius squared to avoid repeated square root calculations (which are computationally expensive):

image.Mutate(context =>
{
    context.Apply(target =>
    {
        int halfSize = target.Height / 2;
        float radiusSquared = (float)(halfSize * halfSize); // Precompute to skip Math.Sqrt in loops
        
        using var pixelAccessor = target.GetPixelAccessor();
        
        for (int y = 0; y < target.Height; y++)
        {
            for (int x = 0; x < target.Width; x++)
            {
                // Calculate distance squared from center
                int dx = x - halfSize;
                int dy = y - halfSize;
                if ((dx * dx + dy * dy) > radiusSquared)
                {
                    // Set pixel to transparent
                    pixelAccessor[x, y] = default;
                }
            }
        }
    });
});

This code works identically to your original implementation but is safer and more readable. The precomputed radiusSquared also gives a noticeable performance boost, especially for larger images.

2. Using ImageSharp's Drawing API (Most Intuitive) #

If you prefer a more declarative, visual approach, you can create a circular mask and composite it with your original image. This aligns perfectly with how you'd mentally picture cropping to a circle:

// Create a mask image matching the original dimensions
using var mask = new Image<Argb32>(image.Width, image.Height);

// Draw a solid white circle on the transparent mask
mask.Mutate(ctx =>
{
    var center = new PointF(image.Width / 2f, image.Height / 2f);
    var circle = new EllipsePolygon(center, image.Width / 2f);
    ctx.Fill(Color.White, circle);
});

// Apply the mask: white areas retain original pixels, transparent areas become transparent
image.Mutate(ctx =>
{
    ctx.DrawImage(mask, PixelColorBlendingMode.DestinationIn, 1f);
});

This method is incredibly intuitive—you're essentially creating a "stencil" of the circle you want, then using it to cut that shape from your original image. It's also easy to adjust: tweak the EllipsePolygon parameters if you want an offset circle or a different radius.

Your original code is totally valid, but these alternatives make your codebase easier to maintain and understand for other developers (or future you!).

内容的提问来源于stack exchange，提问作者Sergio0694