public void HslaColorImplementsEquals()
{
HslaColor first = HslaColor.FromColor(Color.White);
HslaColor second = HslaColor.FromColor(Color.White);
first.Equals(second).Should().BeTrue("because the color structure should implement Equals()");
}
public void HslaColorShouldConvertToAndFromString(string expected)
{
Color color = ColorTranslator.FromHtml(expected);
HslaColor hslaColor = HslaColor.FromColor(color);
string result = ColorTranslator.ToHtml(hslaColor);
result.Should().Be(expected);
}
/// <summary>
/// Processes the image.
/// </summary>
/// <param name="factory">
/// The current instance of the <see cref="T:ImageProcessor.ImageFactory"/> class containing
/// the image to process.
/// </param>
/// <returns>
/// The processed image from the current instance of the <see cref="T:ImageProcessor.ImageFactory"/> class.
/// </returns>
public Image ProcessImage(ImageFactory factory)
{
Bitmap newImage = null;
Image image = factory.Image;
try
{
Tuple <int, bool> parameters = this.DynamicParameter;
int degrees = parameters.Item1;
bool rotate = parameters.Item2;
int width = image.Width;
int height = image.Height;
newImage = new Bitmap(image);
using (FastBitmap fastBitmap = new FastBitmap(newImage))
{
if (!rotate)
{
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
HslaColor original = HslaColor.FromColor(fastBitmap.GetPixel(x, y));
HslaColor altered = HslaColor.FromHslaColor(degrees / 360f, original.S, original.L, original.A);
fastBitmap.SetPixel(x, y, altered);
}
}
}
else
{
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
HslaColor original = HslaColor.FromColor(fastBitmap.GetPixel(x, y));
HslaColor altered = HslaColor.FromHslaColor((original.H + (degrees / 360f)) % 1, original.S, original.L, original.A);
fastBitmap.SetPixel(x, y, altered);
}
}
}
}
image.Dispose();
image = newImage;
}
catch (Exception ex)
{
if (newImage != null)
{
newImage.Dispose();
}
throw new ImageProcessingException("Error processing image with " + this.GetType().Name, ex);
}
return(image);
}
/// <summary>
/// Processes the image.
/// </summary>
/// <param name="factory">
/// The current instance of the <see cref="T:ImageProcessor.ImageFactory"/> class containing
/// the image to process.
/// </param>
/// <returns>
/// The processed image from the current instance of the <see cref="T:ImageProcessor.ImageFactory"/> class.
/// </returns>
public Image ProcessImage(ImageFactory factory)
{
var image = factory.Image;
try
{
Tuple <int, bool> parameters = DynamicParameter;
var degrees = parameters.Item1;
if (degrees == 0)
{
return(image);
}
var rotate = parameters.Item2;
var width = image.Width;
var height = image.Height;
using (var fastBitmap = new FastBitmap(image))
{
if (!rotate)
{
for (var y = 0; y < height; y++)
{
for (var x = 0; x < width; x++)
{
var original = HslaColor.FromColor(fastBitmap.GetPixel(x, y));
var altered = HslaColor.FromHslaColor(degrees / 360f, original.S, original.L, original.A);
fastBitmap.SetPixel(x, y, altered);
}
}
}
else
{
for (var y = 0; y < height; y++)
{
for (var x = 0; x < width; x++)
{
var original = HslaColor.FromColor(fastBitmap.GetPixel(x, y));
var altered = HslaColor.FromHslaColor((original.H + (degrees / 360f)) % 1, original.S, original.L, original.A);
fastBitmap.SetPixel(x, y, altered);
}
}
}
}
return(image);
}
catch (Exception ex)
{
throw new ImageProcessingException("Error processing image with " + GetType().Name, ex);
}
}
public void then_should_return_rgba_version_of_hsla_color_given_red()
{
// Arrange
var hslaColor = HslaColor.FromColor(Color.Red);
// Act
var rgbaColor = (RgbaColor)hslaColor;
// Assert
Assert.That(rgbaColor.R, Is.EqualTo(255));
Assert.That(rgbaColor.G, Is.EqualTo(0));
Assert.That(rgbaColor.B, Is.EqualTo(0));
Assert.That(rgbaColor.A, Is.EqualTo(255));
}
public void then_should_return_cmyk_version_of_hsla_color_given_red()
{
// Arrange
var hslaColor = HslaColor.FromHslaColor(0f, 1f, .5f, 1f);
// Act
var cmyk = (CmykColor)hslaColor;
// Assert
Assert.That(cmyk.C, Is.EqualTo(0));
Assert.That(cmyk.M, Is.EqualTo(100));
Assert.That(cmyk.Y, Is.EqualTo(100));
Assert.That(cmyk.K, Is.EqualTo(0));
}
public void then_should_return_hsla_version_of_system_drawing_color_given_red()
{
// Arrange
var color = Color.Red;
// Act
HslaColor hslaColor = color;
// Assert
Assert.That(hslaColor.H, Is.EqualTo(0));
Assert.That(hslaColor.S, Is.EqualTo(1.0f));
Assert.That(hslaColor.L, Is.EqualTo(.5f));
Assert.That(hslaColor.A, Is.EqualTo(1.0f));
}
/// <summary>
/// Calculate a difference measurement between two colors. Weight H, S and L.
/// </summary>
/// <returns>The distance.</returns>
/// <param name="apple">Apple.</param>
/// <param name="orange">Orange.</param>
public static float WeightedDistance(HslaColor apple, HslaColor orange)
{
var diff_h = HueDifference(apple.H, orange.H);
var diff_s = apple.S - orange.S;
diff_s *= diff_s;
var diff_l = apple.L - orange.L;
diff_l *= diff_l;
var distance = 0.5f * diff_h + 0.15f * diff_s + 0.35f * diff_l;
return(distance);
}
public void BasicExchangeEngineTest()
{
// Various H colors.
var c0 = HslaColor.FromHslaColor(0.0f, 0.5f, 0.5f);
var c1 = HslaColor.FromHslaColor(0.1f, 0.5f, 0.5f);
var c3 = HslaColor.FromHslaColor(0.3f, 0.5f, 0.5f);
var c4 = HslaColor.FromHslaColor(0.4f, 0.5f, 0.5f);
var c5 = HslaColor.FromHslaColor(0.5f, 0.5f, 0.5f);
var c9 = HslaColor.FromHslaColor(0.9f, 0.5f, 0.5f);
var cA = HslaColor.FromHslaColor(1.0f, 0.5f, 0.5f);
// Fudged S or L
var c1a = HslaColor.FromHslaColor(0.1f, 0.4f, 0.5f);
var c1b = HslaColor.FromHslaColor(0.1f, 0.5f, 0.4f);
var c1c = HslaColor.FromHslaColor(0.1f, 0.6f, 0.5f);
var c1d = HslaColor.FromHslaColor(0.1f, 0.5f, 0.6f);
// Argument order irrelevant
Assert.AreEqual(ColorDistances.SimpleHue(c1, c3), ColorDistances.SimpleHue(c3, c1), 0.00001);
Assert.AreEqual(ColorDistances.SimpleHue(c1, c4), ColorDistances.SimpleHue(c4, c1), 0.00001);
// Color is always 0.0 away from itself.
Assert.AreEqual(0.0f, ColorDistances.SimpleHue(c1, c1), 0.00001);
Assert.AreEqual(0.0f, ColorDistances.SimpleHue(c4, c4), 0.00001);
Assert.AreEqual(0.0f, ColorDistances.SimpleHue(c9, c9), 0.00001);
// Distance same if wrapping around 1.0/0.0.
Assert.AreEqual(ColorDistances.SimpleHue(c9, c1), ColorDistances.SimpleHue(c1, c3), 0.00001);
// Max distance (1.0) at 180 from each other.
Assert.AreEqual(1.0f, ColorDistances.SimpleHue(c4, c9), 0.00001);
Assert.AreEqual(1.0f, ColorDistances.SimpleHue(c9, c4), 0.00001);
Assert.AreEqual(1.0f, ColorDistances.SimpleHue(c5, c0), 0.00001);
Assert.AreEqual(1.0f, ColorDistances.SimpleHue(c5, cA), 0.00001);
Assert.AreEqual(1.0f, ColorDistances.SimpleHue(c0, c5), 0.00001);
Assert.AreEqual(1.0f, ColorDistances.SimpleHue(cA, c5), 0.00001);
var c25 = HslaColor.FromHslaColor(0.25f, 0.5f, 0.5f);
var c75 = HslaColor.FromHslaColor(0.75f, 0.5f, 0.5f);
Assert.AreEqual(1.0f, ColorDistances.SimpleHue(c25, c75), 0.00001);
Assert.AreEqual(1.0f, ColorDistances.SimpleHue(c75, c25), 0.00001);
}
private void UpdatePixelColor(Point pixelPosition, RgbaColor rgbaColor)
{
if (this.imageController.IsGrayscale)
{
this.rgbGrayColorToolStripStatusLabel.Text = FormattableString.Invariant($"Gray: {rgbaColor.R}");
this.hsvColorToolStripStatusLabel.Text = string.Empty;
}
else
{
this.rgbGrayColorToolStripStatusLabel.Text = rgbaColor.ToString();
HslaColor hslaColor = rgbaColor;
this.hsvColorToolStripStatusLabel.Text = hslaColor.ToString();
}
this.UpdateStatusStripSeparators();
}
/// <summary>
/// Simples color difference, returns higher numbers for higher difference in hue.
/// </summary>
/// <returns>Some sort of distance metric. 0.0 = identical, 1.0 = completely different.</returns>
/// <param name="apple">One color.</param>
/// <param name="orange">Another color.</param>
public static float SimpleHue(HslaColor apple, HslaColor orange)
{
var toreturn = HueDifference(apple.H, orange.H);
return(toreturn);
}
