public void ConstructRgbAttributeBadValues()
{
int testCount = 0;
int exceptionCount = 0;
// Test values outside valid range [0, 255]
int[,] rgbTestValues = new int[, ] {
{ -1, 0, 0 }, { 0, -1, 0 }, { 0, 0, -1 },
{ 256, 0, 0 }, { 0, 256, 0 }, { 0, 0, 256 }
};
for (int i = 0; i < rgbTestValues.GetLength(0); i++)
{
try
{
testCount++;
RgbAttribute rgb = new RgbAttribute(rgbTestValues[i, 0], rgbTestValues[i, 1], rgbTestValues[i, 2]);
}
catch (ArgumentException)
{
exceptionCount++;
}
}
Assert.AreEqual(testCount, exceptionCount);
}
/// <summary>
/// Creates a new instance of RgbAttribute with the specified RGB and alpha values.
/// </summary>
/// <param name="rgb">The colour's RGB value. MUST NOT BE NULL</param>
/// <param name="alpha">The colour's alpha value. MUST BE WITHIN RANGE [0,1]</param>
public Color(RgbAttribute rgb, double alpha)
{
Preconditions.IsNotNull(rgb, "Color rgb property must not be null");
Preconditions.IsWithinRange(alpha, MIN_ALPHA, MAX_ALPHA, "alpha");
this.Rgb = rgb;
this.Alpha = alpha;
}
/// <summary>
/// Parses a URDF <color> element from XML.
/// </summary>
/// <param name="node">The XML node of a <color> element</param>
/// <returns>A Color object parsed from the XML</returns>
public override Color Parse(XmlNode node)
{
ValidateXmlNode(node);
XmlAttribute rgbAttribute = GetAttributeFromNode(node, UrdfSchema.RGB_ATTRIBUTE_NAME);
XmlAttribute alphaAttribute = GetAttributeFromNode(node, UrdfSchema.ALPHA_ATTRIBUTE_NAME);
XmlAttribute rgbaAttribute = GetAttributeFromNode(node, UrdfSchema.RGBA_ATTRIBUTE_NAME);
RgbAttribute rgb;
double alpha;
if (rgbaAttribute != null && rgbAttribute == null && alphaAttribute == null)
{
Tuple <RgbAttribute, double> rgba = ParseRgba(rgbaAttribute);
rgb = rgba.Item1;
alpha = rgba.Item2;
}
else if (rgbAttribute == null)
{
//Logger.Warn("Parsing {0} failed due to missing both {1} and {2} attributes", ElementName, UrdfSchema.RGBA_ATTRIBUTE_NAME, UrdfSchema.RGB_ATTRIBUTE_NAME);
rgb = new RgbAttribute(DEFAULT_RGB_VALUE, DEFAULT_RGB_VALUE, DEFAULT_RGB_VALUE);
alpha = DEFAULT_ALPHA_VALUE;
}
else
{
rgb = ParseRgb(rgbAttribute);
alpha = ParseAlpha(alphaAttribute);
}
return(new Color(rgb, alpha));
}
private Tuple <RgbAttribute, double> ParseRgba(XmlAttribute rgbaAttribute)
{
RgbAttribute rgb = new RgbAttribute(DEFAULT_RGB_VALUE, DEFAULT_RGB_VALUE, DEFAULT_RGB_VALUE);
double alpha = DEFAULT_ALPHA_VALUE;
if (rgbaAttribute == null)
{
LogMissingOptionalAttribute(UrdfSchema.RGBA_ATTRIBUTE_NAME);
}
else
{
if (!RegexUtils.IsMatchNDoubles(rgbaAttribute.Value, 4))
{
LogMalformedAttribute(UrdfSchema.RGBA_ATTRIBUTE_NAME);
}
else
{
double[] values = RegexUtils.MatchDoubles(rgbaAttribute.Value);
rgb = new RgbAttribute(values[0], values[1], values[2]);
alpha = values[3];
}
}
return(new Tuple <RgbAttribute, double>(rgb, alpha));
}
public void ConstructColorNoAlpha()
{
RgbAttribute rgb = new RgbAttribute(255, 255, 255);
Color colour = new Color(rgb);
Assert.AreEqual(rgb, colour.Rgb);
Assert.AreEqual(1d, colour.Alpha);
}
public void ConstructRgbAttributeDoubles()
{
double r = 0.5d;
double g = 0.75d;
double b = 0d;
RgbAttribute rgb = new RgbAttribute(r, g, b);
Assert.AreEqual((int)(255 * r), rgb.R);
Assert.AreEqual((int)(255 * g), rgb.G);
Assert.AreEqual((int)(255 * b), rgb.B);
}
public void ConstructRgbAttribute()
{
int r = 255;
int g = 255;
int b = 255;
RgbAttribute rgb = new RgbAttribute(r, g, b);
Assert.AreEqual(r, rgb.R);
Assert.AreEqual(g, rgb.G);
Assert.AreEqual(b, rgb.B);
}
public void ConstructColorWithAlpha()
{
double alpha = 0.5;
RgbAttribute rgb = new RgbAttribute(255, 255, 255);
Color colour = new Color(rgb, alpha);
Assert.AreEqual(rgb, colour.Rgb);
Assert.AreEqual(alpha, colour.Alpha);
// Test bounds [0,1]
colour = new Color(rgb, 0d);
colour = new Color(rgb, 1d);
}
public void EqualsAndHash()
{
RgbAttribute rgb = new RgbAttribute(1, 2, 3);
RgbAttribute same = new RgbAttribute(1, 2, 3);
RgbAttribute diff = new RgbAttribute(3, 2, 1);
Assert.IsTrue(rgb.Equals(rgb));
Assert.IsFalse(rgb.Equals(null));
Assert.IsTrue(rgb.Equals(same));
Assert.IsTrue(same.Equals(rgb));
Assert.IsFalse(rgb.Equals(diff));
Assert.AreEqual(rgb.GetHashCode(), same.GetHashCode());
Assert.AreNotEqual(rgb.GetHashCode(), diff.GetHashCode());
}
public void ParseMaterialColor()
{
string name = "name";
RgbAttribute rgb = new RgbAttribute(1, 1, 1);
string xml = String.Format("<material name='{0}'><color rgb='{1} {2} {3}'/></material>",
name, rgb.R, rgb.B, rgb.G);
this.xmlDoc.Load(XmlReader.Create(new StringReader(xml)));
Material material = this.parser.Parse(this.xmlDoc.DocumentElement);
Assert.AreEqual(name, material.Name);
Assert.AreEqual(rgb, material.Color.Rgb);
Assert.IsNull(material.Texture);
}
public void ConstructColorInvalidAlpha()
{
int testCount = 0;
int exceptionCount = 0;
RgbAttribute rgb = new RgbAttribute(0, 0, 0);
double[] alphaTestValues = new double[] { -1, -0.0001, 1.00000001, 2 };
for (int i = 0; i < alphaTestValues.Length; i++)
{
testCount++;
try
{
Color colour = new Color(rgb, alphaTestValues[i]);
}
catch (ArgumentException)
{
exceptionCount++;
}
}
Assert.AreEqual(testCount, exceptionCount);
}
private RgbAttribute ParseRgb(XmlAttribute rgbAttribute)
{
RgbAttribute rgb = new RgbAttribute(DEFAULT_RGB_VALUE, DEFAULT_RGB_VALUE, DEFAULT_RGB_VALUE);
if (rgbAttribute == null)
{
LogMissingOptionalAttribute(UrdfSchema.RGB_ATTRIBUTE_NAME);
}
else
{
if (!RegexUtils.IsMatchNDoubles(rgbAttribute.Value, 3))
{
LogMalformedAttribute(UrdfSchema.RGB_ATTRIBUTE_NAME);
}
else
{
int[] values = RegexUtils.MatchInts(rgbAttribute.Value);
rgb = new RgbAttribute(values[0], values[1], values[2]);
}
}
return(rgb);
}
/// <summary>
/// Creates a new instance of RgbAtribute with the specified RGB value.
/// </summary>
/// <param name="rgb">The colour's RGB value. MUST NOT BE NULL</param>
public Color(RgbAttribute rgb) : this(rgb, DEFAULT_ALPHA)
{
// Invoke overloaded constructor.
}
