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 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 = ExtractFont("webdings.ttf", _appPaths);
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 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 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 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 MediaBrowserWandRoundCornersTest()
{
var cofactor = 15;
using (var wand = new MagickWand(TestImageBackdrop).RoundCorners(cofactor))
wand.SaveImage(Path.Combine(SaveDirectory, "TestImageBackdrop.png"));
}
/// <summary>
/// Draws the indicator.
/// </summary>
/// <param name="wand">The wand.</param>
/// <param name="imageWidth">Width of the image.</param>
/// <param name="imageHeight">Height of the image.</param>
/// <param name="options">The options.</param>
private void DrawIndicator(MagickWand wand, int imageWidth, int imageHeight, ImageProcessingOptions options)
{
if (!options.AddPlayedIndicator && !options.UnplayedCount.HasValue && options.PercentPlayed.Equals(0))
{
return;
}
try
{
if (options.AddPlayedIndicator)
{
var currentImageSize = new ImageSize(imageWidth, imageHeight);
var task = new PlayedIndicatorDrawer(_appPaths, _httpClient, _fileSystem).DrawPlayedIndicator(wand, currentImageSize);
Task.WaitAll(task);
}
else if (options.UnplayedCount.HasValue)
{
var currentImageSize = new ImageSize(imageWidth, imageHeight);
new UnplayedCountIndicator(_appPaths, _fileSystem).DrawUnplayedCountIndicator(wand, currentImageSize, options.UnplayedCount.Value);
}
if (options.PercentPlayed > 0)
{
new PercentPlayedDrawer().Process(wand, options.PercentPlayed);
}
}
catch (Exception ex)
{
_logger.ErrorException("Error drawing indicator overlay", ex);
}
}
public async Task EnhanceImageAsync(IHasImages item, string inputPath, string outputPath, ImageType imageType, int imageIndex)
{
using (MagickWand img = await this.EnhanceImageAsyncInternal(item, new MagickWand(inputPath), imageType, imageIndex))
{
img.SaveImage(outputPath);
}
}
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);
}
}
}
void RegenerateVideoThumbnail(string sourceFile, string destThumb)
{
DumpImageFromVideo(sourceFile, destThumb);
var width = 240;
var height = 160;
using (var wand = new MagickWand(destThumb))
{
float idealAspect = (float)width / (float)height;
float actualAspect = (float)wand.ImageWidth / (float)wand.ImageHeight;
if (idealAspect >= actualAspect)
{
width = (int)(actualAspect * (float)height);
}
else
{
height = (int)((float)width / actualAspect);
}
wand.ScaleImage((uint)width, (uint)height);
// sharpen after potentially resizing
// http://www.imagemagick.org/Usage/resize/#resize_unsharp
wand.UnsharpMaskImage(0, 0.7, 0.7, 0.008);
wand.WriteImage(destThumb, true);
}
}
private MagickWand BuildSquareCollageWand(List <string> paths, int width, int height)
{
var inputPaths = ImageHelpers.ProjectPaths(paths, 4);
var outputWand = new MagickWand(width, height, new PixelWand("none", 1));
var imageIndex = 0;
var cellWidth = width / 2;
var cellHeight = height / 2;
for (var x = 0; x < 2; x++)
{
for (var y = 0; y < 2; y++)
{
using (var temp = new MagickWand(inputPaths[imageIndex]))
{
temp.CurrentImage.ScaleImage(cellWidth, cellHeight);
// draw this image into the strip at the next position
var xPos = x * cellWidth;
var yPos = y * cellHeight;
outputWand.CurrentImage.CompositeImage(temp, CompositeOperator.OverCompositeOp, xPos, yPos);
}
imageIndex++;
}
}
return(outputWand);
}
/// <summary>
/// Gets the image size internal.
/// </summary>
/// <param name="path">The path.</param>
/// <returns>ImageSize.</returns>
private ImageSize GetImageSizeInternal(string path)
{
ImageSize size;
try
{
size = ImageHeader.GetDimensions(path, _logger, _fileSystem);
}
catch
{
_logger.Info("Failed to read image header for {0}. Doing it the slow way.", path);
CheckDisposed();
using (var wand = new MagickWand())
{
wand.PingImage(path);
var img = wand.CurrentImage;
size = new ImageSize
{
Width = img.Width,
Height = img.Height
};
}
}
StartSaveImageSizeTimer();
return(size);
}
public void DrawingWandAnnotationTest()
{
//using (var wand = new MagickWand(TestImageBackdrop))
using (var wand = new MagickWand(400, 100, "#ffffff"))
{
//wand.NewImage(400, 200, new PixelWand("white"));
//wand.OpenImage(TestImageBackdrop);
using (var draw = new DrawingWand())
{
using (PixelWand pixel = new PixelWand("black"))
{
draw.FillColor = pixel;
draw.Font = "Arial";
draw.FontSize = 20;
draw.FontStyle = FontStyleType.NormalStyle;
draw.TextAlignment = TextAlignType.LeftAlign;
draw.FontWeight = FontWeightType.BoldStyle;
draw.TextAntialias = true;
draw.DrawAnnotation(0, 20, "Media Browser");
draw.BorderColor = new PixelWand("red");
//draw.Font = "Times-New-Roman";
//pixel.Color = "Red";
//pixel.Opacity = 0.8;
//draw.FillColor = pixel;
//draw.DrawAnnotation(60, 120, "Tavares");
Debug.WriteLine(draw);
wand.CurrentImage.DrawImage(draw);
}
}
//Debug.WriteLine(wand.GetNumberImages());
//wand.Image.TrimImage(10);
wand.SaveImage(Path.Combine(SaveDirectory, "logo_extent.jpg"));
}
}
void Run()
{
MagickWandEnvironment.Genesis();
var qr = (double)MagickWandEnvironment.QuantumRange;
WriteLine(new string[] { "Quantum Range", $"{qr}" });
Console.WriteLine();
WriteLine(new string[] { "Image Name", "Mean", "StdDev", "Mean (pct)", "StdDev (pct)", "Kurtosis", "Skew" });
foreach (var file in Directory.GetFiles(_opts.PhotoRoot))
{
double mean, stddev, kurtosis, skewness;
using (var wand = new MagickWand(file))
{
wand.AutoLevelImage();
wand.GetImageChannelMean(ChannelType.AllChannels, out mean, out stddev);
wand.GetImageChannelKurtosis(ChannelType.AllChannels, out kurtosis, out skewness);
WriteLine(new string[] { $"{Path.GetFileName(file)}", $"{mean}", $"{stddev}", $"{mean / qr}", $"{stddev / qr}", $"{kurtosis}", $"{skewness}" });
}
}
MagickWandEnvironment.Terminus();
}
public static void RotateImage(MagickWand wand, float angle)
{
using (var pixelWand = new PixelWand("none", 1))
{
wand.CurrentImage.RotateImage(pixelWand, angle);
}
}
public void EncodeImage(string inputPath, string outputPath, int width, int height, int quality, ImageProcessingOptions options)
{
if (string.IsNullOrWhiteSpace(options.BackgroundColor) || !HasTransparency(inputPath))
{
using (var originalImage = new MagickWand(inputPath))
{
originalImage.CurrentImage.ResizeImage(width, height);
DrawIndicator(originalImage, width, height, options);
originalImage.CurrentImage.CompressionQuality = quality;
originalImage.SaveImage(outputPath);
}
}
else
{
using (var wand = new MagickWand(width, height, options.BackgroundColor))
{
using (var originalImage = new MagickWand(inputPath))
{
originalImage.CurrentImage.ResizeImage(width, height);
wand.CurrentImage.CompositeImage(originalImage, CompositeOperator.OverCompositeOp, 0, 0);
DrawIndicator(wand, width, height, options);
wand.CurrentImage.CompressionQuality = quality;
wand.SaveImage(outputPath);
}
}
}
SaveDelay();
}
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();
}
internal static MagickWand MediaBrowserSquareCollectionImage(MagickWand wandImages)
{
int width = 540;
int height = 540;
var wand = new MagickWand(width, height);
wand.OpenImage("gradient:#000000-#202020");
using (var draw = new DrawingWand())
{
var iSlice = Convert.ToInt32(width * .225);
int iTrans = Convert.ToInt32(height * .25);
int iHeight = Convert.ToInt32(height * .63);
var horizontalImagePadding = Convert.ToInt32(width * 0.02);
foreach (var element in wandImages.ImageList)
{
using (var blackPixelWand = new PixelWand(ColorName.Black))
{
int iWidth = (int)Math.Abs(iHeight * element.Width / element.Height);
element.Gravity = GravityType.CenterGravity;
element.BackgroundColor = blackPixelWand;
element.ResizeImage(iWidth, iHeight, FilterTypes.LanczosFilter);
int ix = (int)Math.Abs((iWidth - iSlice) / 2);
element.CropImage(iSlice, iHeight, ix, 0);
element.ExtentImage(iSlice, iHeight, 0 - horizontalImagePadding, 0);
}
}
wandImages.SetFirstIterator();
using (var wandList = wandImages.AppendImages())
{
wandList.CurrentImage.TrimImage(1);
using (var mwr = wandList.CloneMagickWand())
using (var blackPixelWand = new PixelWand(ColorName.Black))
using (var greyPixelWand = new PixelWand(ColorName.Grey70))
{
mwr.CurrentImage.ResizeImage(wandList.CurrentImage.Width, (wandList.CurrentImage.Height / 2), FilterTypes.LanczosFilter, 1);
mwr.CurrentImage.FlipImage();
mwr.CurrentImage.AlphaChannel = AlphaChannelType.DeactivateAlphaChannel;
mwr.CurrentImage.ColorizeImage(blackPixelWand, greyPixelWand);
using (var mwg = new MagickWand(wandList.CurrentImage.Width, iTrans))
{
mwg.OpenImage("gradient:black-none");
var verticalSpacing = Convert.ToInt32(height * 0.01111111111111111111111111111111);
mwr.CurrentImage.CompositeImage(mwg, CompositeOperator.CopyOpacityCompositeOp, 0, verticalSpacing);
wandList.AddImage(mwr);
int ex = (int)(wand.CurrentImage.Width - mwg.CurrentImage.Width) / 2;
wand.CurrentImage.CompositeImage(wandList.AppendImages(true), CompositeOperator.AtopCompositeOp, ex, Convert.ToInt32(height * .07));
}
}
}
}
return(wand);
}
public void SetFontTest()
{
using (var wand = new MagickWand())
{
//wand.SetFont("Arial");
//Debug.WriteLine(wand.GetFont());
}
}
public void MediaBrowserWandCropWhitespaceTests()
{
using (var wand = new MagickWand(TestImageLogo))
{
wand.CurrentImage.TrimImage(10);
wand.SaveImage(Path.Combine(SaveDirectory, "TestImageBackdrop.png"));
}
}
public void GetFontTest()
{
using (var wand = new MagickWand())
{
//wand.SetFont("Arial");
//Debug.WriteLine(wand.GetFont());
}
}
public void NewImageTest2()
{
using (var wand = new MagickWand(100, 100, "#ffffff"))
{
//wand.NewImage(100, 100, "#ffffff");
wand.SaveImage(Path.Combine(SaveDirectory, "TestSetBackgroundColor.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 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 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"));
}
}
private MagickWand BuildThumbCollageWand(IEnumerable <string> paths, int width, int height)
{
var inputPaths = ProjectPaths(paths, 8);
using (var wandImages = new MagickWand(inputPaths))
{
var wand = new MagickWand(width, height);
wand.OpenImage("gradient:#111111-#111111");
using (var draw = new DrawingWand())
{
var iSlice = Convert.ToInt32(width * .1166666667);
int iTrans = Convert.ToInt32(height * .25);
int iHeight = Convert.ToInt32(height * .6);
var horizontalImagePadding = Convert.ToInt32(width * 0.0125);
foreach (var element in wandImages.ImageList)
{
int iWidth = (int)Math.Abs(iHeight * element.Width / element.Height);
element.Gravity = GravityType.CenterGravity;
element.BackgroundColor = ColorName.Black;
element.ResizeImage(iWidth, iHeight, FilterTypes.LanczosFilter);
int ix = (int)Math.Abs((iWidth - iSlice) / 2);
element.CropImage(iSlice, iHeight, ix, 0);
element.ExtentImage(iSlice, iHeight, 0 - horizontalImagePadding, 0);
}
wandImages.SetFirstIterator();
using (var wandList = wandImages.AppendImages())
{
wandList.CurrentImage.TrimImage(1);
using (var mwr = wandList.CloneMagickWand())
{
mwr.CurrentImage.ResizeImage(wandList.CurrentImage.Width, (wandList.CurrentImage.Height / 2), FilterTypes.LanczosFilter, 1);
mwr.CurrentImage.FlipImage();
mwr.CurrentImage.AlphaChannel = AlphaChannelType.DeactivateAlphaChannel;
mwr.CurrentImage.ColorizeImage(ColorName.Black, ColorName.Grey60);
using (var mwg = new MagickWand(wandList.CurrentImage.Width, iTrans))
{
mwg.OpenImage("gradient:black-none");
var verticalSpacing = Convert.ToInt32(height * 0.01111111111111111111111111111111);
mwr.CurrentImage.CompositeImage(mwg, CompositeOperator.CopyOpacityCompositeOp, 0, verticalSpacing);
wandList.AddImage(mwr);
int ex = (int)(wand.CurrentImage.Width - mwg.CurrentImage.Width) / 2;
wand.CurrentImage.CompositeImage(wandList.AppendImages(true), CompositeOperator.AtopCompositeOp, ex, Convert.ToInt32(height * .1));
}
}
}
}
return(wand);
}
}
public void CropWhiteSpace(string inputPath, string outputPath)
{
CheckDisposed();
using (var wand = new MagickWand(inputPath))
{
wand.CurrentImage.TrimImage(10);
wand.SaveImage(outputPath);
}
}
public void MediaBrowserCollectionImageWithTextTest()
{
string imageOut = "TestCollectionImages.png";
using (var wandImages = new MagickWand(TestImageFolder1, TestImageFolder2, TestImageFolder3, TestImageFolder4, TestImageFolder1, TestImageFolder2, TestImageFolder3, TestImageFolder4))
{
var wandReturn = MediaBrowserWandExtension.MediaBrowserCollectionImageWithText(wandImages, "Collections", MontserratLightFont);
wandReturn.SaveImage(Path.Combine(SaveDirectory, imageOut));
}
}
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 void MediaBrowserSquareCollectionImageTest()
{
string imageOut = "TestCollectionImages.png";
using (var wandImages = new MagickWand(TestImageFolder1, TestImageFolder2, TestImageFolder3, TestImageFolder4))
{
var wandReturn = MediaBrowserWandExtension.MediaBrowserSquareCollectionImage(wandImages);
wandReturn.SaveImage(Path.Combine(SaveDirectory, imageOut));
}
}
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;
}
internal static Stream GetStream(MagickWand image, IApplicationPaths appPaths)
{
var tempFile = Path.Combine(appPaths.TempDirectory, Guid.NewGuid().ToString("N") + ".png");
Directory.CreateDirectory(Path.GetDirectoryName(tempFile));
image.CurrentImage.CompressionQuality = 100;
image.SaveImage(tempFile);
return(File.OpenRead(tempFile));
}
public void SaveImagesTest()
{
var path = TestImageLogo;
Assert.IsTrue(File.Exists(path));
using (var wand = new MagickWand(path))
{
wand.SaveImages(Path.Combine(SaveDirectory, "logo.png"), true);
}
}
public void OpenImageTestWebp()
{
var path = TestImageFolder5;
Assert.IsTrue(File.Exists(path));
using (var wand = new MagickWand(path))
{
wand.SaveImage(Path.Combine(SaveDirectory, "test.png"));
}
}
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"));
}
}
private void ScaleImage(MagickWand wand, int width, int height)
{
wand.CurrentImage.ResizeImage(width, height);
//if (_config.Configuration.EnableHighQualityImageScaling)
//{
// wand.CurrentImage.ResizeImage(width, height);
//}
//else
//{
// wand.CurrentImage.ScaleImage(width, height);
//}
}
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 EncodeImage(string inputPath, string outputPath, bool autoOrient, int width, int height, int quality, ImageProcessingOptions options, ImageFormat selectedOutputFormat)
{
// Even if the caller specified 100, don't use it because it takes forever
quality = Math.Min(quality, 99);
if (string.IsNullOrWhiteSpace(options.BackgroundColor) || !HasTransparency(inputPath))
{
using (var originalImage = new MagickWand(inputPath))
{
ScaleImage(originalImage, width, height);
if (autoOrient)
{
AutoOrientImage(originalImage);
}
AddForegroundLayer(originalImage, options);
DrawIndicator(originalImage, width, height, options);
originalImage.CurrentImage.CompressionQuality = quality;
originalImage.CurrentImage.StripImage();
originalImage.SaveImage(outputPath);
}
}
else
{
using (var wand = new MagickWand(width, height, options.BackgroundColor))
{
using (var originalImage = new MagickWand(inputPath))
{
ScaleImage(originalImage, width, height);
if (autoOrient)
{
AutoOrientImage(originalImage);
}
wand.CurrentImage.CompositeImage(originalImage, CompositeOperator.OverCompositeOp, 0, 0);
AddForegroundLayer(wand, options);
DrawIndicator(wand, width, height, options);
wand.CurrentImage.CompressionQuality = quality;
wand.CurrentImage.StripImage();
wand.SaveImage(outputPath);
}
}
}
SaveDelay();
}
public static async Task <Stream> GetThumbCollage(List <string> files,
IFileSystem fileSystem,
int width,
int height, IApplicationPaths appPaths)
{
if (files.Any(string.IsNullOrWhiteSpace))
{
throw new ArgumentException("Empty file found in files list");
}
if (files.Count == 0)
{
return(null);
}
if (files.Count < 3)
{
return(await GetSingleImage(files, fileSystem).ConfigureAwait(false));
}
const int rows = 1;
const int cols = 3;
int cellWidth = 2 * (width / 3);
int cellHeight = height;
var index = 0;
using (var wand = new MagickWand(width, height, new PixelWand(ColorName.None, 1)))
{
for (var row = 0; row < rows; row++)
{
for (var col = 0; col < cols; col++)
{
var x = col * (cellWidth / 2);
var y = row * cellHeight;
if (files.Count > index)
{
using (var innerWand = new MagickWand(files[index]))
{
innerWand.CurrentImage.ResizeImage(cellWidth, cellHeight);
wand.CurrentImage.CompositeImage(innerWand, CompositeOperator.OverCompositeOp, x, y);
}
}
index++;
}
}
return(GetStream(wand, appPaths));
}
}
private void ScaleImage(MagickWand wand, int width, int height, int blur)
{
var useResize = blur > 1;
if (useResize)
{
wand.CurrentImage.ResizeImage(width, height, FilterTypes.GaussianFilter, blur);
}
else
{
wand.CurrentImage.ScaleImage(width, height);
}
}
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"));
}
/// <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 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"));
}
}
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));
}
}
public void SaveResizedImage(int newWidth, int newHeight, string outPath)
{
CreateDirectoryForFile(outPath);
using (MagickWand wand = new MagickWand()) {
wand.ReadImage(filename);
if (width > newWidth && height > newHeight) {
wand.ResizeImage((uint)newWidth, (uint)newHeight);
} else {
// XXX: Make a new image that's newwidth by newheight
// and center old image in it
}
wand.WriteImage (outPath);
}
}
/// <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;
}
}
public void ImageWandCreateManyTest()
{
using (var wand = new MagickWand())
using (var yellowPixelWand = new PixelWand("yellow"))
using (var blackPixelWand = new PixelWand("black", 0.5))
{
wand.NewImage(200, 200, "Blue");
wand.CurrentImage.DrawRoundRectangle(10, 10, wand.CurrentImage.Width - 10, 70, 5, 5, yellowPixelWand, blackPixelWand);
wand.NewImage(200, 200, "red");
wand.CurrentImage.DrawRoundRectangle(10, 10, wand.CurrentImage.Width - 10, 70, 5, 5, yellowPixelWand, blackPixelWand);
wand.NewImage(200, 200, "green");
wand.CurrentImage.DrawRoundRectangle(10, 10, wand.CurrentImage.Width - 10, 70, 5, 5, yellowPixelWand, blackPixelWand);
wand.SaveImages(Path.Combine(SaveDirectory, "logo_extent.jpg"));
}
}
public void ImageWandImageClassTest()
{
using (var wand = new MagickWand())
using (var yellowPixelWand = new PixelWand("yellow"))
using (var blackPixelWand = new PixelWand("black", 0.5))
{
wand.NewImage(200, 200, "Blue");
wand.CurrentImage.DrawRoundRectangle(10, 10, wand.CurrentImage.Width - 10, 70, 5, 5, yellowPixelWand, blackPixelWand);
var t = wand.GetImage();
//wand.Image.RotateImage("red", 45);
//t.RotateImage("red", 45);
t.SaveImages(Path.Combine(SaveDirectory, "logo_extent.jpg"));
wand.SaveImages(Path.Combine(SaveDirectory, "logo_extent.jpg"));
}
}
public void MediaBrowserResizeImageTest()
{
using (var wand = new MagickWand(TestImageBackdrop))
{
var w = wand.CurrentImage.Width;
var h = wand.CurrentImage.Height;
using (var mwr = wand.CloneMagickWand())
{
var newW = 1280;
var newH = 720;
mwr.CurrentImage.ResizeImage(newW, newH);
mwr.CurrentImage.StripImage();
mwr.SaveImage(Path.Combine(SaveDirectory, Guid.NewGuid().ToString() + ".jpg"));
}
}
}
private void TestWebp()
{
try
{
var tmpPath = Path.Combine(_appPaths.TempDirectory, Guid.NewGuid() + ".webp");
_fileSystem.CreateDirectory(Path.GetDirectoryName(tmpPath));
using (var wand = new MagickWand(1, 1, new PixelWand("none", 1)))
{
wand.SaveImage(tmpPath);
}
}
catch
{
//_logger.ErrorException("Error loading webp: ", ex);
_webpAvailable = false;
}
}
public void DrawingWandCircleTest()
{
using (var wand = new MagickWand(TestImageBackdrop))
{
//wand.NewImage(400, 200, new PixelWand("white"));
//wand.OpenImage(TestImageBackdrop);
using (var draw = new DrawingWand())
{
using (PixelWand pixel = new PixelWand())
{
pixel.Color = "red";
draw.StrokeColor = pixel;
pixel.Color = "black";
pixel.Opacity = 0.3;
draw.FillColor = pixel;
draw.DrawCircle(400, 400, 300, 300);
pixel.Color = "transparent";
draw.StrokeColor = pixel;
pixel.Color = "white";
draw.FillColor = pixel;
draw.Font = "Verdana";
draw.FontSize = 120;
draw.FontStyle = FontStyleType.NormalStyle;
draw.TextAlignment = TextAlignType.LeftAlign;
draw.FontWeight = FontWeightType.BoldStyle;
draw.TextAntialias = true;
draw.DrawAnnotation(10, 100, "Media Browser");
draw.FillColor = pixel;
wand.CurrentImage.DrawImage(draw);
}
}
//Debug.WriteLine(wand.GetNumberImages());
//wand.Image.TrimImage(10);
wand.SaveImage(Path.Combine(SaveDirectory, "logo_extent.jpg"));
}
}
public void TestWrapperAndStringQueryFuncs()
{
MagickWandEnvironment.Genesis();
using(var mi = new MagickWand())
{
mi.ReadImage(TestHelper.TEST_FILE);
var list = mi.GetImageProperties(string.Empty);
Assert.True(list != null, "the list should not be null");
Assert.True(list.Count > 0, "there should be more than 1 profile");
foreach(var item in list)
{
Console.WriteLine($"profile: {item}");
}
}
MagickWandEnvironment.Terminus();
}
public void ExtendcanvasaroundimageTest()
{
var path = TestImageThumb;
Assert.IsTrue(File.Exists(path));
using (var wand = new MagickWand(path))
{
wand.OpenImage(path);
var w = wand.CurrentImage.Width;
var h = wand.CurrentImage.Height;
using (PixelWand newPixelWand = new PixelWand("blue"))
{
wand.CurrentImage.BackgroundColor = newPixelWand;
}
wand.CurrentImage.ExtentImage(1024, 768, -(1024 - w) / 2, -(768 - h) / 2);
wand.SaveImage(Path.Combine(SaveDirectory, "logo_extent.jpg"));
}
}
/// <summary> A MagickWand extension method that cover art stack. </summary>
/// <param name="wand"> The wand. </param>
/// <param name="xIncrement"> Amount to increment by. </param>
/// <param name="yIncrement"> Amount to increment by. </param>
/// <param name="width"> The width. </param>
/// <param name="height"> The height. </param>
/// <param name="images"> A variable-length parameters list containing images. </param>
private static void CoverArtStack(this MagickWand wand, double xIncrement, double yIncrement, double width, double height, params string[] images)
{
using (var draw = new DrawingWand())
{
double x = 0;
double y = 0;
using (var wandimages = new MagickWand(images))
{
foreach (ImageWand imageWand in wandimages.ImageList)
{
using (var blackPixelWand = new PixelWand("black"))
{
imageWand.BorderImage(blackPixelWand, 2, 2);
draw.DrawComposite(CompositeOperator.AtopCompositeOp, x, y, width, height, imageWand);
x += xIncrement;
y += yIncrement;
}
}
}
wand.CurrentImage.DrawImage(draw);
}
}
public uint GetOptimalQuality(MagickWand wand)
{
var tmp = $"{Path.GetTempFileName()}.jpg";
try
{
using(var tmpWand = wand.Clone())
{
tmpWand.CompressionQuality = MAX_QUALITY;
wand.WriteImage(tmp, true);
}
var opts = new ImgminOptions
{
ErrorThreshold = 0.08
};
var imgmin = new Imgmin(opts);
var result = imgmin.Minify(tmp, tmp);
if(!_quiet)
{
Console.WriteLine(result.StandardOutput);
}
// the following has not been reliable, so figure out the
// quality based on opening the tmp file.
//return Convert.ToUInt32(result.StatsAfter.Quality);
using(var qualWand = new MagickWand(tmp))
{
return qualWand.ImageCompressionQuality;
}
}
finally
{
File.Delete(tmp);
}
}
