public void ShouldCreateMagickImage()
{
var factory = new MagickImageFactory();
var data = FileHelper.ReadAllBytes(Files.ImageMagickJPG);
using (var image = factory.Create(data, 0, data.Length))
{
Assert.IsType <MagickImage>(image);
Assert.Equal(123, image.Width);
}
}
public void ShouldCreateMagickImage()
{
var factory = new MagickImageFactory();
var color = MagickColors.Goldenrod;
using (var image = factory.Create(color, 10, 5))
{
Assert.IsType <MagickImage>(image);
Assert.Equal(10, image.Width);
}
}
public void ShouldCreateMagickImage()
{
var factory = new MagickImageFactory();
var data = File.ReadAllBytes(Files.ImageMagickJPG);
using (var image = factory.Create(data))
{
Assert.IsInstanceOfType(image, typeof(MagickImage));
Assert.AreEqual(123, image.Width);
}
}
public void ShouldReadImage()
{
var factory = new MagickImageFactory();
using (var image = factory.Create("xc:red", 20, 30))
{
Assert.AreEqual(20, image.Width);
Assert.AreEqual(30, image.Height);
ColorAssert.AreEqual(MagickColors.Red, image, 10, 10);
}
}
public void ShouldCreateMagickImage()
{
var factory = new MagickImageFactory();
var file = new FileInfo(Files.ImageMagickJPG);
using (var image = factory.Create(file))
{
Assert.IsInstanceOfType(image, typeof(MagickImage));
Assert.AreEqual(123, image.Width);
}
}
public void ShouldCreateMagickImage()
{
var factory = new MagickImageFactory();
var color = MagickColors.Goldenrod;
using (var image = factory.Create(color, 10, 5))
{
Assert.IsInstanceOfType(image, typeof(MagickImage));
Assert.AreEqual(10, image.Width);
}
}
public void ShouldCreateMagickImage()
{
var factory = new MagickImageFactory();
var file = new FileInfo(Files.ImageMagickJPG);
using (var image = factory.Create(file))
{
Assert.IsType <MagickImage>(image);
Assert.Equal(123, image.Width);
}
}
public void ShouldNotThrowExceptionWhenSettingsIsNull()
{
var factory = new MagickImageFactory();
using (var fileStream = File.OpenRead(Files.CirclePNG))
{
using (var image = factory.Create(fileStream, null))
{
Assert.IsType <MagickImage>(image);
}
}
}
public void ShouldNotThrowExceptionWhenSettingsIsNull()
{
var factory = new MagickImageFactory();
using (var fileStream = File.OpenRead(Files.CirclePNG))
{
using (var image = factory.Create(fileStream, (MagickReadSettings)null))
{
Assert.IsInstanceOfType(image, typeof(MagickImage));
}
}
}
public async Task ShouldNotThrowExceptionWhenSettingsIsNull()
{
var factory = new MagickImageFactory();
using (var fileStream = File.OpenRead(Files.CirclePNG))
{
using (var image = await factory.CreateAsync(fileStream, (MagickReadSettings)null))
{
Assert.IsType <MagickImage>(image);
}
}
}
public void ShouldNotThrowExceptionWhenSettingsIsNull()
{
var factory = new MagickImageFactory();
using (var fileStream = File.OpenRead(Files.CirclePNG))
{
Assert.Throws <ArgumentNullException>("settings", () =>
{
factory.Create(fileStream, (PixelReadSettings)null);
});
}
}
public void ShouldCreateImageFromBitmap()
{
using (var bitmap = new Bitmap(Files.SnakewarePNG))
{
var factory = new MagickImageFactory();
using (var image = factory.Create(bitmap))
{
Assert.Equal(286, image.Width);
Assert.Equal(67, image.Height);
Assert.Equal(MagickFormat.Png, image.Format);
}
}
}
public void ShouldCreateMagickImage()
{
var factory = new MagickImageFactory();
using (var stream = File.OpenRead(Files.ImageMagickJPG))
{
using (var image = factory.Create(stream))
{
Assert.IsInstanceOfType(image, typeof(MagickImage));
Assert.AreEqual(123, image.Width);
}
}
}
public void ShouldCreateMagickImage()
{
var factory = new MagickImageFactory();
using (var stream = File.OpenRead(Files.ImageMagickJPG))
{
using (var image = factory.Create(stream))
{
Assert.IsType <MagickImage>(image);
Assert.Equal(123, image.Width);
}
}
}
public async Task <byte[]> OverlayImage(Stream baseImage, Stream overlayImage)
{
var factory = new MagickImageFactory();
baseImage.Position = 0;
overlayImage.Position = 0;
using var image = factory.Create(baseImage);
using var overlay = factory.Create(overlayImage);
var scale = findScalePercentage(overlay.Width, overlay.Height, image.Width, image.Height);
await Task.Run(() => overlay.Scale(scale));
await Task.Run(() => image.Composite(overlay, findXOffCenter(overlay.Width, image.Width), findYBottom(overlay.Height, image.Height), CompositeOperator.Over));
return(await Task.Run <byte[]>(() => { return image.ToByteArray(); }));
}
public void ShouldCreateMagickImage()
{
var factory = new MagickImageFactory();
var data = File.ReadAllBytes(Files.ImageMagickJPG);
var readSettings = new MagickReadSettings
{
BackgroundColor = MagickColors.Goldenrod,
};
using (var image = factory.Create(data, readSettings))
{
Assert.IsInstanceOfType(image, typeof(MagickImage));
Assert.AreEqual(123, image.Width);
Assert.AreEqual(MagickColors.Goldenrod, image.Settings.BackgroundColor);
}
}
public void ShouldCreateMagickImage()
{
var factory = new MagickImageFactory();
var settings = new MagickReadSettings
{
BackgroundColor = MagickColors.Purple,
};
var data = File.ReadAllBytes(Files.ImageMagickJPG);
using (var image = factory.Create(data, 0, data.Length, settings))
{
Assert.IsType <MagickImage>(image);
Assert.Equal(123, image.Width);
Assert.Equal(MagickColors.Purple, image.BackgroundColor);
}
}
public void ShouldCreateMagickImage()
{
var factory = new MagickImageFactory();
var data = File.ReadAllBytes(Files.ImageMagickJPG);
var readSettings = new MagickReadSettings
{
BackgroundColor = MagickColors.Goldenrod,
};
using (var image = factory.Create(new ReadOnlySequence <byte>(data), readSettings))
{
Assert.IsType <MagickImage>(image);
Assert.Equal(123, image.Width);
Assert.Equal(MagickColors.Goldenrod, image.Settings.BackgroundColor);
}
}
private MagickImage GenerateMagicImage(Texture2D tex)
{
//make null checks
if (tex == null)
{
return(null);
}
if (m_MagickFactory == null)
{
m_MagickFactory = new MagickImageFactory();
}
//create Magic image
var temp = m_MagickFactory.Create(tex.EncodeToPNG());
temp.Format = MagickFormat.Png32;
MagickImage image = new MagickImage(temp);
return(image);
}
public async Task <byte[]> ProcessImage(ImageMeme meme, params string[] replacements)
{
var factory = new MagickImageFactory();
using (var image = factory.Create(await(await imageStore.GetImageAsync(meme.Template.ImageBaseIdentifier)).GetBytes()))
{
List <MagickImage> MemeTexts = new List <MagickImage>();
foreach (var m in meme.Template.memeText)
{
MagickImage mti;
try
{
mti = new MagickImage($"caption:{m.GetMemeText(random, replacements)}", Composition(m));
}
catch (Exception e)
{
throw e;
}
MemeTexts.Add(mti);
// well there's your problem
// image.Composite(mti,m.XStartPosition,m.YStartPosition,CompositeOperator.Over);
await Task.Run(() => {
image.Composite(mti, m.XStartPosition, m.YStartPosition, CompositeOperator.Over);
});
//
}
var bytes = await Task.Run <byte[]>(() => { return(image.ToByteArray()); });
// dispose our dynamic images
//image.Write(writeStream);
foreach (var m in MemeTexts)
{
m.Dispose();
}
return(bytes);
}
}
public void ShouldCreateMagickImage()
{
var factory = new MagickImageFactory();
var data = new byte[]
{
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0xf0, 0x3f,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0xf0, 0x3f,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
};
var settings = new PixelReadSettings(2, 1, StorageType.Double, PixelMapping.RGBA);
using (var image = factory.Create(data, settings))
{
Assert.IsInstanceOfType(image, typeof(MagickImage));
Assert.AreEqual(2, image.Width);
}
}
public void ShouldCreateMagickImage()
{
var factory = new MagickImageFactory();
var data = new byte[]
{
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0xf0, 0x3f,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0xf0, 0x3f,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
};
var settings = new PixelReadSettings(2, 1, StorageType.Double, PixelMapping.RGBA);
using (var image = factory.Create(new Span <byte>(data), settings))
{
Assert.IsType <MagickImage>(image);
Assert.Equal(2, image.Width);
}
}
public void ShouldThrowExceptionWhenDataIsEmpty()
{
var factory = new MagickImageFactory();
Assert.Throws <ArgumentException>("data", () => factory.Create(Span <byte> .Empty));
}
public async Task ShouldThrowExceptionWhenSettingsIsNull()
{
var factory = new MagickImageFactory();
await Assert.ThrowsAsync <ArgumentNullException>("settings", () => factory.CreateAsync(new FileInfo(Files.CirclePNG), (PixelReadSettings)null));
}
public void ShouldThrowExceptionWhenBitmapIsNull()
{
var factory = new MagickImageFactory();
Assert.Throws <ArgumentNullException>("bitmap", () => factory.Create((Bitmap)null));
}
public async Task ShouldThrowExceptionWhenFileInfoIsNull()
{
var factory = new MagickImageFactory();
await Assert.ThrowsAsync <ArgumentNullException>("file", () => factory.CreateAsync((FileInfo)null));
}
public async Task ShouldThrowExceptionWhenFileNameIsEmpty()
{
var factory = new MagickImageFactory();
await Assert.ThrowsAsync <ArgumentException>("fileName", () => factory.CreateAsync(string.Empty));
}
public void ShouldThrowExceptionWhenCountIsNegative()
{
var factory = new MagickImageFactory();
Assert.Throws <ArgumentException>("count", () => factory.Create(new byte[] { 215 }, 0, -1));
}
public void ShouldThrowExceptionWhenArrayIsEmpty()
{
var factory = new MagickImageFactory();
Assert.Throws <ArgumentException>("data", () => factory.Create(Array.Empty <byte>(), 0, 0));
}
public void ShouldThrowExceptionWhenArrayIsNull()
{
var factory = new MagickImageFactory();
Assert.Throws <ArgumentNullException>("data", () => factory.Create((byte[])null, 0, 0));
}
