private static string Convert(MagickGeometry geometry)
{
if (geometry == null)
return null;
return geometry.ToString();
}
public void ShouldSetAspectRatioWithNegativeOffset()
{
var geometry = new MagickGeometry("4:3-2+1");
Assert.AreEqual(-2, geometry.X);
Assert.AreEqual(1, geometry.Y);
Assert.AreEqual(4, geometry.Width);
Assert.AreEqual(3, geometry.Height);
Assert.IsTrue(geometry.AspectRatio);
}
public void ShouldSetLess()
{
var geometry = new MagickGeometry("10x5+2+1<");
Assert.AreEqual(2, geometry.X);
Assert.AreEqual(1, geometry.Y);
Assert.AreEqual(10, geometry.Width);
Assert.AreEqual(5, geometry.Height);
Assert.AreEqual(true, geometry.Less);
}
public void ShouldSetXAndYAndIsPercentage()
{
var geometry = new MagickGeometry(5, 10, (Percentage)15.0, (Percentage)20.0);
Assert.AreEqual(5, geometry.X);
Assert.AreEqual(10, geometry.Y);
Assert.AreEqual(15, geometry.Width);
Assert.AreEqual(20, geometry.Height);
Assert.AreEqual(true, geometry.IsPercentage);
}
public void ShouldSetIgnoreAspectRatio()
{
var geometry = new MagickGeometry("5x10!");
Assert.AreEqual(0, geometry.X);
Assert.AreEqual(0, geometry.Y);
Assert.AreEqual(5, geometry.Width);
Assert.AreEqual(10, geometry.Height);
Assert.AreEqual(true, geometry.IgnoreAspectRatio);
}
public void ShouldSetAspectRatio()
{
var geometry = new MagickGeometry("3:2");
Assert.AreEqual(0, geometry.X);
Assert.AreEqual(0, geometry.Y);
Assert.AreEqual(3, geometry.Width);
Assert.AreEqual(2, geometry.Height);
Assert.AreEqual(true, geometry.AspectRatio);
}
public void ShouldSetWidthAndHeightAndIsPercentage()
{
var geometry = new MagickGeometry(new Percentage(50.0), new Percentage(10.0));
Assert.AreEqual(0, geometry.X);
Assert.AreEqual(0, geometry.Y);
Assert.AreEqual(50, geometry.Width);
Assert.AreEqual(10, geometry.Height);
Assert.AreEqual(true, geometry.IsPercentage);
}
public void ShouldSetLimitPixels()
{
var geometry = new MagickGeometry("10@");
Assert.AreEqual(0, geometry.X);
Assert.AreEqual(0, geometry.Y);
Assert.AreEqual(10, geometry.Width);
Assert.AreEqual(0, geometry.Height);
Assert.IsTrue(geometry.LimitPixels);
}
public void ShouldSetFillArea()
{
var geometry = new MagickGeometry("10x15^");
Assert.AreEqual(0, geometry.X);
Assert.AreEqual(0, geometry.Y);
Assert.AreEqual(10, geometry.Width);
Assert.AreEqual(15, geometry.Height);
Assert.IsTrue(geometry.FillArea);
}
public void ShouldSetGreater()
{
var geometry = new MagickGeometry("5x10>");
Assert.AreEqual(0, geometry.X);
Assert.AreEqual(0, geometry.Y);
Assert.AreEqual(5, geometry.Width);
Assert.AreEqual(10, geometry.Height);
Assert.IsTrue(geometry.Greater);
}
public void ShouldSetAspectRatioWithOnlyXOffset()
{
var geometry = new MagickGeometry("4:3+2");
Assert.AreEqual(2, geometry.X);
Assert.AreEqual(0, geometry.Y);
Assert.AreEqual(4, geometry.Width);
Assert.AreEqual(3, geometry.Height);
Assert.IsTrue(geometry.AspectRatio);
}
public void Test_Constructor()
{
ExceptionAssert.Throws<ArgumentNullException>(delegate()
{
new MagickGeometry((string)null);
});
ExceptionAssert.Throws<ArgumentException>(delegate()
{
new MagickGeometry("");
});
MagickGeometry geometry = new MagickGeometry("5x10!");
Assert.AreEqual(5, geometry.Width);
Assert.AreEqual(10, geometry.Height);
Assert.AreEqual(true, geometry.IgnoreAspectRatio);
geometry = new MagickGeometry("10x5<");
Assert.AreEqual(10, geometry.Width);
Assert.AreEqual(5, geometry.Height);
Assert.AreEqual(true, geometry.Less);
geometry = new MagickGeometry("5x10>");
Assert.AreEqual(5, geometry.Width);
Assert.AreEqual(10, geometry.Height);
Assert.AreEqual(true, geometry.Greater);
geometry = new MagickGeometry("50%x0>");
Assert.AreEqual(50, geometry.Width);
Assert.AreEqual(0, geometry.Height);
Assert.AreEqual(true, geometry.IsPercentage);
Assert.AreEqual(true, geometry.Greater);
geometry = new MagickGeometry(5, 10);
Assert.AreEqual(5, geometry.Width);
Assert.AreEqual(10, geometry.Height);
geometry = new MagickGeometry(5, 10, 15, 20);
Assert.AreEqual(5, geometry.X);
Assert.AreEqual(10, geometry.Y);
Assert.AreEqual(15, geometry.Width);
Assert.AreEqual(20, geometry.Height);
geometry = new MagickGeometry(50.0, 10.0);
Assert.AreEqual(50, geometry.Width);
Assert.AreEqual(10, geometry.Height);
Assert.AreEqual(true, geometry.IsPercentage);
geometry = new MagickGeometry(5, 10, 15.0, 20.0);
Assert.AreEqual(5, geometry.X);
Assert.AreEqual(10, geometry.Y);
Assert.AreEqual(15, geometry.Width);
Assert.AreEqual(20, geometry.Height);
Assert.AreEqual(true, geometry.IsPercentage);
}
public void ShouldSetTheProperties()
{
var rectangle = new Rectangle(1, 2, 3, 4);
var geometry = new MagickGeometry(rectangle);
Assert.AreEqual(1, geometry.X);
Assert.AreEqual(2, geometry.Y);
Assert.AreEqual(3, geometry.Width);
Assert.AreEqual(4, geometry.Height);
}
private async Task <byte[]> GetThumbnail(string link)
{
byte[] imgContent = null;
try
{
using (var httpClient = new HttpClient())
{
using (var response = await httpClient.GetAsync(link))
{
response.EnsureSuccessStatusCode();
using (var stream = await response.Content.ReadAsStreamAsync())
{
HtmlDocument doc = new HtmlDocument();
doc.Load(stream);
HtmlNodeCollection metaImageNodes = doc.DocumentNode.SelectNodes("/html/head/meta[@property='og:image']");
if (metaImageNodes == null)
{
metaImageNodes = doc.DocumentNode.SelectNodes("/html/head/meta[@property='og:image:secure_url']");
}
var imgUrl = metaImageNodes?.FirstOrDefault()?.Attributes["content"]?.Value;
if (imgUrl == null)
{
return(null);
}
using (HttpClient client = new HttpClient())
{
using (var imgResponse = await httpClient.GetAsync(imgUrl))
{
imgResponse.EnsureSuccessStatusCode();
imgContent = await imgResponse.Content.ReadAsByteArrayAsync();
}
}
}
}
}
using (MagickImage image = new MagickImage(imgContent))
{
var size = new MagickGeometry(300, 100);
size.IgnoreAspectRatio = false;
image.Resize(size);
image.Format = MagickFormat.Jpg;
imgContent = image.ToByteArray();
}
}
catch (Exception ex)
{
_logger.LogError(ex, $"Error downloading image for: {link}");
}
return(imgContent);
}
public MagickGeometry MagickResize()
{
MagickGeometry size = new MagickGeometry(ResizedWidth, ResizedHeight);
using (MagickImage image = new MagickImage(MagickColor.FromRgba(0, 0, 0, 0), Width, Height))
{
image.Resize(size);
}
return(size);
}
public void ShouldReturnTheCorrectDefine()
{
var testDefine = new TestDefine();
var geometry = new MagickGeometry(1, 2, 3, 4);
var define = testDefine.PublicCreateDefine("test", geometry);
Assert.Equal(MagickFormat.A, define.Format);
Assert.Equal("test", define.Name);
Assert.Equal("3x4+1+2", define.Value);
}
/// <summary>
/// Initializes a new instance of the <see cref="DrawableComposite"/> class.
/// </summary>
/// <param name="offset">The offset from origin.</param>
/// <param name="image">The image to draw.</param>
public DrawableComposite(MagickGeometry offset, MagickImage image)
: this(image)
{
Throw.IfNull(nameof(offset), offset);
X = offset.X;
Y = offset.Y;
Width = offset.Width;
Height = offset.Height;
Compose = CompositeOperator.CopyAlpha;
}
/// <summary>
/// Initializes a new instance of the <see cref="DrawableComposite"/> class.
/// </summary>
/// <param name="offset">The offset from origin.</param>
/// <param name="compose">The algorithm to use.</param>
/// <param name="image">The image to draw.</param>
public DrawableComposite(MagickGeometry offset, CompositeOperator compose, MagickImage image)
: this(image)
{
Throw.IfNull("offset", offset);
X = offset.X;
Y = offset.Y;
Width = offset.Width;
Height = offset.Height;
Compose = compose;
}
public void Test_ToGeometry()
{
Density density = new Density(50.0);
MagickGeometry geometry = density.ToGeometry(0.5, 2.0);
Assert.AreEqual(0, geometry.X);
Assert.AreEqual(0, geometry.Y);
Assert.AreEqual(25, geometry.Width);
Assert.AreEqual(100, geometry.Height);
}
public void ShouldSetGreaterAndIsPercentage()
{
var geometry = new MagickGeometry("50%x0>");
Assert.AreEqual(0, geometry.X);
Assert.AreEqual(0, geometry.Y);
Assert.AreEqual(50, geometry.Width);
Assert.AreEqual(0, geometry.Height);
Assert.IsTrue(geometry.IsPercentage);
Assert.IsTrue(geometry.Greater);
}
public async Task GetGraphics(CancellationToken cancellationToken)
{
while (!cancellationToken.IsCancellationRequested)
{
if (!Directory.Exists(_secrets.AvatarDir()))
{
Directory.CreateDirectory(_secrets.AvatarDir());
}
var users = _pokerDB.User.OrderBy(u => u.ID).ToList();
var size = new MagickGeometry(32, 32);
size.IgnoreAspectRatio = true;
//did something change?
int counter = 0;
foreach (var user in users)
{
counter++;
string uid = user.SlackID;
string uri = "https://slack.com/api/users.profile.get?token=" + _secrets.UserToken() + "&user="******".png"))
{
MagickImage i = new MagickImage(await client.GetStreamAsync(u.Profile.Image48));
i.Resize(size);
if (File.Exists(_secrets.AvatarDir() + user.SlackID + ".png"))
{
File.Delete(_secrets.AvatarDir() + user.SlackID + ".png");
}
Console.WriteLine(_secrets.AvatarDir() + user.SlackID + ".png");
i.Write(_secrets.AvatarDir() + user.SlackID + ".png");
user.AvatarHash = u.Profile.AvatarHash;
}
if (!u.Profile.DisplayName.Equals(user.SlackUserName))
{
user.SlackUserName = u.Profile.DisplayName;
}
user.AvatarIndex = counter;
}
catch (HttpRequestException e)
{
Console.WriteLine("\nException Caught!");
Console.WriteLine("Message :{0} ", e.Message);
}
_pokerRepo.SetAvatarPath(user.UserName, _secrets.AvatarDir() + user.SlackID + ".png");
await Task.Delay(20000, cancellationToken);
}
_pokerDB.SaveChanges();
}
await Task.Delay(9000000, cancellationToken); //very long time
}
private static void ConvertLowres(string lowresDirectory, IFormFile image, string imageName, string imageExtension)
{
using (MagickImage imageFile = new MagickImage(GetFormImageToByte(image)))
{
MagickGeometry reSize = new MagickGeometry(new Percentage(90), new Percentage(90));
imageFile.AutoOrient();
reSize.IgnoreAspectRatio = false;
imageFile.Resize(reSize);
imageFile.Write(Path.Combine(lowresDirectory, imageName + imageExtension));
}
}
private static void ConvertThumbnail(string thumbnailDirectory, IFormFile image, string imageName, string imageExtension)
{
using (MagickImage imageFile = new MagickImage(GetFormImageToByte(image)))
{
MagickGeometry reSize = new MagickGeometry(300);
imageFile.AutoOrient();
reSize.IgnoreAspectRatio = false;
imageFile.Resize(reSize);
imageFile.Write(Path.Combine(thumbnailDirectory, imageName + imageExtension));
}
}
public bool ProcessLogoImage(string logoPath)
{
try
{
using (var image = new MagickImage(logoPath))
{
var originalWitdh = image.Width;
var originalHeight = image.Height;
var imageChanged = false;
if (settings.LogoTrimOnDownload)
{
image.Trim();
if (originalWitdh != image.Width || originalHeight != image.Height)
{
imageChanged = true;
originalWitdh = image.Width;
originalHeight = image.Height;
}
}
if (settings.SetLogoMaxProcessDimensions)
{
if (settings.MaxLogoProcessWidth < image.Width || settings.MaxLogoProcessHeight < image.Height)
{
var targetWidth = settings.MaxLogoProcessWidth;
var targetHeight = settings.MaxLogoProcessHeight;
MagickGeometry size = new MagickGeometry(targetWidth, targetHeight)
{
IgnoreAspectRatio = false
};
image.Resize(size);
if (originalWitdh != image.Width || originalHeight != image.Height)
{
imageChanged = true;
originalWitdh = image.Width;
originalHeight = image.Height;
}
}
}
// Only save new image if dimensions changed
if (imageChanged)
{
image.Write(logoPath);
}
return(true);
}
}
catch (Exception e)
{
logger.Error(e, $"Error while processing logo {logoPath}");
return(false);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DrawableComposite"/> class.
/// </summary>
/// <param name="offset">The offset from origin.</param>
/// <param name="image">The image to draw.</param>
public DrawableComposite(MagickGeometry offset, MagickImage image)
: this(image)
{
Throw.IfNull(nameof(offset), offset);
X = offset.X;
Y = offset.Y;
Width = offset.Width;
Height = offset.Height;
Compose = CompositeOperator.CopyAlpha;
}
public void Constructor_WithRectangle_PropertiesAreSet()
{
var rectangle = new Rectangle(1, 2, 3, 4);
var geometry = new MagickGeometry(rectangle);
Assert.AreEqual(1, geometry.X);
Assert.AreEqual(2, geometry.Y);
Assert.AreEqual(3, geometry.Width);
Assert.AreEqual(4, geometry.Height);
}
private static MagickGeometry TestGeometry(MagickGeometry geometry, Line line1, Line line2)
{
int x = Math.Max(line1.X1, line2.X1);
int y = line1.Y;
int width = Math.Min(line1.X2, line2.X2) - x;
int height = line2.Y - line1.Y;
MagickGeometry newGeometry = new MagickGeometry(x, y, width, height);
return(newGeometry > geometry ? newGeometry : geometry);
}
public void ShouldThrowExceptionWhenGeometryIsPercentage()
{
using (var image = new MagickImage())
{
Assert.Throws <ArgumentException>("geometry", () =>
{
var geometry = new MagickGeometry(new Percentage(100), new Percentage(100));
image.Evaluate(Channels.Red, geometry, EvaluateOperator.Set, 0.0);
});
}
}
public void Test_ToPoint()
{
PointD point = new MagickGeometry(10, 5).ToPoint();
Assert.AreEqual(0, point.X);
Assert.AreEqual(0, point.Y);
point = new MagickGeometry(1, 2, 3, 4).ToPoint();
Assert.AreEqual(1, point.X);
Assert.AreEqual(2, point.Y);
}
public void Test_ToString()
{
MagickGeometry geometry = new MagickGeometry(10, 5);
Assert.AreEqual("10x5", geometry.ToString());
geometry = new MagickGeometry(-5, 5, 10, 5);
Assert.AreEqual("10x5-5+5", geometry.ToString());
geometry = new MagickGeometry(5, -5, 10, 5);
Assert.AreEqual("10x5+5-5", geometry.ToString());
}
public void ShouldReturnTheCorrectValueWhenInstanceAreEqual()
{
var first = new MagickGeometry(10, 5);
var second = new MagickGeometry(10, 5);
Assert.True(first == second);
Assert.False(first != second);
Assert.False(first < second);
Assert.True(first <= second);
Assert.False(first > second);
Assert.True(first >= second);
}
private void ExecuteOuterTrim(MagickImage image)
{
image.BackgroundColor = _BorderColor;
image.ColorFuzz = ColorFuzz;
image.Trim();
image.RePage();
MagickGeometry geometry = new MagickGeometry(0, 0, image.Width, image.Height);
ShiftGeometry(geometry);
Crop(image, geometry);
}
/// <summary>
/// Method to resize an image
/// </summary>
/// <param name="imageData"></param>
/// <param name="width"></param>
/// <param name="height"></param>
/// <param name="ignoreAspectRatio">Normally an image will be resized to fit inside the specified size.</param>
/// <returns></returns>
public byte[] ResizeImage(byte[] imageData, int width, int height, bool ignoreAspectRatio)
{
using (var magickImage = new MagickImage(imageData))
{
var size = new MagickGeometry(width, height)
{
IgnoreAspectRatio = ignoreAspectRatio
};
magickImage.Resize(size);
return(magickImage.ToByteArray());
}
}
internal static MagickGeometry Clone(MagickGeometry value)
{
if (value == null)
return null;
MagickGeometry clone = new MagickGeometry();
clone.FillArea = value.FillArea;
clone.Greater = value.Greater;
clone.Height = value.Height;
clone.IgnoreAspectRatio = value.IgnoreAspectRatio;
clone.IsPercentage = value.IsPercentage;
clone.Less = value.Less;
clone.LimitPixels = value.LimitPixels;
clone.Width = value.Width;
clone.X = value.X;
clone.Y = value.Y;
return clone;
}
public void Test_IComparable()
{
MagickGeometry first = new MagickGeometry(10, 5);
Assert.AreEqual(0, first.CompareTo(first));
Assert.AreEqual(1, first.CompareTo(null));
Assert.IsFalse(first < null);
Assert.IsFalse(first <= null);
Assert.IsTrue(first > null);
Assert.IsTrue(first >= null);
Assert.IsTrue(null < first);
Assert.IsTrue(null <= first);
Assert.IsFalse(null > first);
Assert.IsFalse(null >= first);
MagickGeometry second = new MagickGeometry(5, 5);
Assert.AreEqual(1, first.CompareTo(second));
Assert.IsFalse(first < second);
Assert.IsFalse(first <= second);
Assert.IsTrue(first > second);
Assert.IsTrue(first >= second);
second = new MagickGeometry(5, 10);
Assert.AreEqual(0, first.CompareTo(second));
Assert.IsFalse(first == second);
Assert.IsFalse(first < second);
Assert.IsTrue(first <= second);
Assert.IsFalse(first > second);
Assert.IsTrue(first >= second);
}
/// <summary>
/// Determines whether the specified <see cref="MagickGeometry"/> is equal to the current <see cref="MagickGeometry"/>.
/// </summary>
/// <param name="other">The <see cref="MagickGeometry"/> to compare this <see cref="MagickGeometry"/> with.</param>
/// <returns>True when the specified <see cref="MagickGeometry"/> is equal to the current <see cref="MagickGeometry"/>.</returns>
public bool Equals(MagickGeometry other)
{
if (ReferenceEquals(other, null))
return false;
if (ReferenceEquals(this, other))
return true;
return
Width == other.Width &&
Height == other.Height &&
X == other.X &&
Y == other.Y &&
IsPercentage == other.IsPercentage &&
IgnoreAspectRatio == other.IgnoreAspectRatio &&
Less == other.Less &&
Greater == other.Greater &&
FillArea == other.FillArea &&
LimitPixels == other.LimitPixels;
}
/// <summary>
/// Compares the current instance with another object of the same type.
/// </summary>
/// <param name="other">The object to compare this geometry with.</param>
/// <returns>A signed number indicating the relative values of this instance and value.</returns>
public int CompareTo(MagickGeometry other)
{
if (ReferenceEquals(other, null))
return 1;
int left = Width * Height;
int right = other.Width * other.Height;
if (left == right)
return 0;
return left < right ? -1 : 1;
}
public void Test_IEquatable()
{
MagickGeometry first = new MagickGeometry(10, 5);
Assert.IsFalse(first == null);
Assert.IsFalse(first.Equals(null));
Assert.IsTrue(first.Equals(first));
Assert.IsTrue(first.Equals((object)first));
MagickGeometry second = new MagickGeometry(10, 5);
Assert.IsTrue(first == second);
Assert.IsTrue(first.Equals(second));
Assert.IsTrue(first.Equals((object)second));
second = new MagickGeometry(5, 5);
Assert.IsTrue(first != second);
Assert.IsFalse(first.Equals(second));
}
public void Test_ToString()
{
MagickGeometry geometry = new MagickGeometry(10, 5);
Assert.AreEqual("10x5", geometry.ToString());
geometry = new MagickGeometry(-5, 5, 10, 5);
Assert.AreEqual("10x5-5+5", geometry.ToString());
geometry = new MagickGeometry(5, -5, 10, 5);
Assert.AreEqual("10x5+5-5", geometry.ToString());
}
internal static string ToString(MagickGeometry value)
{
return value == null ? null : value.ToString();
}
/// <summary>
/// Initializes a new instance of the <see cref="DrawableComposite"/> class.
/// </summary>
/// <param name="offset">The offset from origin.</param>
/// <param name="compose">The algorithm to use.</param>
/// <param name="image">The image to draw.</param>
public DrawableComposite(MagickGeometry offset, CompositeOperator compose, MagickImage image)
: this(image)
{
Throw.IfNull("offset", offset);
X = offset.X;
Y = offset.Y;
Width = offset.Width;
Height = offset.Height;
Compose = compose;
}
public DrawableCompositeImage(MagickGeometry offset, MagickImage image)
: base(AssemblyHelper.CreateInstance(Types.DrawableCompositeImage, new Type[] {Types.MagickGeometry, Types.MagickImage}, GraphicsMagick.MagickGeometry.GetInstance(offset), GraphicsMagick.MagickImage.GetInstance(image)))
{
}
