MARKUS

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows.Media;

using System.Windows.Media.Imaging;

namespace KCOM.Common

{

    public static class ImageSourceHelper

    {

        public static async System.Threading.Tasks.Task<BitmapImage> GetDownloadImageAsync(Uri uri, double pageWidth, double pageHeight)

        {

            System.Net.Http.HttpClient httpClient = null;

            System.IO.Stream responseStream = null;

            System.IO.MemoryStream memoryStream = null;

            BitmapImage image = null;

            try

            {

                using (httpClient = new System.Net.Http.HttpClient())

                {

                    using (responseStream = await httpClient.GetStreamAsync(uri))

                    {

                        using (memoryStream = new System.IO.MemoryStream())

                        {

                            System.Diagnostics.Debug.WriteLine("이미지 다운로드");

                            await responseStream.CopyToAsync(memoryStream);

                            image = new BitmapImage();

                            image.BeginInit();

                            image.CacheOption = BitmapCacheOption.OnLoad;

                            image.StreamSource = memoryStream;

                            image.DecodePixelWidth = (int)pageWidth;

                            image.DecodePixelHeight = (int)pageHeight;

                            image.EndInit();

                            image.Freeze();

                            return image;

                        }

                    }

                }

            }

            catch (Exception ex)

            {

                throw new Exception("Image Load Error ", ex);

            }

            finally

            {

                httpClient?.Dispose();

                responseStream?.Dispose();

                memoryStream?.Dispose();

                image = null;

            }

        }

        public static BitmapImage GetDownloadImage(string uri)

        {

           return GetDownloadImage(new Uri(uri));

        }

        public static BitmapImage GetDownloadImage(Uri uri)

        {

            BitmapImage resultImage = new BitmapImage();

            resultImage.BeginInit();

            resultImage.CacheOption = BitmapCacheOption.OnLoad;

            resultImage.UriCachePolicy = new System.Net.Cache.RequestCachePolicy(System.Net.Cache.RequestCacheLevel.Default);

            resultImage.UriSource = uri;

            resultImage.EndInit();

            resultImage.DownloadProgress += (ex, arg) =>

            {

                System.Diagnostics.Debug.WriteLine($"download Image : {arg.Progress}%");

            };

            while (resultImage.IsDownloading)

            {

                System.Windows.Forms.Application.DoEvents(); //Method from thread linked above

                System.Diagnostics.Debug.WriteLine("doEvent");

            }

            resultImage.Freeze();

            return resultImage;

        }

        public static byte[] CopyPixels(BitmapSource image)

        {

            byte[] result = new byte[image.PixelWidth * image.PixelHeight * 4];

            image.CopyPixels(result, image.PixelWidth * 4, 0);

            return result;

        }

        public static byte[] SetBrightness(int brightness, byte[] pixels)

        {

            for (int i = 0; i < pixels.Length / 4; ++i)

            {

                byte b = pixels[i * 4];

                byte g = pixels[i * 4 + 1];

                byte r = pixels[i * 4 + 2];

                byte a = pixels[i * 4 + 3];

                if (r != 255 || g != 255 || b != 255 || a == 255)

                {

                    b = (byte)(b + brightness);

                    g = (byte)(g + brightness);

                    r = (byte)(r + brightness);

                    ///a = (byte)(a + brightness);

                    if (r < 0) r = 1;

                    if (r > 255) r = 255;

                    if (g < 0) g = 1;

                    if (g > 255) g = 255;

                    if (b < 0) b = 1;

                    if (b > 255) b = 255;

                    pixels[i * 4] = b;

                    pixels[i * 4 + 1] = g;

                    pixels[i * 4 + 2] = r;

                }

            }

            return pixels;

        }

        public static byte[] SetBrightnessAndContrast(int brightness,double contrast, byte[] pixels)

        {

            System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch();

            stopwatch.Start();

            if (contrast < -100) contrast = -100;

            if (contrast > 100) contrast = 100;

            contrast = (100.0 + contrast) / 100.0;

            contrast *= contrast;

            for (int i = 0; i < pixels.Length / 4; ++i)

            {

                byte b = pixels[i * 4];

                byte g = pixels[i * 4 + 1];

                byte r = pixels[i * 4 + 2];

                byte a = pixels[i * 4 + 3];

                //System.Diagnostics.Debug.WriteLineIf(i< 4, $"B :{b} G : {g} r : {r}");

                if (r != 255 || g != 255 || b != 255)

                {

                    b = (byte)(b + brightness);

                    g = (byte)(g + brightness);

                    r = (byte)(r + brightness);

                    ///a = (byte)(a + brightness);

                    if (r < 0) r = 1;

                    if (r > 255) r = 255;

                    if (g < 0) g = 1;

                    if (g > 255) g = 255;

                    if (b < 0) b = 1;

                    if (b > 255) b = 255;

                    double pR = r / 255.0;

                    pR -= 0.5;

                    pR *= contrast;

                    pR += 0.5;

                    pR *= 255;

                    if (pR < 0) pR = 0;

                    if (pR > 255) pR = 255;

                    double pG = g / 255.0;

                    pG -= 0.5;

                    pG *= contrast;

                    pG += 0.5;

                    pG *= 255;

                    if (pG < 0) pG = 0;

                    if (pG > 255) pG = 255;

                    double pB = b / 255.0;

                    pB -= 0.5;

                    pB *= contrast;

                    pB += 0.5;

                    pB *= 255;

                    if (pB < 0) pB = 0;

                    if (pB > 255) pB = 255;

                    pixels[i * 4] = (byte)pB;

                    pixels[i * 4 + 1] = (byte)pG;

                    pixels[i * 4 + 2] = (byte)pR;

              }

            }

            System.Diagnostics.Debug.WriteLine($"일반 : {stopwatch.Elapsed.ToString()}");

            return pixels;

        }

        public static byte[] SetBrightnessAndContrastLinp(int brightness, double contrast, byte[] pixels)

        {

            System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch();

            stopwatch.Start();

            if (contrast < -100) contrast = -100;

            if (contrast > 100) contrast = 100;

            contrast = (100.0 + contrast) / 100.0;

            contrast *= contrast;

            Parallel.ForEach(SteppedIntegerList(pixels,0, pixels.Length, 4,4),new ParallelOptions {MaxDegreeOfParallelism = 5 }, item=>

            {

                var pixel = item.ToList();

                byte b = pixel[0].Value;

                byte g = pixel[1].Value;

                byte r = pixel[2].Value;

                byte a = pixel[3].Value;

                //System.Diagnostics.Debug.WriteLineIf(pixel[0].Key < 4, $"B :{b} G : {g} r : {r}");

                if (r != 255 || g != 255 || b != 255)

                {

                    b = (byte)(b + brightness);

                    g = (byte)(g + brightness);

                    r = (byte)(r + brightness);

                    ///a = (byte)(a + brightness);

                    if (r < 0) r = 1;

                    if (r > 255) r = 255;

                    if (g < 0) g = 1;

                    if (g > 255) g = 255;

                    if (b < 0) b = 1;

                    if (b > 255) b = 255;

                    double pR = r / 255.0;

                    pR -= 0.5;

                    pR *= contrast;

                    pR += 0.5;

                    pR *= 255;

                    if (pR < 0) pR = 0;

                    if (pR > 255) pR = 255;

                    double pG = g / 255.0;

                    pG -= 0.5;

                    pG *= contrast;

                    pG += 0.5;

                    pG *= 255;

                    if (pG < 0) pG = 0;

                    if (pG > 255) pG = 255;

                    double pB = b / 255.0;

                    pB -= 0.5;

                    pB *= contrast;

                    pB += 0.5;

                    pB *= 255;

                    if (pB < 0) pB = 0;

                    if (pB > 255) pB = 255;

                    pixels[pixel[0].Key] = (byte)pB;

                    pixels[pixel[1].Key] = (byte)pG;

                    pixels[pixel[2].Key] = (byte)pR;

                }

            });

            System.Diagnostics.Debug.WriteLine($"Linq : {stopwatch.Elapsed.ToString()}");

            return pixels;

        }

        public static IEnumerable<Dictionary<int,T>> SteppedIntegerList<T>(T[] array, int startIndex,int endEndex, int stepSize,int TakeSize)

        {

            for (int i = startIndex; i < endEndex; i += stepSize)

            {

                Dictionary<int, T> result = new Dictionary<int, T>();

                for (int j = 0; j < TakeSize; j++)

                {

                    result.Add(j, array[i + j]);

                }

                yield return result;

            }

        }

        public static byte[] SetContrast(double contrast, byte[] pixels)

        {

            if (contrast < -100) contrast = -100;

            if (contrast > 100) contrast = 100;

            contrast = (100.0 + contrast) / 100.0;

            contrast *= contrast;

            for (int i = 0; i < pixels.Length / 4; ++i)

            {

                byte b = pixels[i * 4];

                byte g = pixels[i * 4 + 1];

                byte r = pixels[i * 4 + 2];

                byte a = pixels[i * 4 + 3];

                if (r != 255 || g != 255 || b != 255 || a == 255)

                {

                    double pR = r / 255.0;

                    pR -= 0.5;

                    pR *= contrast;

                    pR += 0.5;

                    pR *= 255;

                    if (pR < 0) pR = 0;

                    if (pR > 255) pR = 255;

                    double pG = g / 255.0;

                    pG -= 0.5;

                    pG *= contrast;

                    pG += 0.5;

                    pG *= 255;

                    if (pG < 0) pG = 0;

                    if (pG > 255) pG = 255;

                    double pB = b / 255.0;

                    pB -= 0.5;

                    pB *= contrast;

                    pB += 0.5;

                    pB *= 255;

                    if (pB < 0) pB = 0;

                    if (pB > 255) pB = 255;

                    pixels[i * 4] = (byte)pB;

                    pixels[i * 4 + 1] = (byte)pG;

                    pixels[i * 4 + 2] = (byte)pR;

                }

            }

            return pixels;

        }

    }

}