public Material(Color color, Luminosity luminosity, string brushFamily)
{
Color = color;
Luminosity = luminosity;
BrushFamily = brushFamily;
Brush = new SolidColorBrush(color);
}
public Material GetMaterial(Luminosity i)
{
foreach (var m in Materials.Where(m => m.Luminosity == i))
{
return m;
}
throw new Exception($"Material with luminosity {i} cannot be found in this MaterialSet.");
}
/// <summary>
/// Generates multiple random colors.
/// </summary>
/// <param name="scheme">Which color schemed to use when generating the color.</param>
/// <param name="luminosity">The desired luminosity of the color.</param>
/// <param name="count">How many colors to generate</param>
public static Color[] GetColors(ColorScheme scheme, Luminosity luminosity, int count)
{
var ret = new Color[count];
for (var i = 0; i < count; i++)
{
ret[i] = GetColor(scheme, luminosity);
}
return ret;
}
/// <summary>
/// Gets a new random color.
/// </summary>
/// <param name="scheme">Which color schemed to use when generating the color.</param>
/// <param name="luminosity">The desired luminosity of the color.</param>
public static Color GetColor(ColorScheme scheme, Luminosity luminosity)
{
int H, S, B;
// First we pick a hue (H)
H = PickHue(scheme);
// Then use H to determine saturation (S)
S = PickSaturation(H, luminosity, scheme);
// Then use S and H to determine brightness (B).
B = PickBrightness(H, S, luminosity);
// Then we return the HSB color in the desired format
return HsvToColor(H, S, B);
}
public void Convert_ChangeType_SelfType_EqualsSelf()
{
var quantity = Luminosity.FromWatts(1.0);
Assert.Equal(quantity, Convert.ChangeType(quantity, typeof(Luminosity)));
}
public void Convert_ToString_EqualsToString()
{
var quantity = Luminosity.FromWatts(1.0);
Assert.Equal(quantity.ToString(), Convert.ToString(quantity));
}
public void Convert_ToSByte_EqualsValueAsSameType()
{
var quantity = Luminosity.FromWatts(1.0);
Assert.Equal((sbyte)quantity.Value, Convert.ToSByte(quantity));
}
public void Convert_ToDecimal_EqualsValueAsSameType()
{
var quantity = Luminosity.FromWatts(1.0);
Assert.Equal((decimal)quantity.Value, Convert.ToDecimal(quantity));
}
public void ToString_NullProvider_EqualsCurrentUICulture()
{
var quantity = Luminosity.FromWatts(1.0);
Assert.Equal(quantity.ToString(CultureInfo.CurrentUICulture, "g"), quantity.ToString(null, "g"));
}
public void EqualsReturnsFalseOnNull()
{
Luminosity watt = Luminosity.FromWatts(1);
Assert.False(watt.Equals(null));
}
public SolidColorBrush FromLuminosity(Luminosity l)
{
if (LuinosityPairs.ContainsKey(l))
{
return (SolidColorBrush)GetValue(LuinosityPairs[l]);
}
throw new NotSupportedException($"Luminosity {l} not supported");
}
public void NegationOperator_ReturnsQuantity_WithNegatedValue(decimal value)
{
var quantity = Luminosity.FromWatts(value);
Assert.Equal(Luminosity.FromWatts(-value), -quantity);
}
private static int PickBrightness(int H, int S, Luminosity luminosity)
{
var bMin = GetMinimumBrightness(H, S);
var bMax = 100;
switch (luminosity)
{
case Luminosity.Dark:
bMax = bMin + 20;
break;
case Luminosity.Light:
bMin = (bMax + bMin) / 2;
break;
case Luminosity.Random:
bMin = 0;
bMax = 100;
break;
}
return RandomWithin(bMin, bMax);
}
private static int PickSaturation(int hue, Luminosity luminosity, ColorScheme scheme)
{
if (luminosity == Luminosity.Random)
{
return RandomWithin(0, 100);
}
if (scheme == ColorScheme.Monochrome)
{
return 0;
}
var saturationRange = GetColorInfo(hue).SaturationRange;
var sMin = saturationRange.Lower;
var sMax = saturationRange.Upper;
switch (luminosity)
{
case Luminosity.Bright:
sMin = 55;
break;
case Luminosity.Dark:
sMin = sMax - 10;
break;
case Luminosity.Light:
sMax = 55;
break;
}
return RandomWithin(sMin, sMax);
}
public LuminosityMaterialDescriptor(Luminosity luminosity, double opacity = 1.0)
{
Luminosity = luminosity;
Opacity = opacity;
}
/// <summary>
/// Creates a new instance with the given color scheme and luminosity range.
/// </summary>
/// <param name="scheme">The color scheme to use when generating the color.</param>
/// <param name="luminosity">The luminosity range to use when generating the color.</param>
public Options(ColorScheme scheme, Luminosity luminosity)
{
ColorScheme = scheme;
Luminosity = luminosity;
}
public void Convert_ChangeType_QuantityType_EqualsQuantityType()
{
var quantity = Luminosity.FromWatts(1.0);
Assert.Equal(QuantityType.Luminosity, Convert.ChangeType(quantity, typeof(QuantityType)));
}
public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
{
var v = Luminosity.FromWatts(1);
Assert.Throws <ArgumentOutOfRangeException>(() => v.Equals(Luminosity.FromWatts(1), -1, ComparisonType.Relative));
}
public void Convert_ChangeType_InvalidType_ThrowsInvalidCastException()
{
var quantity = Luminosity.FromWatts(1.0);
Assert.Throws <InvalidCastException>(() => Convert.ChangeType(quantity, typeof(QuantityFormatter)));
}
public Material GetMaterialWithOpacity(Luminosity i, double opacity)
{
var material = GetMaterial(i);
return material.WithOpacity(opacity);
}
public static void SetClickFeedback(DependencyObject i, Luminosity v) => i.Set(ClickFeedbackProperty, v);
public SolidColorBrush FromLuminosity(Luminosity luminosity)
{
if (LuminosityPairs.ContainsKey(luminosity))
{
return GetValue(LuminosityPairs[luminosity]).RequireType<SolidColorBrush>();
}
return MaterialPalette.Red500;
}
public void EqualsReturnsFalseOnTypeMismatch()
{
Luminosity watt = Luminosity.FromWatts(1);
Assert.False(watt.Equals(new object()));
}
public void NumberToWattsTest() => Assert.Equal(Luminosity.FromWatts(2), 2.Watts());
public void ToString_NullArgs_ThrowsArgumentNullException()
{
var quantity = Luminosity.FromWatts(1.0);
Assert.Throws <ArgumentNullException>(() => quantity.ToString(null, "g", null));
}
public void FromWatts_WithInfinityValue_ThrowsArgumentException()
{
Assert.Throws <ArgumentException>(() => Luminosity.FromWatts(double.PositiveInfinity));
Assert.Throws <ArgumentException>(() => Luminosity.FromWatts(double.NegativeInfinity));
}
public void Convert_ToDateTime_ThrowsInvalidCastException()
{
var quantity = Luminosity.FromWatts(1.0);
Assert.Throws <InvalidCastException>(() => Convert.ToDateTime(quantity));
}
public void FromWatts_WithNanValue_ThrowsArgumentException()
{
Assert.Throws <ArgumentException>(() => Luminosity.FromWatts(double.NaN));
}
public void Convert_ToInt32_EqualsValueAsSameType()
{
var quantity = Luminosity.FromWatts(1.0);
Assert.Equal((int)quantity.Value, Convert.ToInt32(quantity));
}
public void ToUnit_WithNullUnitSystem_ThrowsNullException()
{
var watt = Luminosity.FromWatts(1);
Assert.Throws <ArgumentNullException>(() => watt.ToUnit(null));
}
public void Convert_ToSingle_EqualsValueAsSameType()
{
var quantity = Luminosity.FromWatts(1.0);
Assert.Equal((float)quantity.Value, Convert.ToSingle(quantity));
}
public void Convert_ChangeType_QuantityInfo_EqualsQuantityInfo()
{
var quantity = Luminosity.FromWatts(1.0);
Assert.Equal(Luminosity.Info, Convert.ChangeType(quantity, typeof(QuantityInfo)));
}
public void Convert_ToUInt64_EqualsValueAsSameType()
{
var quantity = Luminosity.FromWatts(1.0);
Assert.Equal((ulong)quantity.Value, Convert.ToUInt64(quantity));
}
public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
{
var quantity00 = Luminosity.From(1, LuminosityUnit.Decawatt);
AssertEx.EqualTolerance(1, quantity00.Decawatts, DecawattsTolerance);
Assert.Equal(LuminosityUnit.Decawatt, quantity00.Unit);
var quantity01 = Luminosity.From(1, LuminosityUnit.Deciwatt);
AssertEx.EqualTolerance(1, quantity01.Deciwatts, DeciwattsTolerance);
Assert.Equal(LuminosityUnit.Deciwatt, quantity01.Unit);
var quantity02 = Luminosity.From(1, LuminosityUnit.Femtowatt);
AssertEx.EqualTolerance(1, quantity02.Femtowatts, FemtowattsTolerance);
Assert.Equal(LuminosityUnit.Femtowatt, quantity02.Unit);
var quantity03 = Luminosity.From(1, LuminosityUnit.Gigawatt);
AssertEx.EqualTolerance(1, quantity03.Gigawatts, GigawattsTolerance);
Assert.Equal(LuminosityUnit.Gigawatt, quantity03.Unit);
var quantity04 = Luminosity.From(1, LuminosityUnit.Kilowatt);
AssertEx.EqualTolerance(1, quantity04.Kilowatts, KilowattsTolerance);
Assert.Equal(LuminosityUnit.Kilowatt, quantity04.Unit);
var quantity05 = Luminosity.From(1, LuminosityUnit.Megawatt);
AssertEx.EqualTolerance(1, quantity05.Megawatts, MegawattsTolerance);
Assert.Equal(LuminosityUnit.Megawatt, quantity05.Unit);
var quantity06 = Luminosity.From(1, LuminosityUnit.Microwatt);
AssertEx.EqualTolerance(1, quantity06.Microwatts, MicrowattsTolerance);
Assert.Equal(LuminosityUnit.Microwatt, quantity06.Unit);
var quantity07 = Luminosity.From(1, LuminosityUnit.Milliwatt);
AssertEx.EqualTolerance(1, quantity07.Milliwatts, MilliwattsTolerance);
Assert.Equal(LuminosityUnit.Milliwatt, quantity07.Unit);
var quantity08 = Luminosity.From(1, LuminosityUnit.Nanowatt);
AssertEx.EqualTolerance(1, quantity08.Nanowatts, NanowattsTolerance);
Assert.Equal(LuminosityUnit.Nanowatt, quantity08.Unit);
var quantity09 = Luminosity.From(1, LuminosityUnit.Petawatt);
AssertEx.EqualTolerance(1, quantity09.Petawatts, PetawattsTolerance);
Assert.Equal(LuminosityUnit.Petawatt, quantity09.Unit);
var quantity10 = Luminosity.From(1, LuminosityUnit.Picowatt);
AssertEx.EqualTolerance(1, quantity10.Picowatts, PicowattsTolerance);
Assert.Equal(LuminosityUnit.Picowatt, quantity10.Unit);
var quantity11 = Luminosity.From(1, LuminosityUnit.SolarLuminosity);
AssertEx.EqualTolerance(1, quantity11.SolarLuminosities, SolarLuminositiesTolerance);
Assert.Equal(LuminosityUnit.SolarLuminosity, quantity11.Unit);
var quantity12 = Luminosity.From(1, LuminosityUnit.Terawatt);
AssertEx.EqualTolerance(1, quantity12.Terawatts, TerawattsTolerance);
Assert.Equal(LuminosityUnit.Terawatt, quantity12.Unit);
var quantity13 = Luminosity.From(1, LuminosityUnit.Watt);
AssertEx.EqualTolerance(1, quantity13.Watts, WattsTolerance);
Assert.Equal(LuminosityUnit.Watt, quantity13.Unit);
}
public void Convert_ChangeType_UnitType_EqualsUnit()
{
var quantity = Luminosity.FromWatts(1.0);
Assert.Equal(quantity.Unit, Convert.ChangeType(quantity, typeof(LuminosityUnit)));
}
public void ToUnit()
{
var watt = Luminosity.FromWatts(1);
var decawattQuantity = watt.ToUnit(LuminosityUnit.Decawatt);
AssertEx.EqualTolerance(DecawattsInOneWatt, (decimal)decawattQuantity.Value, DecawattsTolerance);
Assert.Equal(LuminosityUnit.Decawatt, decawattQuantity.Unit);
var deciwattQuantity = watt.ToUnit(LuminosityUnit.Deciwatt);
AssertEx.EqualTolerance(DeciwattsInOneWatt, (decimal)deciwattQuantity.Value, DeciwattsTolerance);
Assert.Equal(LuminosityUnit.Deciwatt, deciwattQuantity.Unit);
var femtowattQuantity = watt.ToUnit(LuminosityUnit.Femtowatt);
AssertEx.EqualTolerance(FemtowattsInOneWatt, (decimal)femtowattQuantity.Value, FemtowattsTolerance);
Assert.Equal(LuminosityUnit.Femtowatt, femtowattQuantity.Unit);
var gigawattQuantity = watt.ToUnit(LuminosityUnit.Gigawatt);
AssertEx.EqualTolerance(GigawattsInOneWatt, (decimal)gigawattQuantity.Value, GigawattsTolerance);
Assert.Equal(LuminosityUnit.Gigawatt, gigawattQuantity.Unit);
var kilowattQuantity = watt.ToUnit(LuminosityUnit.Kilowatt);
AssertEx.EqualTolerance(KilowattsInOneWatt, (decimal)kilowattQuantity.Value, KilowattsTolerance);
Assert.Equal(LuminosityUnit.Kilowatt, kilowattQuantity.Unit);
var megawattQuantity = watt.ToUnit(LuminosityUnit.Megawatt);
AssertEx.EqualTolerance(MegawattsInOneWatt, (decimal)megawattQuantity.Value, MegawattsTolerance);
Assert.Equal(LuminosityUnit.Megawatt, megawattQuantity.Unit);
var microwattQuantity = watt.ToUnit(LuminosityUnit.Microwatt);
AssertEx.EqualTolerance(MicrowattsInOneWatt, (decimal)microwattQuantity.Value, MicrowattsTolerance);
Assert.Equal(LuminosityUnit.Microwatt, microwattQuantity.Unit);
var milliwattQuantity = watt.ToUnit(LuminosityUnit.Milliwatt);
AssertEx.EqualTolerance(MilliwattsInOneWatt, (decimal)milliwattQuantity.Value, MilliwattsTolerance);
Assert.Equal(LuminosityUnit.Milliwatt, milliwattQuantity.Unit);
var nanowattQuantity = watt.ToUnit(LuminosityUnit.Nanowatt);
AssertEx.EqualTolerance(NanowattsInOneWatt, (decimal)nanowattQuantity.Value, NanowattsTolerance);
Assert.Equal(LuminosityUnit.Nanowatt, nanowattQuantity.Unit);
var petawattQuantity = watt.ToUnit(LuminosityUnit.Petawatt);
AssertEx.EqualTolerance(PetawattsInOneWatt, (decimal)petawattQuantity.Value, PetawattsTolerance);
Assert.Equal(LuminosityUnit.Petawatt, petawattQuantity.Unit);
var picowattQuantity = watt.ToUnit(LuminosityUnit.Picowatt);
AssertEx.EqualTolerance(PicowattsInOneWatt, (decimal)picowattQuantity.Value, PicowattsTolerance);
Assert.Equal(LuminosityUnit.Picowatt, picowattQuantity.Unit);
var solarluminosityQuantity = watt.ToUnit(LuminosityUnit.SolarLuminosity);
AssertEx.EqualTolerance(SolarLuminositiesInOneWatt, (decimal)solarluminosityQuantity.Value, SolarLuminositiesTolerance);
Assert.Equal(LuminosityUnit.SolarLuminosity, solarluminosityQuantity.Unit);
var terawattQuantity = watt.ToUnit(LuminosityUnit.Terawatt);
AssertEx.EqualTolerance(TerawattsInOneWatt, (decimal)terawattQuantity.Value, TerawattsTolerance);
Assert.Equal(LuminosityUnit.Terawatt, terawattQuantity.Unit);
var wattQuantity = watt.ToUnit(LuminosityUnit.Watt);
AssertEx.EqualTolerance(WattsInOneWatt, (decimal)wattQuantity.Value, WattsTolerance);
Assert.Equal(LuminosityUnit.Watt, wattQuantity.Unit);
}
public void Convert_ChangeType_BaseDimensions_EqualsBaseDimensions()
{
var quantity = Luminosity.FromWatts(1.0);
Assert.Equal(Luminosity.BaseDimensions, Convert.ChangeType(quantity, typeof(BaseDimensions)));
}
public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
{
var quantityInBaseUnit = Luminosity.FromWatts(1).ToBaseUnit();
Assert.Equal(Luminosity.BaseUnit, quantityInBaseUnit.Unit);
}
public void GetHashCode_Equals()
{
var quantity = Luminosity.FromWatts(1.0);
Assert.Equal(new { Luminosity.QuantityType, quantity.Value, quantity.Unit }.GetHashCode(), quantity.GetHashCode());
}
public void CompareToThrowsOnTypeMismatch()
{
Luminosity watt = Luminosity.FromWatts(1);
Assert.Throws <ArgumentException>(() => watt.CompareTo(new object()));
}
public static void SetClickFeedback(DependencyObject i, Luminosity v) => i.Set(ClickFeedbackProperty, v);
public void CompareToThrowsOnNull()
{
Luminosity watt = Luminosity.FromWatts(1);
Assert.Throws <ArgumentNullException>(() => watt.CompareTo(null));
}
