ImageCropperView.cs

using System;
using System.IO;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Maui.Controls;
using SkiaSharp;
using SkiaSharp.Views.Maui;
using SkiaSharp.Views.Maui.Controls;
 
namespace NeuroAccessMaui.UI.Controls
{
    #region Enums
 
    public enum CropMode
    {
        Square,
 
        Circle,
 
        Aspect
    }
 
    public enum CropOutputFormat
    {
        Png,
 
        Jpeg
    }
 
    #endregion
 
    public class ImageCropperView : ContentView
    {
#warning Replace this with InternetContent
        private static readonly HttpClient sHttpClient = new HttpClient();
 
        #region Bindable Properties
 
        public static readonly BindableProperty OutputMaxResolutionProperty = BindableProperty.Create(
            propertyName: nameof(OutputMaxResolution),
            returnType: typeof(Size),
            declaringType: typeof(ImageCropperView),
            defaultValue: new Size(1280, 1280));
 
        public Size OutputMaxResolution
        {
            get => (Size)this.GetValue(OutputMaxResolutionProperty);
            set => this.SetValue(OutputMaxResolutionProperty, value);
        }
 
        public static readonly BindableProperty InputMaxResolutionProperty = BindableProperty.Create(
            propertyName: nameof(InputMaxResolution),
            returnType: typeof(Size),
            declaringType: typeof(ImageCropperView),
            defaultValue: new Size(3840, 2160));
 
        public Size InputMaxResolution
        {
            get => (Size)this.GetValue(InputMaxResolutionProperty);
            set => this.SetValue(InputMaxResolutionProperty, value);
        }
 
        public static readonly BindableProperty ImageSourceProperty = BindableProperty.Create(
            propertyName: nameof(ImageSource),
            returnType: typeof(ImageSource),
            declaringType: typeof(ImageCropperView),
            defaultValue: null,
            propertyChanged: OnImageSourceChanged);
 
        public ImageSource ImageSource
        {
            get => (ImageSource)this.GetValue(ImageSourceProperty);
            set => this.SetValue(ImageSourceProperty, value);
        }
 
        public static readonly BindableProperty CropModeProperty = BindableProperty.Create(
            propertyName: nameof(CropMode),
            returnType: typeof(CropMode),
            declaringType: typeof(ImageCropperView),
            defaultValue: CropMode.Square);
 
        public CropMode CropMode
        {
            get => (CropMode)this.GetValue(CropModeProperty);
            set => this.SetValue(CropModeProperty, value);
        }
 
        public static readonly BindableProperty OutputFormatProperty = BindableProperty.Create(
            propertyName: nameof(OutputFormat),
            returnType: typeof(CropOutputFormat),
            declaringType: typeof(ImageCropperView),
            defaultValue: CropOutputFormat.Png);
 
        public CropOutputFormat OutputFormat
        {
            get => (CropOutputFormat)this.GetValue(OutputFormatProperty);
            set => this.SetValue(OutputFormatProperty, value);
        }
 
        public static readonly BindableProperty JpegQualityProperty = BindableProperty.Create(
            propertyName: nameof(JpegQuality),
            returnType: typeof(int),
            declaringType: typeof(ImageCropperView),
            defaultValue: 90);
 
        public int JpegQuality
        {
            get => (int)this.GetValue(JpegQualityProperty);
            set => this.SetValue(JpegQualityProperty, value);
        }
 
        public static readonly BindableProperty CropShapeFillPortionProperty = BindableProperty.Create(
            propertyName: nameof(CropShapeFillPortion),
            returnType: typeof(float),
            declaringType: typeof(ImageCropperView),
            defaultValue: 0.9f);
 
        public float CropShapeFillPortion
        {
            get => (float)this.GetValue(CropShapeFillPortionProperty);
            set => this.SetValue(CropShapeFillPortionProperty, value);
        }
 
        public static readonly BindableProperty RotationAngleProperty = BindableProperty.Create(
            propertyName: nameof(RotationAngle),
            returnType: typeof(double),
            declaringType: typeof(ImageCropperView),
            defaultValue: 0.0,
            propertyChanged: OnRotationAngleChanged);
 
        public double RotationAngle
        {
            get => (double)this.GetValue(RotationAngleProperty);
            set => this.SetValue(RotationAngleProperty, value);
        }
 
        public static readonly BindableProperty LimitToBoundsProperty = BindableProperty.Create(
        propertyName: nameof(LimitToBounds),
        returnType: typeof(bool),
        declaringType: typeof(ImageCropperView),
        defaultValue: true);
 
        public bool LimitToBounds
        {
            get => (bool)this.GetValue(LimitToBoundsProperty);
            set => this.SetValue(LimitToBoundsProperty, value);
        }
 
        #endregion
 
        #region Instance Fields
 
        private float scale = 1f;
 
        private float offsetX;
 
        private float offsetY;
 
        private float startOffsetX;
 
        private float startOffsetY;
 
        private Point pinchPivot = new Point(0.5, 0.5);
 
        private SKBitmap? bitmap;
 
        private readonly SKCanvasView canvasView;
 
        private bool initialPositionSet;
 
        #endregion
 
        #region Constructor
 
        public ImageCropperView()
        {
            // Create a root grid layout.
            Grid Root = new Grid
            {
                VerticalOptions = LayoutOptions.Fill,
                HorizontalOptions = LayoutOptions.Fill
            };
 
            // Initialize the canvas view.
            this.canvasView = new SKCanvasView
            {
                VerticalOptions = LayoutOptions.Fill,
                HorizontalOptions = LayoutOptions.Fill
            };
 
            // Set up pan and pinch gesture recognizers.
            PanGestureRecognizer panGesture = new() { TouchPoints = 1 };
            panGesture.PanUpdated += this.OnPan;
 
            PinchGestureRecognizer pinchGesture = new();
            pinchGesture.PinchUpdated += this.OnPinch;
 
            this.canvasView.GestureRecognizers.Add(panGesture);
            this.canvasView.GestureRecognizers.Add(pinchGesture);
 
            // Subscribe to the canvas paint event.
            this.canvasView.PaintSurface += this.OnPaintSurface; // No need to unregister as the canvasView has the same lifetime
 
            Root.Add(this.canvasView);
            this.Content = Root;
        }
        #endregion
 
        #region Public Methods
 
        public void ResetTransformations()
        {
            this.scale = 1f;
            this.offsetX = 0f;
            this.offsetY = 0f;
            this.startOffsetX = 0f;
            this.startOffsetY = 0f;
            this.canvasView.InvalidateSurface();
        }
 
        public byte[]? PerformCrop()
        {
            try
            {
                if (this.bitmap is null)
                    return null;
 
                int viewWidth = (int)this.canvasView.CanvasSize.Width;
                int viewHeight = (int)this.canvasView.CanvasSize.Height;
                if (viewWidth <= 0 || viewHeight <= 0)
                    return null;
 
                // Render the transformed image to a temporary surface.
                using SKBitmap tempSurfaceBitmap = new SKBitmap(viewWidth, viewHeight, isOpaque: false);
                using SKCanvas tempCanvas = new SKCanvas(tempSurfaceBitmap);
                tempCanvas.Clear(SKColors.Transparent);
 
                float centerX = viewWidth / 2f;
                float centerY = viewHeight / 2f;
 
                tempCanvas.Save();
                tempCanvas.Translate(this.offsetX, this.offsetY);
                tempCanvas.Scale(this.scale);
                tempCanvas.Translate(centerX, centerY);
                tempCanvas.RotateDegrees((float)this.RotationAngle);
                tempCanvas.Translate(-centerX, -centerY);
 
                SKRect destRect = new SKRect(0, 0, this.bitmap.Width, this.bitmap.Height);
                tempCanvas.DrawBitmap(this.bitmap, destRect);
                tempCanvas.Restore();
 
                // Define the crop shape.
                SKRect cropRect = this.ComputeCropShapeRect(viewWidth, viewHeight, this.CropShapeFillPortion);
                SKPath cropPath = new SKPath();
                switch (this.CropMode)
                {
                    case CropMode.Circle:
                        {
                            float radius = cropRect.Width / 2f;
                            float cx = cropRect.MidX;
                            float cy = cropRect.MidY;
                            cropPath.AddCircle(cx, cy, radius);
                            break;
                        }
                    case CropMode.Square:
                    case CropMode.Aspect:
                        cropPath.AddRect(cropRect);
                        break;
                }
 
                // Apply the crop mask.
                using SKBitmap maskedBitmap = new SKBitmap(viewWidth, viewHeight, isOpaque: false);
                using (SKCanvas maskedCanvas = new SKCanvas(maskedBitmap))
                {
                    maskedCanvas.Clear(SKColors.Transparent);
                    maskedCanvas.ClipPath(cropPath, SKClipOperation.Intersect, true);
 
                    maskedCanvas.Save();
                    maskedCanvas.Translate(this.offsetX, this.offsetY);
                    maskedCanvas.Scale(this.scale);
                    maskedCanvas.Translate(centerX, centerY);
                    maskedCanvas.RotateDegrees((float)this.RotationAngle);
                    maskedCanvas.Translate(-centerX, -centerY);
                    maskedCanvas.DrawBitmap(this.bitmap, destRect);
                    maskedCanvas.Restore();
                }
 
                // Extract the bounding box of the crop area.
                int left = (int)Math.Floor(cropRect.Left);
                int top = (int)Math.Floor(cropRect.Top);
                int right = (int)Math.Ceiling(cropRect.Right);
                int bottom = (int)Math.Ceiling(cropRect.Bottom);
 
                SKRectI BoundingBox = new SKRectI(left, top, right, bottom);
                using SKBitmap cropped = new SKBitmap(BoundingBox.Width, BoundingBox.Height);
                using (SKCanvas croppedCanvas = new SKCanvas(cropped))
                {
                    SKRect dst = new SKRect(0, 0, BoundingBox.Width, BoundingBox.Height);
                    croppedCanvas.DrawBitmap(maskedBitmap, BoundingBox, dst);
                }
 
                // Resize the cropped bitmap if needed.
                SKBitmap finalBitmap = ResizeBitmapIfNeeded(cropped,
                    (int)this.OutputMaxResolution.Width,
                    (int)this.OutputMaxResolution.Height);
 
                // Encode the final bitmap to the specified format.
                using MemoryStream ms = new MemoryStream();
                if (this.OutputFormat == CropOutputFormat.Png)
                {
                    finalBitmap.Encode(ms, SKEncodedImageFormat.Png, 100);
                }
                else
                {
                    int quality = Math.Max(0, Math.Min(100, this.JpegQuality));
                    finalBitmap.Encode(ms, SKEncodedImageFormat.Jpeg, quality);
                }
                return ms?.ToArray();
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error during cropping: {ex.Message}");
                return null;
            }
        }
 
        #endregion
 
        #region Gesture Handlers
 
        private void OnPan(object? sender, PanUpdatedEventArgs e)
        {
            double density = DeviceDisplay.MainDisplayInfo.Density;
 
            switch (e.StatusType)
            {
                case GestureStatus.Started:
                    this.startOffsetX = this.offsetX;
                    this.startOffsetY = this.offsetY;
                    break;
                case GestureStatus.Running:
                    this.offsetX = this.startOffsetX + (float)(e.TotalX * density);
                    this.offsetY = this.startOffsetY + (float)(e.TotalY * density);
                    if (this.LimitToBounds)
                    {
                        this.ClampTransformations();
                    }
                    this.canvasView.InvalidateSurface();
                    break;
            }
        }
 
        private void OnPinch(object? sender, PinchGestureUpdatedEventArgs e)
        {
            switch (e.Status)
            {
                case GestureStatus.Started:
                    // Record the current offsets and the pinch pivot.
                    this.startOffsetX = this.offsetX;
                    this.startOffsetY = this.offsetY;
                    this.pinchPivot = e.ScaleOrigin;
                    break;
                case GestureStatus.Running:
                    // Use the incremental scale factor directly.
                    float delta = (float)e.Scale; // e.Scale is the incremental factor.
 
                    // Update the cumulative scale.
                    this.scale *= delta;
 
                    // Convert the pinch pivot (relative coordinates) to actual pixels.
                    float pivotX = (float)(this.pinchPivot.X * this.canvasView.CanvasSize.Width);
                    float pivotY = (float)(this.pinchPivot.Y * this.canvasView.CanvasSize.Height);
 
                    // Adjust offsets to keep the pivot point stable.
                    this.offsetX = pivotX - (pivotX - this.offsetX) * delta;
                    this.offsetY = pivotY - (pivotY - this.offsetY) * delta;
 
                    if (this.LimitToBounds)
                    {
                        this.ClampTransformations();
                    }
                    this.canvasView.InvalidateSurface();
                    break;
                case GestureStatus.Completed:
                case GestureStatus.Canceled:
                    break;
            }
        }
 
        #endregion
 
        #region Paint & Layout
 
        private void OnPaintSurface(object? sender, SKPaintSurfaceEventArgs e)
        {
            SKCanvas canvas = e.Surface.Canvas;
            canvas.Clear(SKColors.Transparent);
 
            if (this.bitmap is null)
                return;
 
            float centerX = e.Info.Width / 2f;
            float centerY = e.Info.Height / 2f;
 
            canvas.Save();
            canvas.Translate(this.offsetX, this.offsetY);
            canvas.Scale(this.scale);
            canvas.Translate(centerX, centerY);
            canvas.RotateDegrees((float)this.RotationAngle);
            canvas.Translate(-centerX, -centerY);
            SKRect destRect = new SKRect(0, 0, this.bitmap.Width, this.bitmap.Height);
            canvas.DrawBitmap(this.bitmap, destRect);
            canvas.Restore();
 
            SKRect shapeRect = this.ComputeCropShapeRect(e.Info.Width, e.Info.Height, this.CropShapeFillPortion);
            SKPath path = new SKPath();
            switch (this.CropMode)
            {
                case CropMode.Circle:
                    {
                        float radius = shapeRect.Width / 2f;
                        float cx = shapeRect.MidX;
                        float cy = shapeRect.MidY;
                        path.AddCircle(cx, cy, radius);
                        break;
                    }
                case CropMode.Square:
                case CropMode.Aspect:
                    path.AddRect(shapeRect);
                    break;
            }
 
            using (SKPaint overlayPaint = new SKPaint
            {
                Color = new SKColor(0, 0, 0, 100),
                Style = SKPaintStyle.Fill
            })
            {
                canvas.Save();
                canvas.ClipPath(path, SKClipOperation.Difference, true);
                canvas.DrawRect(new SKRect(0, 0, e.Info.Width, e.Info.Height), overlayPaint);
                canvas.Restore();
            }
 
            using (SKPaint outlinePaint = new SKPaint
            {
                Color = SKColors.White,
                Style = SKPaintStyle.Stroke,
                StrokeWidth = 3,
                IsAntialias = true
            })
            {
                canvas.DrawPath(path, outlinePaint);
            }
        }
 
        protected override void OnSizeAllocated(double width, double height)
        {
            base.OnSizeAllocated(width, height);
 
            if (!this.initialPositionSet && width > 0 && height > 0 && this.bitmap is not null)
            {
                this.SetInitialImagePosition(width, height);
                this.initialPositionSet = true;
                this.canvasView.InvalidateSurface();
            }
        }
 
        private void SetInitialImagePosition(double width, double height)
        {
            double density = DeviceDisplay.MainDisplayInfo.Density;
            float viewWidthPx = (float)(width * density);
            float viewHeightPx = (float)(height * density);
 
            SKRect cropShapeRect = this.ComputeCropShapeRect(viewWidthPx, viewHeightPx, this.CropShapeFillPortion);
            float cropCenterX = cropShapeRect.MidX;
            float cropCenterY = cropShapeRect.MidY;
 
            float scaleX = cropShapeRect.Width / this.bitmap!.Width;
            float scaleY = cropShapeRect.Height / this.bitmap.Height;
            float newScale = MathF.Max(scaleX, scaleY);
            this.scale = newScale;
 
            float scaledWidth = this.bitmap.Width * newScale;
            float scaledHeight = this.bitmap.Height * newScale;
 
            this.offsetX = cropCenterX - (scaledWidth / 2f);
            this.offsetY = cropCenterY - (scaledHeight / 2f);
        }
 
        private SKRect ComputeCropShapeRect(float containerWidth, float containerHeight, float marginFactor)
        {
            marginFactor = MathF.Max(0.0f, MathF.Min(1.0f, marginFactor));
 
            switch (this.CropMode)
            {
                case CropMode.Circle:
                case CropMode.Square:
                    {
                        float minDim = MathF.Min(containerWidth, containerHeight);
                        float shapeSize = minDim * marginFactor;
                        float left = (containerWidth - shapeSize) / 2f;
                        float top = (containerHeight - shapeSize) / 2f;
                        return new SKRect(left, top, left + shapeSize, top + shapeSize);
                    }
                case CropMode.Aspect:
                    {
                        float targetRatio = 1.0f;
                        if (this.OutputMaxResolution.Height > 0)
                        {
                            targetRatio = (float)this.OutputMaxResolution.Width / (float)this.OutputMaxResolution.Height;
                        }
                        float shapeWidth = containerWidth * marginFactor;
                        float shapeHeight = shapeWidth / targetRatio;
                        if (shapeHeight > containerHeight * marginFactor)
                        {
                            shapeHeight = containerHeight * marginFactor;
                            shapeWidth = shapeHeight * targetRatio;
                        }
                        float left = (containerWidth - shapeWidth) / 2f;
                        float top = (containerHeight - shapeHeight) / 2f;
                        return new SKRect(left, top, left + shapeWidth, top + shapeHeight);
                    }
            }
            return SKRect.Empty;
        }
 
        #endregion
 
        #region Bitmap Loading & Resizing
 
        private static void OnRotationAngleChanged(BindableObject bindable, object oldValue, object newValue)
        {
            if (bindable is ImageCropperView cropper)
            {
                cropper.ClampTransformations();
                cropper.canvasView.InvalidateSurface();
            }
        }
 
        private static async void OnImageSourceChanged(BindableObject bindable, object oldValue, object newValue)
        {
            if (bindable is ImageCropperView cropper && newValue is ImageSource newSource)
            {
                cropper.bitmap?.Dispose();
                cropper.bitmap = await LoadAndResizeBitmapAsync(newSource, cropper.InputMaxResolution);
                // Optionally, reset transformations:
                // cropper.ResetTransformations();
 
                cropper.initialPositionSet = false;
 
                if (cropper.Width > 0 && cropper.Height > 0)
                {
                    cropper.SetInitialImagePosition(cropper.Width, cropper.Height);
                    cropper.initialPositionSet = true;
                }
                else
                {
                    cropper.initialPositionSet = false;
                }
 
                cropper.canvasView.InvalidateSurface();
            }
        }
 
        private static async Task<SKBitmap?> LoadAndResizeBitmapAsync(ImageSource imageSource, Size maxResolution)
        {
            try
            {
                StreamImageSource? streamImageSource = null;
                switch (imageSource)
                {
                    case FileImageSource fileSource:
                        if (File.Exists(fileSource.File))
                        {
                            streamImageSource = new StreamImageSource
                            {
                                Stream = _ => Task.FromResult<Stream>(File.OpenRead(fileSource.File))
                            };
                        }
                        break;
                    case UriImageSource uriSource:
                        {
                            HttpResponseMessage response = await sHttpClient.GetAsync(uriSource.Uri);
                            if (response.IsSuccessStatusCode)
                            {
                                MemoryStream ms = new MemoryStream();
                                await response.Content.CopyToAsync(ms);
                                ms.Position = 0;
                                streamImageSource = new StreamImageSource
                                {
                                    Stream = _ => Task.FromResult<Stream>(ms)
                                };
                            }
                            break;
                        }
                    case StreamImageSource sis:
                        streamImageSource = sis;
                        break;
                }
 
                if (streamImageSource is null)
                    return null;
 
                Stream stream = await streamImageSource.Stream(CancellationToken.None).ConfigureAwait(false);
                if (stream is null)
                    return null;
 
                using MemoryStream managedStream = new MemoryStream();
                await stream.CopyToAsync(managedStream).ConfigureAwait(false);
                managedStream.Position = 0;
 
                SKBitmap loadedBitmap = SKBitmap.Decode(managedStream);
                if (loadedBitmap is null)
                    return null;
 
                SKBitmap resized = ResizeBitmapIfNeeded(loadedBitmap,
                    (int)maxResolution.Width,
                    (int)maxResolution.Height);
 
                if (resized != loadedBitmap)
                {
                    loadedBitmap.Dispose();
                }
                return resized;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error loading bitmap: {ex.Message}");
                return null;
            }
        }
 
        private static SKBitmap ResizeBitmapIfNeeded(SKBitmap sourceBitmap, int maxWidth, int maxHeight)
        {
            if (sourceBitmap is null || maxWidth <= 0 || maxHeight <= 0)
                return new SKBitmap(1, 1);
 
            int width = sourceBitmap.Width;
            int height = sourceBitmap.Height;
 
            if (width <= maxWidth && height <= maxHeight)
            {
                return sourceBitmap;
            }
 
            float widthRatio = (float)maxWidth / width;
            float heightRatio = (float)maxHeight / height;
            float scale = Math.Min(widthRatio, heightRatio);
 
            int newWidth = (int)(width * scale);
            int newHeight = (int)(height * scale);
 
            SKBitmap resized = new SKBitmap(newWidth, newHeight, sourceBitmap.ColorType, sourceBitmap.AlphaType);
            using SKCanvas canvas = new SKCanvas(resized);
            using SKPaint paint = new SKPaint
            {
                FilterQuality = SKFilterQuality.High,
                IsAntialias = true
            };
 
            SKRect srcRect = new SKRect(0, 0, width, height);
            SKRect destRect = new SKRect(0, 0, newWidth, newHeight);
            canvas.DrawBitmap(sourceBitmap, srcRect, destRect, paint);
 
            return resized;
        }
 
        #endregion
 
        private void ClampTransformations()
        {
            if (!this.LimitToBounds || this.bitmap is null)
                return;
 
            SKSize canvasSize = this.canvasView.CanvasSize;
            if (canvasSize.Width <= 0 || canvasSize.Height <= 0)
                return;
 
            float canvasWidth = canvasSize.Width;
            float canvasHeight = canvasSize.Height;
            // Compute the crop rectangle (in canvas coordinates).
            SKRect cropRect = this.ComputeCropShapeRect(canvasWidth, canvasHeight, this.CropShapeFillPortion);
 
            // -----------------------------------------------------
            // 1. Enforce a Minimum Scale (Zoom)
            // -----------------------------------------------------
            // When the image is rotated, its axis-aligned bounding box is larger than the original.
            // Compute the bounding box dimensions of the image after rotation (at scale = 1).
            float angle = (float)this.RotationAngle;
            float rad = angle * (MathF.PI / 180f);
            float absCos = MathF.Abs(MathF.Cos(rad));
            float absSin = MathF.Abs(MathF.Sin(rad));
 
            float rotatedWidth = this.bitmap.Width * absCos + this.bitmap.Height * absSin;
            float rotatedHeight = this.bitmap.Width * absSin + this.bitmap.Height * absCos;
 
            // Compute the minimal scale needed so that the rotated image’s bounding box covers the cropRect.
            float minScaleX = cropRect.Width / rotatedWidth;
            float minScaleY = cropRect.Height / rotatedHeight;
            float minScale = MathF.Max(minScaleX, minScaleY);
 
            // Enforce the minimum scale.
            if (this.scale < minScale)
            {
                this.scale = minScale;
            }
 
            // -----------------------------------------------------
            // 2. Adjust the Offset (Translation)
            // -----------------------------------------------------
            // In OnPaintSurface the image is drawn with:
            //   canvas.Translate(offsetX, offsetY);
            //   canvas.Scale(scale);
            //   canvas.Translate(centerX, centerY);
            //   canvas.RotateDegrees(RotationAngle);
            //   canvas.Translate(-centerX, -centerY);
            //
            // This is equivalent to transforming any image point p as:
            //   p' = offset + scale * (center + R*(p - center))
            // where the canvas center is:
            SKPoint Center = new SKPoint(canvasWidth / 2, canvasHeight / 2);
 
            // Compute the transformed (but not offset-adjusted) positions of the image corners.
            float LocalMinX = float.MaxValue;
            float LocalMaxX = float.MinValue;
            float LocalMinY = float.MaxValue;
            float LocalMaxY = float.MinValue;
 
            // The four corners of the original image.
            SKPoint[] Corners =
            [
                new SKPoint(0, 0),
                new SKPoint(this.bitmap.Width, 0),
                new SKPoint(this.bitmap.Width, this.bitmap.Height),
                new SKPoint(0, this.bitmap.Height)
            ];
 
            float cos = MathF.Cos(rad);
            float sin = MathF.Sin(rad);
 
            foreach (SKPoint p in Corners)
            {
                // Compute the vector from the canvas center.
                SKPoint Diff = new SKPoint(p.X - Center.X, p.Y - Center.Y);
                // Rotate the vector.
                SKPoint Rotated = new SKPoint(Diff.X * cos - Diff.Y * sin,
                                              Diff.X * sin + Diff.Y * cos);
                // Apply scaling and add back the canvas center.
                SKPoint TransformedLocal = new SKPoint(
                    this.scale * (Center.X + Rotated.X),
                    this.scale * (Center.Y + Rotated.Y)
                );
 
                LocalMinX = MathF.Min(LocalMinX, TransformedLocal.X);
                LocalMaxX = MathF.Max(LocalMaxX, TransformedLocal.X);
                LocalMinY = MathF.Min(LocalMinY, TransformedLocal.Y);
                LocalMaxY = MathF.Max(LocalMaxY, TransformedLocal.Y);
            }
 
            // The final (drawn) image bounds are the local bounds shifted by the offset.
            float ImageMinX = this.offsetX + LocalMinX;
            float ImageMaxX = this.offsetX + LocalMaxX;
            float ImageMinY = this.offsetY + LocalMinY;
            float ImageMaxY = this.offsetY + LocalMaxY;
 
            // Determine the adjustments needed so that the image bounds fully cover the crop area.
            float DeltaX = 0;
            float DeltaY = 0;
 
            // If the image is too far right (its left edge is right of the crop's left), shift left.
            if (ImageMinX > cropRect.Left)
            {
                DeltaX = cropRect.Left - ImageMinX;
            }
            // Or if the image is too far left (its right edge is left of the crop's right), shift right.
            else if (ImageMaxX < cropRect.Right)
            {
                DeltaX = cropRect.Right - ImageMaxX;
            }
 
            // Do the same for vertical adjustment.
            if (ImageMinY > cropRect.Top)
            {
                DeltaY = cropRect.Top - ImageMinY;
            }
            else if (ImageMaxY < cropRect.Bottom)
            {
                DeltaY = cropRect.Bottom - ImageMaxY;
            }
 
            this.offsetX += DeltaX;
            this.offsetY += DeltaY;
        }
 
 
    }
}