public void Process(MagickWand wand, double percent)
        {
            var currentImage = wand.CurrentImage;
            var height = currentImage.Height;

            using (var draw = new DrawingWand())
            {
                using (PixelWand pixel = new PixelWand())
                {
                    var endX = currentImage.Width - 1;
                    var endY = height - 1;

                    pixel.Color = "black";
                    pixel.Opacity = 0.4;
                    draw.FillColor = pixel;
                    draw.DrawRectangle(0, endY - IndicatorHeight, endX, endY);

                    double foregroundWidth = endX;
                    foregroundWidth *= percent;
                    foregroundWidth /= 100;

                    pixel.Color = "#52B54B";
                    pixel.Opacity = 0;
                    draw.FillColor = pixel;
                    draw.DrawRectangle(0, endY - IndicatorHeight, Convert.ToInt32(Math.Round(foregroundWidth)), endY);
                    wand.CurrentImage.DrawImage(draw);
                }
            }
        }

 public void SigmoidalTest()
 {
     double[] alpha = { 1, 2, 3, 4 };
     double[] beta = { 0 , 5000, 20000, 30000, 40000, 65000 };
     
     MagickWandEnvironment.Genesis();
     
     foreach(var file in _files)
     {
         using(var wand = new MagickWand(file))
         {
             foreach(var a in alpha)
             {
                 foreach(var b in beta)
                 {
                     using(var tmp = wand.Clone())
                     {
                         tmp.SigmoidalContrastImage(true, a, b);
                         
                         WriteImage("sigmoidal", file, new string[] { a.ToString(), b.ToString() }, tmp);
                     }
                 }
             }
         }
     }
     
     MagickWandEnvironment.Terminus();
 }

        public async Task<ProcessingResult> ProcessPhotoAsync(string filename)
        {
            using(var wand = new MagickWand())
            {
                var srcFile = _pathHelper.GetSourceFilePath(filename);

                if(_rawConverter.IsRawFile(srcFile))
                {
                    var conversionResult = await _rawConverter.ConvertAsync(srcFile);
                    
                    wand.ReadImage(conversionResult.OutputFile);
                    File.Delete(conversionResult.OutputFile);
                } 
                else 
                {
                    wand.ReadImage(srcFile);
                }
                
                wand.AutoOrientImage();
                wand.AutoLevelImage();
                wand.StripImage();
                
                var path = Path.Combine(Path.GetDirectoryName(srcFile), "review", $"{Path.GetFileNameWithoutExtension(filename)}.jpg");

                wand.WriteImage(path, true);
            }
            
            return null;
        }

 public void ContrastTest()
 {
     double[] alpha = { 0, .5, 1, 1.1 };
     double[] beta = { 0 , 5000, 20000, 30000, 40000, 65000 };
     
     MagickWandEnvironment.Genesis();
     
     foreach(var file in _files)
     {
         using(var wand = new MagickWand(file))
         {
             using(var tmp = wand.Clone())
             {
                 tmp.ContrastImage(true);
                 
                 WriteImage("contrast", file, new string[] { "1" }, tmp);
                 
                 tmp.ContrastImage(true);
                 
                 WriteImage("contrast", file, new string[] { "2" }, tmp);
                 
                 tmp.ContrastImage(true);
                 
                 WriteImage("contrast", file, new string[] { "3" }, tmp);
             }
         }
     }
     
     MagickWandEnvironment.Terminus();
 }

        public async Task DrawPlayedIndicator(MagickWand wand, ImageSize imageSize)
        {
            var x = imageSize.Width - OffsetFromTopRightCorner;

            using (var draw = new DrawingWand())
            {
                using (PixelWand pixel = new PixelWand())
                {
                    pixel.Color = "#52B54B";
                    pixel.Opacity = 0.2;
                    draw.FillColor = pixel;
                    draw.DrawCircle(x, OffsetFromTopRightCorner, x - 20, OffsetFromTopRightCorner - 20);

                    pixel.Opacity = 0;
                    pixel.Color = "white";
                    draw.FillColor = pixel;
                    draw.Font = await DownloadFont("webdings.ttf", "https://github.com/MediaBrowser/Emby.Resources/raw/master/fonts/webdings.ttf", _appPaths, _iHttpClient, _fileSystem).ConfigureAwait(false);
                    draw.FontSize = FontSize;
                    draw.FontStyle = FontStyleType.NormalStyle;
                    draw.TextAlignment = TextAlignType.CenterAlign;
                    draw.FontWeight = FontWeightType.RegularStyle;
                    draw.TextAntialias = true;
                    draw.DrawAnnotation(x + 4, OffsetFromTopRightCorner + 14, "a");

                    draw.FillColor = pixel;
                    wand.CurrentImage.DrawImage(draw);
                }
            }
        }

        public void Resize()
        {
            var file = "test3.jpg";

            MagickWandEnvironment.Genesis();

            using(var mw = new MagickWand())
            {
                mw.ReadImage("test.jpg");
                mw.ResizeImage(120, 100, FilterTypes.LanczosFilter, 1);
                mw.WriteImage(file, true);

                Assert.True(File.Exists(file), "scaled image not created");
            }

            using(var mw = new MagickWand(file))
            {
                Assert.True(mw.ImageWidth == 120, "width does not match the expected size");
                Assert.True(mw.ImageHeight == 100, "height does not match the expected size");
            }

            File.Delete(file);

            MagickWandEnvironment.Terminus();
        }

 public void GetFontTest()
 {
     using (var wand = new MagickWand())
     {
         //wand.SetFont("Arial");
         //Debug.WriteLine(wand.GetFont());
     }
 }

 public void CoverArtWandRotateTests()
 {
     using (var wand = new MagickWand(this.TestImageFolder1))
     {
         wand.CurrentImage.RotateImage(new PixelWand("transparent", 1), 30);
         //wand.CurrentImage.TrimImage(10);
         wand.SaveImage(Path.Combine(SaveDirectory, "logo_extent.png"));
     }
 }

 public void MediaBrowserCollectionImageTest()
 {
     string imageOut = "TestCollectionImages.png";
     using (var wandImages = new MagickWand(TestImageFolder1, TestImageFolder2, TestImageFolder3, TestImageFolder4, TestImageFolder1, TestImageFolder2, TestImageFolder3, TestImageFolder4))
     {
         var wandReturn = MediaBrowserWandExtension.MediaBrowserCollectionImage(wandImages);
         wandReturn.SaveImage(Path.Combine(SaveDirectory, imageOut));
     }
 }

 public void SaveResizedImage(int newWidth, string outPath)
 {
     CreateDirectoryForFile(outPath);
      using (MagickWand wand = new MagickWand()) {
         wand.ReadImage(filename);
         wand.TransformImage("", newWidth.ToString());
         wand.WriteImage (outPath);
     }
 }

        public Image(string filename)
        {
            this.filename = filename;

            using (MagickWand wand = new MagickWand()) {
                wand.ReadImage(filename);
                this.width = (int)wand.ImageWidth;
                this.height = (int)wand.ImageHeight;
            }
        }

 public async Task<ProcessingResult> ProcessPhotoAsync(string filename)
 {
     var result = new ProcessingResult();
     var jpgName = Path.ChangeExtension(filename, ".jpg");
     var origPath = _pathHelper.GetSourceFilePath(filename);
     var srcPath = _pathHelper.GetScaledLocalPath(SourceTarget.ScaledPathSegment, filename);
     
     result.ExifData = await _exifReader.ReadExifDataAsync(origPath);
     
     // always keep the original in the source dir
     File.Move(origPath, srcPath);
     result.Source = new ProcessedPhoto { 
         Target = SourceTarget, 
         LocalFilePath = srcPath, 
         WebFilePath = _pathHelper.GetScaledWebFilePath(SourceTarget.ScaledPathSegment, filename)
     };
     
     using(var wand = new MagickWand())
     {
         if(_rawConverter.IsRawFile(srcPath))
         {
             result.RawConversionResult = await _rawConverter.ConvertAsync(srcPath);
             
             wand.ReadImage(result.RawConversionResult.OutputFile);
             File.Delete(result.RawConversionResult.OutputFile);
         } 
         else 
         {
             wand.ReadImage(srcPath);
         }
         
         result.Source.Height = wand.ImageHeight;
         result.Source.Width = wand.ImageWidth;
         
         wand.AutoOrientImage();
         wand.StripImage();
         
         using(var optWand = wand.Clone())
         {
             result.OptimizationResult = _optimizer.Optimize(optWand);
             
             // get the best compression quality for the optimized image
             // (best => smallest size for negligible quality loss)
             result.CompressionQuality = (short)_qualitySearcher.GetOptimalQuality(optWand);
             
             result.Xs = ProcessTarget(wand, optWand, result.CompressionQuality, XsTarget, jpgName);
             result.Sm = ProcessTarget(wand, optWand, result.CompressionQuality, SmTarget, jpgName);
             result.Md = ProcessTarget(wand, optWand, result.CompressionQuality, MdTarget, jpgName);
             result.Lg = ProcessTarget(wand, optWand, result.CompressionQuality, LgTarget, jpgName);
             result.Print = ProcessTarget(wand, optWand, result.CompressionQuality, PrintTarget, jpgName);
         }
     }
     
     return result;
 }

 public void ImageWandImageListTest()
 {
     using (var wand = new MagickWand(this.TestImageLogo, this.TestImageThumb, this.TestImageBackdrop, this.TestImageFolder1, this.TestImageFolder2, this.TestImageFolder3, this.TestImageFolder4))
     {
         foreach (ImageWand imageWand in wand.ImageList)
         {
             imageWand.RotateImage(new PixelWand("", 1), 45);
             imageWand.TrimImage(100);
         }
         wand.SaveImages(Path.Combine(SaveDirectory, "ListOutput.png"));
     }
 }

        public void DrawUnplayedCountIndicator(MagickWand wand, ImageSize imageSize, int count)
        {
            var x = imageSize.Width - OffsetFromTopRightCorner;
            var text = count.ToString(CultureInfo.InvariantCulture);

            using (var draw = new DrawingWand())
            {
                using (PixelWand pixel = new PixelWand())
                {
                    pixel.Color = "#52B54B";
                    pixel.Opacity = 0.2;
                    draw.FillColor = pixel;
                    draw.DrawCircle(x, OffsetFromTopRightCorner, x - 20, OffsetFromTopRightCorner - 20);

                    pixel.Opacity = 0;
                    pixel.Color = "white";
                    draw.FillColor = pixel;
                    draw.Font = PlayedIndicatorDrawer.ExtractFont("robotoregular.ttf", _appPaths, _fileSystem);
                    draw.FontStyle = FontStyleType.NormalStyle;
                    draw.TextAlignment = TextAlignType.CenterAlign;
                    draw.FontWeight = FontWeightType.RegularStyle;
                    draw.TextAntialias = true;

                    var fontSize = 30;
                    var y = OffsetFromTopRightCorner + 11;

                    if (text.Length == 1)
                    {
                        x += 1;
                    }
                    else if (text.Length == 2)
                    {
                        x += 1;
                    }
                    else if (text.Length >= 3)
                    {
                        //x += 1;
                        y -= 2;
                        fontSize = 24;
                    }

                    draw.FontSize = fontSize;
                    draw.DrawAnnotation(x, y, text);

                    draw.FillColor = pixel;
                    wand.CurrentImage.DrawImage(draw);
                }

            }
        }

 public void CoverArtWandShadowTests()
 {
     using (var wand = new MagickWand(TestImageFolder1))
     {
         using (MagickWand nailclone = wand.CloneMagickWand())
         using (var blackPixelWand = new PixelWand(ColorName.Black))
         {
             nailclone.CurrentImage.BackgroundColor = blackPixelWand;
             nailclone.CurrentImage.ShadowImage(80, 5, 5, 5);
             nailclone.CurrentImage.CompositeImage(wand, CompositeOperator.CopyCompositeOp, 0, 0);
             nailclone.SaveImage(Path.Combine(SaveDirectory, "logo_extent.png"));
         }
     }
 }

        public void MediaBrowserClipMaskTest()
        {
            var dest = new MagickWand(100, 100);
            var mask = new MagickWand();
            var src = new MagickWand(100, 100);

            dest.OpenImage(this.TestImageFolder1);
            mask.OpenImage(this.TestImageFolder2);
            mask.CurrentImage.NegateImage(false);
            mask.SaveImage(Path.Combine(SaveDirectory, "TestImageBackdropMask.png"));
            dest.CurrentImage.SetImageClipMask(mask);
            src.OpenImage(this.TestImageBackdrop);
            dest.CurrentImage.CompositeImage(src, CompositeOperator.OverCompositeOp, 0, 0);
            dest.SaveImage(Path.Combine(SaveDirectory, "TestImageBackdrop.png"));
        }

        public void CoverArtWand3DTests()
        {
            using (var wand = new MagickWand(TestImageFolder1))
            {
                var t = wand.CloneMagickWand();
                t.CurrentImage.ShearImage(new PixelWand(ColorHEX.None, 1), 0, 10);
                t.CurrentImage.ExtentImage(t.CurrentImage.Width + 50, t.CurrentImage.Height + 50, -25, -25);
                //RaiseImage
                //wand.CurrentImage.ShadeImage(true, 5, 6);
                //
                wand.CurrentImage.TrimImage(100);
                t.SaveImage(Path.Combine(SaveDirectory, "logo_extent.png"));

            }
        }

        /// <summary>
        /// Gets a System.Drawing.Bitmap from an ImageMagick wand.
        /// </summary>
        /// <param name="wand"></param>
        /// <returns></returns>
        public static System.Drawing.Bitmap MagickGetImageBitmap(MagickWand wand)
        {
            System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(
                (int)MagickGetImageWidth(wand), (int)MagickGetImageHeight(wand));

            System.Drawing.Imaging.BitmapData bmpdat = bmp.LockBits(
                new System.Drawing.Rectangle(0, 0, bmp.Width, bmp.Height),
                System.Drawing.Imaging.ImageLockMode.ReadOnly,
                System.Drawing.Imaging.PixelFormat.Format32bppArgb);

            MagickExportImagePixels(wand, 0, 0, MagickGetImageWidth(wand), MagickGetImageHeight(wand),
                "ARGB", StorageType.CharPixel, bmpdat.Scan0);

            return bmp;
        }

        public void ImageSizeTest()
        {
            var path = TestImageLogo;

            Assert.IsTrue(File.Exists(path));

            using (var wand = new MagickWand(path))
            {
                Debug.WriteLine(wand.CurrentImage.Height);
            }

            using (var wand2 = new MagickWand())
            {
                Assert.IsTrue(wand2.OpenImage(path));
            }
        }

        /// <summary> Round corners. </summary>
        /// <param name="wand"> The wand to act on. </param>
        /// <param name="cofactor"> The cofactor. </param>
        /// <returns> A MagickWand. </returns>
        public static MagickWand RoundCorners(this MagickWand wand, Double cofactor)
        {
            var currentWidth = wand.CurrentImage.Width;
            var currentHeight = wand.CurrentImage.Height;

            var newWand = new MagickWand(currentWidth, currentHeight, new PixelWand(ColorName.None, 1));

            using (var whitePixelWand = new PixelWand(ColorName.White))
            using (var draw = new DrawingWand(whitePixelWand))
            {
                draw.DrawRoundRectangle(0, 0, currentWidth, currentHeight, cofactor, cofactor);
                newWand.CurrentImage.DrawImage(draw);
                newWand.CurrentImage.CompositeImage(wand, CompositeOperator.SrcInCompositeOp, 0, 0);
                return newWand;
            }
        }