public void ShouldThrowExceptionWhenSettingsIsNull()
{
var factory = new MagickImageFactory();
var bytes = FileHelper.ReadAllBytes(Files.CirclePNG);
Assert.Throws <ArgumentNullException>("settings", () =>
{
factory.Create(bytes, 0, bytes.Length, (PixelReadSettings)null);
});
}
public void ShouldCreateMagickImage()
{
var factory = new MagickImageFactory();
using (var image = factory.Create())
{
Assert.IsType <MagickImage>(image);
Assert.Equal(0, image.Width);
}
}
public void ShouldThrowExceptionWhenStreamIsNull()
{
var factory = new MagickImageFactory();
var settings = new PixelReadSettings();
ExceptionAssert.Throws <ArgumentNullException>("stream", () =>
{
factory.Create((Stream)null, settings);
});
}
public void ShouldThrowExceptionWhenStreamIsEmpty()
{
var factory = new MagickImageFactory();
var settings = new PixelReadSettings();
ExceptionAssert.Throws <ArgumentException>("stream", () =>
{
factory.Create(new MemoryStream(), settings);
});
}
public void ShouldThrowExceptionWhenSettingsIsNull()
{
var factory = new MagickImageFactory();
var settings = new PixelReadSettings();
ExceptionAssert.Throws <ArgumentNullException>("settings", () =>
{
factory.Create(Files.CirclePNG, (PixelReadSettings)null);
});
}
public void ShouldThrowExceptionWhenOffsetIsNegative()
{
var factory = new MagickImageFactory();
var settings = new MagickReadSettings();
ExceptionAssert.Throws <ArgumentException>("offset", () =>
{
factory.Create(new byte[] { 215 }, -1, 0, settings);
});
}
public void ShouldCreateMagickImage()
{
var factory = new MagickImageFactory();
using (var image = factory.Create(Files.ImageMagickJPG))
{
Assert.IsInstanceOfType(image, typeof(MagickImage));
Assert.AreEqual(123, image.Width);
}
}
public void ShouldThrowExceptionWhenFileNameIsEmpty()
{
var factory = new MagickImageFactory();
var settings = new PixelReadSettings();
ExceptionAssert.Throws <ArgumentException>("fileName", () =>
{
factory.Create(string.Empty, settings);
});
}
public void ShouldThrowExceptionWhenArrayIsEmpty()
{
var factory = new MagickImageFactory();
var settings = new PixelReadSettings();
Assert.Throws <ArgumentException>("data", () =>
{
factory.Create(new byte[] { }, settings);
});
}
public void ShouldThrowExceptionWhenFileInfoIsNull()
{
var factory = new MagickImageFactory();
var settings = new MagickReadSettings();
Assert.Throws <ArgumentNullException>("file", () =>
{
factory.Create((FileInfo)null, settings);
});
}
public void ShouldThrowExceptionWhenCountIsNegative()
{
var factory = new MagickImageFactory();
var settings = new PixelReadSettings();
Assert.Throws <ArgumentException>("count", () =>
{
factory.Create(new byte[] { 215 }, 0, -1, settings);
});
}
public void ShouldThrowExceptionWhenArrayIsNull()
{
var factory = new MagickImageFactory();
var settings = new MagickReadSettings();
Assert.Throws <ArgumentNullException>("data", () =>
{
factory.Create((byte[])null, settings);
});
}
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 data = File.ReadAllBytes(Files.ImageMagickJPG);
using (var image = factory.Create(new Span <byte>(data)))
{
Assert.IsType <MagickImage>(image);
Assert.Equal(123, image.Width);
}
}
public void ShouldCreateMagickImage()
{
var factory = new MagickImageFactory();
var data = File.ReadAllBytes(Files.ImageMagickJPG);
using (var image = factory.Create(data, 0, data.Length))
{
Assert.IsInstanceOfType(image, typeof(MagickImage));
Assert.AreEqual(123, 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 ShouldReadImage()
{
var factory = new MagickImageFactory();
using (var image = factory.Create("xc:red", 20, 30))
{
Assert.Equal(20, image.Width);
Assert.Equal(30, image.Height);
ColorAssert.Equal(MagickColors.Red, image, 10, 10);
}
}
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 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))
{
Assert.Throws <ArgumentNullException>("settings", () =>
{
factory.Create(fileStream, (PixelReadSettings)null);
});
}
}
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 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.IsType <MagickImage>(image);
Assert.Equal(123, image.Width);
}
}
}
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);
}
}
public static MagickImage GenerateMagicImage(Texture2D tex)
{
//make null checks
if (tex == null)
{
return(null);
}
// if (magickFactory == null) magickFactory = new MagickImageFactory();
//create Magic image
var temp = magickFactory.Create(tex.EncodeToPNG());
temp.Format = MagickFormat.Png32;
MagickImage image = new MagickImage(temp);
return(image);
}
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(data, readSettings))
{
Assert.IsInstanceOfType(image, typeof(MagickImage));
Assert.AreEqual(123, image.Width);
Assert.AreEqual(MagickColors.Goldenrod, image.Settings.BackgroundColor);
}
}
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(new Span <byte>(data), settings))
{
Assert.IsType <MagickImage>(image);
Assert.Equal(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(data, settings))
{
Assert.IsInstanceOfType(image, typeof(MagickImage));
Assert.AreEqual(2, image.Width);
}
}
