Вырезать круг из квадратной картинки

    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            CurBitmap = (Bitmap)Image.FromFile("C://nard.jpg");
            double R = CurBitmap.Width / 2;
            using (var wr = new ImageWrapper(CurBitmap))
            {
                foreach (Point p in wr)
                {
                    Point center = new Point(CurBitmap.Width / 2, CurBitmap.Height / 2);
                    double Distance = Math.Sqrt(Math.Pow(p.X - center.Y, 2) + Math.Pow(p.Y - center.Y, 2));
                    if (Distance > R) wr.SetPixel(p, 255, 255, 255);
                    else wr.SetPixel(p, wr[p].R, wr[p].G, wr[p].B);
                }
            }
        }
        Bitmap CurBitmap;
        protected override void OnPaint(PaintEventArgs e)
        {
            e.Graphics.DrawImage(CurBitmap, 0, 0);
        }
    }
    public class ImageWrapper : IDisposable, IEnumerable<Point>
    {
        /// <summary>
        /// Ширина изображения
        /// </summary>
        public int Width { get; private set; }
        /// <summary>
        /// Высота изображения
        /// </summary>
        public int Height { get; private set; }
        /// <summary>
        /// Цвет по-умолачнию (используется при выходе координат за пределы изображения)
        /// </summary>
        public Color DefaultColor { get; set; }
 
        private byte[] data;//буфер исходного изображения
        private byte[] outData;//выходной буфер
        private int stride;
        private BitmapData bmpData;
        private Bitmap bmp;
 
        /// <summary>
        /// Создание обертки поверх bitmap.
        /// </summary>
        /// <param name="copySourceToOutput">Копирует исходное изображение в выходной буфер</param>
        public ImageWrapper(Bitmap bmp, bool copySourceToOutput = false)
        {
            Width = bmp.Width;
            Height = bmp.Height;
            this.bmp = bmp;
 
            bmpData = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
            stride = bmpData.Stride;
 
            data = new byte[stride * Height];
            System.Runtime.InteropServices.Marshal.Copy(bmpData.Scan0, data, 0, data.Length);
 
            outData = copySourceToOutput ? (byte[])data.Clone() : new byte[stride * Height];
        }
 
        /// <summary>
        /// Возвращает пиксел из исходнго изображения.
        /// Либо заносит пиксел в выходной буфер.
        /// </summary>
        public Color this[int x, int y]
        {
            get
            {
                var i = GetIndex(x, y);
                return i < 0 ? DefaultColor : Color.FromArgb(data[i + 3], data[i + 2], data[i + 1], data[i]);
            }
 
            set
            {
                var i = GetIndex(x, y);
                if (i >= 0)
                {
                    outData[i] = value.B;
                    outData[i + 1] = value.G;
                    outData[i + 2] = value.R;
                    outData[i + 3] = value.A;
                };
            }
        }
 
        /// <summary>
        /// Возвращает пиксел из исходнго изображения.
        /// Либо заносит пиксел в выходной буфер.
        /// </summary>
        public Color this[Point p]
        {
            get { return this[p.X, p.Y]; }
            set { this[p.X, p.Y] = value; }
        }
 
        /// <summary>
        /// Заносит в выходной буфер значение цвета, заданные в double.
        /// Допускает выход double за пределы 0-255.
        /// </summary>
        public void SetPixel(Point p, double r, double g, double b)
        {
            if (r < 0) r = 0;
            if (r >= 256) r = 255;
            if (g < 0) g = 0;
            if (g >= 256) g = 255;
            if (b < 0) b = 0;
            if (b >= 256) b = 255;
 
            this[p.X, p.Y] = Color.FromArgb((int)r, (int)g, (int)b);
        }
 
        int GetIndex(int x, int y)
        {
            return (x < 0 || x >= Width || y < 0 || y >= Height) ? -1 : x * 4 + y * stride;
        }
 
        /// <summary>
        /// Заносит в bitmap выходной буфер и снимает лок.
        /// Этот метод обязателен к исполнению (либо явно, лмбо через using)
        /// </summary>
        public void Dispose()
        {
            System.Runtime.InteropServices.Marshal.Copy(outData, 0, bmpData.Scan0, outData.Length);
            bmp.UnlockBits(bmpData);
        }
 
        /// <summary>
        /// Перечисление всех точек изображения
        /// </summary>
        public IEnumerator<Point> GetEnumerator()
        {
            for (int y = 0; y < Height; y++)
                for (int x = 0; x < Width; x++)
                    yield return new Point(x, y);
        }
 
        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
 
        /// <summary>
        /// Меняет местами входной и выходной буферы
        /// </summary>
        public void SwapBuffers()
        {
            var temp = data;
            data = outData;
            outData = temp;
        }
    }

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Drawing.Drawing2D;
 
namespace CirclePaint
{
    public partial class MainForm : Form
    {
        /// <summary>
        /// Для перевода в радианы
        /// </summary>
        private const double GR = Math.PI / 180.0;
 
        /// <summary>
        /// Центр окружности
        /// </summary>
        private Point CentralPoint = new Point(250, 250);
 
        /// <summary>
        /// Радиус окружности
        /// </summary>
        private int Radius = 200;
 
        /// <summary>
        /// GraphicsPath (контур отрисовки)
        /// </summary>
        private GraphicsPath GrPath = new GraphicsPath();
 
        /// <summary>
        /// Основная форма
        /// </summary>
        public MainForm()
        {
            InitializeComponent();
            Calc();
        }
 
        /// <summary>
        /// Расчет области отрисовки
        /// </summary>
        private void Calc()
        {
            var len = 360;
            var pointsPath = new Point[len];
 
            for (int i = 0; i < len; i++)
            {
                var x = CentralPoint.X + Radius * Math.Cos(i * GR);
                var y = CentralPoint.X + Radius * Math.Sin(i * GR);
 
                pointsPath[i] = new Point((int)x, (int)y);
 
                GrPath.AddLine( i == 0 ? pointsPath[i] :pointsPath[i - 1], pointsPath[i]);
            }
        }
 
        /// <summary>
        /// Отрисовка
        /// </summary>
        /// <param name="e"></param>
        protected override void OnPaint(PaintEventArgs e)
        {
            e.Graphics.SetClip(new Region(GrPath), CombineMode.Replace);
            e.Graphics.DrawImage(Res.cat, new Point());
        }
    }
}

private Image RoundingImage(Image Image)
        {
            Int32 Radius = Image.Width;
 
            Bitmap RoundedImage = new Bitmap(Image.Width, Image.Height);
            using (Graphics G = Graphics.FromImage(RoundedImage))
            {
                G.Clear(Color.Transparent);
                G.SmoothingMode = SmoothingMode.AntiAlias;
                G.CompositingQuality = CompositingQuality.HighQuality;
                G.InterpolationMode = InterpolationMode.HighQualityBicubic;
 
                using (Brush Brush = new TextureBrush(Image))
                {
                    using (GraphicsPath GP = new GraphicsPath())
                    {
                        GP.AddArc(0, 0, Radius, Radius, 180, 90);
                        GP.AddArc(Image.Width - Radius - 0, 0, Radius, Radius, 270, 90);
                        GP.AddArc(0 + Image.Width - Radius, 0 + Image.Height - Radius, Radius, Radius, 0, 90);
                        GP.AddArc(0, Image.Height - Radius, Radius, Radius, 90, 90);
 
                        G.FillPath(Brush, GP);
                    }
                }
                return RoundedImage;
            }
        }