MARKUS

using KCOM.Common;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Media;

using System.Windows.Media.Imaging;

namespace KCOM.Controls

{

   // [TemplatePart(Name = PART_IMAGE, Type = typeof(Image))]

    public class ScaleDecodeImage : System.Windows.Controls.Control

    {

        // private const string PART_IMAGE = "PART_IMAGE";

        //private Image ImageControl;

        private List<ScaleImage> scaleImages = new List<ScaleImage>();

        public override void OnApplyTemplate()

        {

            base.OnApplyTemplate();

            //ImageControl = GetTemplateChild(PART_IMAGE) as Image;

        }

        public static readonly DependencyProperty ViewSourceProperty = DependencyProperty.Register(

                    "ViewSource", typeof(ImageSource), typeof(ScaleDecodeImage));

        public ImageSource ViewSource

        {

            get => (ImageSource)GetValue(ViewSourceProperty);

            set => SetValue(ViewSourceProperty, value);

        }

        public static readonly DependencyProperty SourceProperty = DependencyProperty.Register(

                    "Source", typeof(BitmapImage), typeof(ScaleDecodeImage), new PropertyMetadata(new PropertyChangedCallback(SourcePropertyChaged)));

        public BitmapImage Source

        {

            get => (BitmapImage)GetValue(SourceProperty);

            set => SetValue(SourceProperty, value);

        }

        private static void SourcePropertyChaged(DependencyObject d, DependencyPropertyChangedEventArgs e)

        {

            var owner = d as ScaleDecodeImage;

            if (owner != null)

            {

                if (e.NewValue != null)

                {

                    owner.scaleImages = new List<ScaleImage>();

                    owner.ViewSource = (BitmapImage)e.NewValue;

                    owner.Scale = 1.0;

                }

            }

        }

        public static readonly DependencyProperty ScaleProperty = DependencyProperty.Register(

                    "Scale", typeof(double), typeof(ScaleDecodeImage), new PropertyMetadata(0.0, new PropertyChangedCallback(ScalePropertyChaged)));

        public double Scale

        {

            get => (double)GetValue(ScaleProperty);

            set => SetValue(ScaleProperty, value);

        }

        private static async void ScalePropertyChaged(DependencyObject d, DependencyPropertyChangedEventArgs e)

        {

            var owner = d as ScaleDecodeImage;

            if (owner != null)

            {

                var value = owner.Scale;

                var scaleImage = owner.scaleImages.Where(x => x.Scale == value);

                if (scaleImage.Count() > 0)

                {

                    owner.ViewSource = scaleImage.First().source;

                }

                else

                {

                    await owner.Dispatcher.InvokeAsync(() =>

                    {

                        if (value < 1)

                        {

                            TransformedBitmap tb = new TransformedBitmap();

                            tb.BeginInit();

                            tb.Source = owner.Source;

                            tb.Transform = new ScaleTransform(value, value);

                            tb.EndInit();

                            byte[] pixels = ImageSourceHelper.CopyPixels(tb);

                            var brightness = (double)(value * 100) / (double)100 * (double)100 - 80;

                            if (brightness < -30)

                            {

                                pixels = ImageSourceHelper.SetBrightnessAndContrast((int)brightness, brightness * -1.0, pixels);

                                //pixels = ImageSourceHelper.SetContrast(brightness * -1.0, pixels);

                                var bmp = new WriteableBitmap(tb.PixelWidth, tb.PixelHeight, tb.DpiX, tb.DpiY, PixelFormats.Pbgra32, null);

                                bmp.WritePixels(new Int32Rect(0, 0, tb.PixelWidth, tb.PixelHeight), pixels, tb.PixelWidth * 4, 0);

                                owner.ViewSource = bmp;

                            }

                            else

                            {

                                owner.ViewSource = tb;

                            }

                            owner.scaleImages.Add(new ScaleImage { Scale = value, source = owner.ViewSource });

                            System.Diagnostics.Debug.WriteLine($"TranFormImage Height : {tb.Height} Scale : {value}  brightness : {brightness}");

                        }

                    });

                }

            }

        }

    }

    public class ScaleImage

    {

        public ImageSource source { get; set; }

        public double Scale { get; set; }

    }

}