#nullable enable

​

using System;

using System.Collections.Generic;

using System.Drawing;

using System.IO;

using System.Linq;

using System.Net.Http;

using System.Threading.Tasks;

using Newtonsoft.Json;

using SkiaSharp;

​

// WARNING: This downloads a few sample images from a repo in GitHub - if they are slow to

// download then running this may result in an execution-time-limit-exceeded failure. If

// that is the case then trying running it again, it usually works then!

​

// Note that .NET Fiddle runs as Linux for .NET 6 builds, so SkiaSharp is being used instead of

// System.Drawing.Common, which is Windows-only as of .NET 6. Most of the code is same as it

// would be if System.Drawing.Common was the Bitmap type were used, the differences boil down

// largley to type names (eg. SKBitmap and SKColor) and slight differences in how they are

// instantiated - it doesn't affect the logic of code.

​

// The NuGet package SkiaSharp.NativeAssets.Linux.NoDependencies is also required to avoid

// runtime failures when run in this Linux environment.

​

class Program

{

    // Recommended practice is not to instantiate and dispose of a HttpClient on each request

    // - See https://www.aspnetmonsters.com/2016/08/2016-08-27-httpclientwrong/

    static readonly HttpClient _httpClient = new HttpClient();

    static async Task Main()

    {

        // Pick a few sample images to demonstrate - not too many so that .NET Fiddle isn't overloaded

        var imageUrls = new[] { 338, 2075, 7942, 44602 }

            .Select(frameIndex =>

                "https://raw.githubusercontent.com/ProductiveRage/NaivePerspectiveCorrection/main/" +

                "Samples/Frames/frame_" + frameIndex + ".jpg"

            );

​

        var (topLeft, topRight, bottomRight, bottomLeft) =

            (await Task.WhenAll(

                imageUrls.Select(async url =>

                {

                    using var image = await DownloadImage(url);

                    return IlluminatedAreaLocator.GetMostHighlightedArea(image);

                })

            ))

            .GroupBy(area => area)

            .OrderByDescending(group => group.Count())

            .Select(group => group.Key)

            .FirstOrDefault();

​

        Console.WriteLine($"Most common highlighted area: {topLeft}, {topRight}, {bottomRight}, {bottomLeft}");

        const int resizeLargestSideTo = 150;

        var urlToUseForPreview = imageUrls.Last();

        using var previewImage = await DownloadImage(urlToUseForPreview);

        Console.WriteLine();

        Console.Write("Below is a data url that is a shrunken version of one the input frames:");

        Console.WriteLine(" (paste it into your browser address bar to view):");

        Console.WriteLine();

        Console.WriteLine(GenerateDataUrlForResizedVersion(previewImage, resizeLargestSideTo));

        Console.WriteLine();

        Console.WriteLine("Below is a data url that is the masked-out highlighted area from that frame:");

        Console.WriteLine();

        MaskOutArea(previewImage, (topLeft, topRight, bottomRight, bottomLeft));

        Console.WriteLine(GenerateDataUrlForResizedVersion(previewImage, resizeLargestSideTo));

        Console.WriteLine();

        Console.WriteLine("The original (full size) version of the frame is available here:");

        Console.WriteLine();

        Console.WriteLine(urlToUseForPreview);

    }

    static async Task<SKBitmap> DownloadImage(string url)

    {

        using var downloadStream = await _httpClient.GetStreamAsync(url);

        return SKBitmap.Decode(downloadStream);

    }

    static void MaskOutArea(SKBitmap image, (Point P1, Point P2, Point P3, Point P4) area)

    {

        var polygon = new[] { area.P1, area.P2, area.P3, area.P4 };

        var pixels = image.Pixels;

        for (var x = 0; x < image.Width; x++)

        {

            for (var y = 0; y < image.Height; y++)

            {

                if (!IsPointInPolygon(new Point(x, y), polygon))

                    pixels[(y * image.Width) + x] = new SKColor(0, 0, 0);

            }

        }

        image.Pixels = pixels;

​

        // Based on https://stackoverflow.com/a/14998816/3813189

        static bool IsPointInPolygon(Point testPoint, Point[] polygon)

        {

            var result = false;

            var j = polygon.Length - 1;

            for (var i = 0; i < polygon.Length; i++)

            {

                if (((polygon[i].Y < testPoint.Y) && (polygon[j].Y >= testPoint.Y))

                || ((polygon[j].Y < testPoint.Y) && (polygon[i].Y >= testPoint.Y)))

                {

                    var crossingPointForLineOnX =

                        polygon[i].X +

                        ((testPoint.Y - polygon[i].Y) / (float)(polygon[j].Y - polygon[i].Y) * (polygon[j].X - polygon[i].X));

                    if (crossingPointForLineOnX < testPoint.X)

                        result = !result;

                }

                j = i;

            }

            return result;

        }

    }

    static string GenerateDataUrlForResizedVersion(SKBitmap image, int resizeLargestSideTo)

    {

        using var shrunken = image.CopyAndResize(resizeLargestSideTo);

        using var shrunkenData = shrunken.Encode(SKEncodedImageFormat.Jpeg, 80);

        using var memoryStream = new MemoryStream();

        shrunkenData.SaveTo(memoryStream);

        var shrunkenBytes = memoryStream.ToArray();

        return "data:image/jpg;base64," + Convert.ToBase64String(shrunkenBytes);

    }

    static async Task<IEnumerable<(string Filename, Uri Url)>> GetImageFileLocations()

    {

        // The API refuses requests without a User Agent, so set one before calling (see

        // https://docs.github.com/en/rest/overview/resources-in-the-rest-api#user-agent-required)

        using var request = new HttpRequestMessage();

        request.Headers.Add("User-Agent", "Productive Rage Blog Post Example");

        request.RequestUri = new Uri(

            "https://api.github.com/repos/" +

            "ProductiveRage/NaivePerspectiveCorrection/contents/Samples/Frames"

        );

        using var response = await _httpClient.SendAsync(request);

        if (!response.IsSuccessStatusCode)

            throw new Exception("GitHub API rejected request for list of sample images");

        // Deserialise the response into an array of entries that have Name and Download_Url properties

        var namesAndUrls = JsonConvert.DeserializeAnonymousType(

            await response.Content.ReadAsStringAsync(),

            new[] { new { Name = "", Download_Url = (Uri?)null } }

        );

        return namesAndUrls is null

            ? Array.Empty<(string, Uri)>()

            : namesAndUrls

                .Where(entry => entry.Name.EndsWith(".jpg", StringComparison.OrdinalIgnoreCase))

                .Select(entry => (entry.Name, entry.Download_Url!));

    }

}

​

static class BitmapExtensions

{

    /// <summary>

    /// This will return values in the range 0-255 (inclusive)

    /// </summary>

    /// Inspired by https://stackoverflow.com/q/12201577/3813189

    public static DataRectangle<double> GetGreyscale(this SKBitmap image) =>

        image

            .GetAllPixels()

            .Transform(c => (0.2989 * c.Red) + (0.5870 * c.Green) + (0.1140 * c.Blue));

​

    public static SKBitmap CopyAndResize(this SKBitmap image, int resizeLargestSideTo)

    {

        var (width, height) = (image.Width > image.Height)

            ? (resizeLargestSideTo, (int)((double)image.Height / image.Width * resizeLargestSideTo))

            : ((int)((double)image.Width / image.Height * resizeLargestSideTo), resizeLargestSideTo);

​

        var resized = new SKBitmap(width, height);

        image.ScalePixels(resized, SKFilterQuality.High);

        return resized;

    }

​

    public static DataRectangle<SKColor> GetAllPixels(this SKBitmap image)

    {

        var values = new SKColor[image.Width, image.Height];

        var pixels = image.Pixels;

        for (var y = 0; y < image.Height; y++)

        {

            for (var x = 0; x < image.Width; x++)

            {

                values[x, y] = pixels[(y * image.Width) + x];

            }

        }

        return DataRectangle.For(values);

    }

}

​

static class DataRectangle

{

    public static DataRectangle<T> For<T>(T[,] values) => new DataRectangle<T>(values);

}

​

sealed class DataRectangle<T>

{

    readonly T[,] _protectedValues;

    public DataRectangle(T[,] values) : this(values, isolationCopyMayBeBypassed: false) { }

    DataRectangle(T[,] values, bool isolationCopyMayBeBypassed)

    {

        if ((values.GetLowerBound(0) != 0) || (values.GetLowerBound(1) != 0))

            throw new ArgumentException("Both dimensions must have lower bound zero");

        var arrayWidth = values.GetUpperBound(0) + 1;

        var arrayHeight = values.GetUpperBound(1) + 1;

        if ((arrayWidth == 0) || (arrayHeight == 0))

            throw new ArgumentException("zero element arrays are not supported");

​

        Width = arrayWidth;

        Height = arrayHeight;

​

        if (isolationCopyMayBeBypassed)

            _protectedValues = values;

        else

        {

            _protectedValues = new T[Width, Height];

            Array.Copy(values, _protectedValues, Width * Height);

        }

    }

​

    public int Width { get; }

​

    public int Height { get; }

​

    public T this[int x, int y]

    {

        get

        {

            if ((x < 0) || (x >= Width))

                throw new ArgumentOutOfRangeException(nameof(x));

            if ((y < 0) || (y >= Height))

                throw new ArgumentOutOfRangeException(nameof(y));

            return _protectedValues[x, y];

        }

    }

​

    public IEnumerable<(Point Point, T Value)> Enumerate()

    {

        for (var x = 0; x < Width; x++)

        {

            for (var y = 0; y < Height; y++)

            {

                var value = _protectedValues[x, y];

                var point = new Point(x, y);

                yield return (point, value);

            }

        }

    }

​

    public DataRectangle<TResult> Transform<TResult>(Func<T, TResult> transformer)

    {

        var transformed = new TResult[Width, Height];

        for (var x = 0; x < Width; x++)

        {

            for (var y = 0; y < Height; y++)

                transformed[x, y] = transformer(_protectedValues[x, y]);

        }

        return new DataRectangle<TResult>(transformed, isolationCopyMayBeBypassed: true);

    }

}

​

static class DataRectangleOfDoubleExtensions

{

    public static (double Min, double Max) GetMinAndMax(this DataRectangle<double> source) =>

        source

            .Enumerate()

            .Select(pointAndValue => pointAndValue.Value)

            .Aggregate(

                seed: (Min: double.MaxValue, Max: double.MinValue),

                func: (acc, value) => (Math.Min(value, acc.Min), Math.Max(value, acc.Max))

            );

​

    public static DataRectangle<bool> Mask(this DataRectangle<double> values, double threshold) =>

        values.Transform(value => value >= threshold);

}

​

static class IlluminatedAreaLocator

{

    /// <summary>

    /// Return the largest bright area of the image - this should be the projected slide in a presentation

    /// </summary>

    public static (Point TopLeft, Point TopRight, Point BottomRight, Point BottomLeft) GetMostHighlightedArea(

        SKBitmap image,

        int resizeLargestSideToForProcessing = 400)

    {

        using var resizedImage = image.CopyAndResize(resizeLargestSideToForProcessing);

        var greyScaleImageData = resizedImage.GetGreyscale();

​

        // This threshold value was selected somewhat arbitrarily but it seems to work well

        const double thresholdOfRange = 2 / 3d;

        var (min, max) = greyScaleImageData.GetMinAndMax();

        var range = max - min;

        var thresholdForMasking = min + (range * thresholdOfRange);

        var mask = greyScaleImageData.Mask(thresholdForMasking);

​

        var highlightedAreas = GetDistinctObjects(mask);

        if (!highlightedAreas.Any())

            return default;

​

        var pointsInLargestHighlightedArea = highlightedAreas

            .OrderByDescending(points => points.Count())

            .First()

            .Select(p =>

            {

                var distanceFromRight = greyScaleImageData.Width - p.X;

                var distanceFromBottom = greyScaleImageData.Height - p.Y;

                var fromLeftScore = p.X * p.X;

                var fromTopScore = p.Y * p.Y;

                var fromRightScore = distanceFromRight * distanceFromRight;

                var fromBottomScore = distanceFromBottom * distanceFromBottom;

                return new

                {

                    Point = p,

                    FromTopLeft = fromLeftScore + fromTopScore,

                    FromBottomLeft = fromLeftScore + fromBottomScore,

                    FromTopRight = fromRightScore + fromTopScore,

                    FromBottomRight = fromRightScore + fromBottomScore

                };

            })

            .ToArray(); // Call ToArray because we don't want to repeat this work four times below

​

        // Determine how much the image was scaled down (if it had to be scaled down at all) by comparing

        // the width of the potentially-scaled-down data to the source image

        var reducedImageSideBy = (double)image.Width / greyScaleImageData.Width;

        return Resize(

            pointsInLargestHighlightedArea.OrderBy(p => p.FromTopLeft).First().Point,

            pointsInLargestHighlightedArea.OrderBy(p => p.FromTopRight).First().Point,

            pointsInLargestHighlightedArea.OrderBy(p => p.FromBottomRight).First().Point,

            pointsInLargestHighlightedArea.OrderBy(p => p.FromBottomLeft).First().Point,

            reducedImageSideBy,

            minX: 0,

            maxX: image.Width - 1,

            minY: 0,

            maxY: image.Height - 1

        );

    }

​

    static IEnumerable<IEnumerable<Point>> GetDistinctObjects(DataRectangle<bool> mask)

    {

        // Flood fill areas in the mask to create distinct areas

        var allPoints = mask.Enumerate().Where(pointAndIsMasked => pointAndIsMasked.Value)

            .Select(pointAndIsMasked => pointAndIsMasked.Point)

            .ToHashSet();

        while (allPoints.Any())

        {

            var currentPoint = allPoints.First();

            var pointsInObject = GetPointsInObject(currentPoint).ToArray();

            foreach (var point in pointsInObject)

                allPoints.Remove(point);

            yield return pointsInObject;

        }

​

        // Inspired by https://simpledevcode.wordpress.com/2015/12/29/flood-fill-algorithm-using-c-net/

        IEnumerable<Point> GetPointsInObject(Point startAt)

        {

            var pixels = new Stack<Point>();

            pixels.Push(startAt);

​

            var valueAtOriginPoint = mask[startAt.X, startAt.Y];

            var filledPixels = new HashSet<Point>();

            while (pixels.Count > 0)

            {

                var currentPoint = pixels.Pop();

                if ((currentPoint.X < 0) || (currentPoint.X >= mask.Width) || (currentPoint.Y < 0) || (currentPoint.Y >= mask.Height))

                    continue;

​

                if ((mask[currentPoint.X, currentPoint.Y] == valueAtOriginPoint) && !filledPixels.Contains(currentPoint))

                {

                    filledPixels.Add(new Point(currentPoint.X, currentPoint.Y));

                    pixels.Push(new Point(currentPoint.X - 1, currentPoint.Y));

                    pixels.Push(new Point(currentPoint.X + 1, currentPoint.Y));

                    pixels.Push(new Point(currentPoint.X, currentPoint.Y - 1));

                    pixels.Push(new Point(currentPoint.X, currentPoint.Y + 1));

                }

            }

            return filledPixels;

        }

    }

​

    static (Point TopLeft, Point TopRight, Point BottomRight, Point BottomLeft) Resize(

        Point topLeft, Point topRight, Point bottomRight, Point bottomLeft,

        double resizeBy,

        int minX, int maxX, int minY, int maxY)

    {

        if (resizeBy <= 0)

            throw new ArgumentOutOfRangeException("must be a positive value", nameof(resizeBy));

​

        return (

            Constrain(Multiply(topLeft)),

            Constrain(Multiply(topRight)),

            Constrain(Multiply(bottomRight)),

            Constrain(Multiply(bottomLeft))

        );

​

        Point Multiply(Point p) =>

            new Point((int)Math.Round(p.X * resizeBy), (int)Math.Round(p.Y * resizeBy));

​

        Point Constrain(Point p) =>

            new Point(Math.Min(Math.Max(p.X, minX), maxX), Math.Min(Math.Max(p.Y, minY), maxY));

    }

}

​