public void AccelerationConversions(double value1, AccelerationUnit units1, double value2, AccelerationUnit units2)
{
new Acceleration(value1, units1) {
Units = units2
}.Value.ShouldBeWithinEpsilonOf(value2);
new Acceleration(value2, units2) {
Units = units1
}.Value.ShouldBeWithinEpsilonOf(value1);
}
public void ReadXML(XmlReader reader)
{
reader.ReadStartElement();
while (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case "TimecodeFormat":
timecodeFormat = (TimecodeFormat)Enum.Parse(typeof(TimecodeFormat), reader.ReadElementContentAsString());
break;
case "SpeedUnit":
speedUnit = (SpeedUnit)Enum.Parse(typeof(SpeedUnit), reader.ReadElementContentAsString());
break;
case "AccelerationUnit":
accelerationUnit = (AccelerationUnit)Enum.Parse(typeof(AccelerationUnit), reader.ReadElementContentAsString());
break;
case "AngleUnit":
angleUnit = (AngleUnit)Enum.Parse(typeof(AngleUnit), reader.ReadElementContentAsString());
break;
case "AngularVelocityUnit":
angularVelocityUnit = (AngularVelocityUnit)Enum.Parse(typeof(AngularVelocityUnit), reader.ReadElementContentAsString());
break;
case "AngularAccelerationUnit":
angularAccelerationUnit = (AngularAccelerationUnit)Enum.Parse(typeof(AngularAccelerationUnit), reader.ReadElementContentAsString());
break;
case "CustomLengthUnit":
customLengthUnit = reader.ReadElementContentAsString();
break;
case "CustomLengthAbbreviation":
customLengthAbbreviation = reader.ReadElementContentAsString();
break;
case "AspectRatio":
aspectRatio = (ImageAspectRatio)Enum.Parse(typeof(ImageAspectRatio), reader.ReadElementContentAsString());
break;
case "DeinterlaceByDefault":
deinterlaceByDefault = XmlHelper.ParseBoolean(reader.ReadElementContentAsString());
break;
case "InteractiveFrameTracker":
interactiveFrameTracker = XmlHelper.ParseBoolean(reader.ReadElementContentAsString());
break;
case "WorkingZoneSeconds":
workingZoneSeconds = reader.ReadElementContentAsInt();
break;
case "WorkingZoneMemory":
workingZoneMemory = reader.ReadElementContentAsInt();
break;
case "SyncLockSpeed":
syncLockSpeed = XmlHelper.ParseBoolean(reader.ReadElementContentAsString());
break;
case "ImageFormat":
imageFormat = (KinoveaImageFormat)Enum.Parse(typeof(KinoveaImageFormat), reader.ReadElementContentAsString());
break;
case "VideoFormat":
videoFormat = (KinoveaVideoFormat)Enum.Parse(typeof(KinoveaVideoFormat), reader.ReadElementContentAsString());
break;
case "InfoFading":
defaultFading.ReadXml(reader);
break;
case "MaxFading":
maxFading = reader.ReadElementContentAsInt();
break;
case "DrawOnPlay":
drawOnPlay = XmlHelper.ParseBoolean(reader.ReadElementContentAsString());
break;
case "RecentColors":
ParseRecentColors(reader);
break;
case "MaxRecentColors":
maxRecentColors = reader.ReadElementContentAsInt();
break;
case "TrackingProfile":
trackingProfile.ReadXml(reader);
break;
case "EnableFiltering":
enableFiltering = XmlHelper.ParseBoolean(reader.ReadElementContentAsString());
break;
case "EnableCustomToolsDebugMode":
enableCustomToolsDebugMode = XmlHelper.ParseBoolean(reader.ReadElementContentAsString());
break;
default:
reader.ReadOuterXml();
break;
}
}
reader.ReadEndElement();
}
/// <summary>
/// Takes an acceleration in length unit per second squared and returns it in acceleration unit.
/// </summary>
public static float ConvertAcceleration(float a, LengthUnit lengthUnit, AccelerationUnit unit)
{
float perSecondSquared = ConvertLengthForAccelerationUnit(a, lengthUnit, unit);
return(perSecondSquared);
}
public string ToString(AccelerationUnit unit, CultureInfo culture = null, int significantDigitsAfterRadix = 2)
{
return(ToString(unit, culture, UnitFormatter.GetFormat(As(unit), significantDigitsAfterRadix)));
}
/// <summary>
/// Get string representation of value and unit. Using two significant digits after radix.
/// </summary>
/// <param name="unit">Unit representation to use.</param>
/// <param name="culture">Culture to use for localization and number formatting.</param>
/// <returns>String representation.</returns>
public string ToString(AccelerationUnit unit, [CanBeNull] Culture culture)
{
return(ToString(unit, culture, 2));
}
public static string GetAbbreviation(AccelerationUnit unit, [CanBeNull] Culture culture)
{
return(UnitSystem.GetCached(culture).GetDefaultAbbreviation(unit));
}
Acceleration(double numericValue, AccelerationUnit unit)
{
_value = numericValue;
_unit = unit;
}
public static bool TryParseUnit(string str, out AccelerationUnit unit)
{
return(TryParseUnit(str, null, out unit));
}
/// <summary>
/// Dynamically convert from value and unit enum <see cref="AccelerationUnit" /> to <see cref="Acceleration" />.
/// </summary>
/// <param name="value">Value to convert from.</param>
/// <param name="fromUnit">Unit to convert from.</param>
/// <returns>Acceleration unit value.</returns>
public static Acceleration?From(QuantityValue?value, AccelerationUnit fromUnit)
{
return(value.HasValue ? new Acceleration((double)value.Value, fromUnit) : default(Acceleration?));
}
/// <summary>
/// Creates the quantity with the given numeric value and unit.
/// </summary>
/// <param name="value">The numeric value to construct this quantity with.</param>
/// <param name="unit">The unit representation to construct this quantity with.</param>
/// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
public Acceleration(double value, AccelerationUnit unit)
{
_value = value;
_unit = unit;
}
/// <summary>
/// Converts this Duration to another Duration with the unit representation <paramref name="unit" />.
/// </summary>
/// <returns>A Duration with the specified unit.</returns>
public Acceleration ToUnit(AccelerationUnit unit)
{
var convertedValue = GetValueAs(unit);
return(new Acceleration(convertedValue, unit));
}
/// <summary> /// Convert to the unit representation <paramref name="unit" />. /// </summary> /// <returns>Value converted to the specified unit.</returns> public double As(AccelerationUnit unit) => GetValueAs(unit);
public static string GetAbbreviation(AccelerationUnit unit, [CanBeNull] IFormatProvider provider)
{
provider = provider ?? UnitSystem.DefaultCulture;
return(UnitSystem.GetCached(provider).GetDefaultAbbreviation(unit));
}
protected override AccelerationUnit __DoSubstraction(AccelerationUnit right)
{
return new MetrePerSecondSquared(Value - right.Value);
}
public static Acceleration From(QuantityValue value, AccelerationUnit fromUnit)
#endif
{
return(new Acceleration((double)value, fromUnit));
}
public void Conversion(double value, AccelerationUnit unit, double expected, AccelerationUnit targetUnit, double accurracy = 1e-10)
{
var v = new Measurement <AccelerationUnit>(value, unit);
v.In(targetUnit).Should().BeApproximately(expected, accurracy);
}
protected override AccelerationUnit __DoAddition(AccelerationUnit right)
{
return new MetrePerSecondSquared(Value + right.Value);
}
/// <summary>
/// Initializes a new instance of the <see cref="Gu.Units.Wpf.AccelerationConverter"/> class.
/// </summary>
/// <param name="unit"><see cref="Gu.Units.AccelerationUnit"/>.</param>
public AccelerationConverter(AccelerationUnit unit)
{
this.Unit = unit;
}
/// <summary>
/// Parse a unit string.
/// </summary>
/// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
/// <param name="unit">The parsed unit if successful.</param>
/// <returns>True if successful, otherwise false.</returns>
/// <example>
/// Length.TryParseUnit("m", new CultureInfo("en-US"));
/// </example>
/// <param name="cultureName">Name of culture (ex: "en-US") to use when parsing number and unit. Defaults to <see cref="GlobalConfiguration.DefaultCulture" /> if null.</param>
public static bool TryParseUnit(string str, [CanBeNull] string cultureName, out AccelerationUnit unit)
{
IFormatProvider provider = GetFormatProviderFromCultureName(cultureName);
return(UnitParser.Default.TryParse <AccelerationUnit>(str, provider, out unit));
}
public static string GetAbbreviation(
AccelerationUnit unit,
#if WINDOWS_UWP
[CanBeNull] string cultureName)
/// <summary>
/// Converts this Acceleration to another Acceleration with the unit representation <paramref name="unit" />.
/// </summary>
/// <returns>A Acceleration with the specified unit.</returns>
public Acceleration ToUnit(AccelerationUnit unit)
{
var convertedValue = AsBaseNumericType(unit);
return(new Acceleration(convertedValue, unit));
}
public string GetAccelerationAbbreviation()
{
AccelerationUnit unit = IsCalibrated ? accelerationUnit : AccelerationUnit.PixelsPerSecondSquared;
return(UnitHelper.AccelerationAbbreviation(unit));
}
/// <summary>
/// Get string representation of value and unit. Using current UI culture and two significant digits after radix.
/// </summary>
/// <param name="unit">Unit representation to use.</param>
/// <returns>String representation.</returns>
public string ToString(AccelerationUnit unit)
{
return(ToString(unit, null, 2));
}
public static Acceleration From(double value, AccelerationUnit fromUnit)
{
return(new Acceleration((double)value, fromUnit));
}
public static string GetAbbreviation(AccelerationUnit unit, CultureInfo culture = null)
{
return(UnitSystem.GetCached(culture).GetDefaultAbbreviation(unit));
}
private AccelerationJsonConverter(AccelerationUnit unit)
{
this.unit = unit;
}
public string ToString(AccelerationUnit unit, CultureInfo culture, string format, params object[] args)
{
return(string.Format(culture, format, UnitFormatter.GetFormatArgs(unit, As(unit), culture, args)));
}
private void cmbAccelerationUnit_SelectedIndexChanged(object sender, EventArgs e)
{
accelerationUnit = (AccelerationUnit)cmbAccelerationUnit.SelectedIndex;
}
private static float ConvertLengthForAccelerationUnit(float length, LengthUnit lengthUnit, AccelerationUnit accUnit)
{
// Convert from one length unit to another, target unit is extracted from acceleration unit.
// We first convert from whatever unit into meters, then from meters to the output.
// The scenario where the space is calibrated but the user wants the acceleration in pixels is not supported.
if (lengthUnit == LengthUnit.Pixels || lengthUnit == LengthUnit.Percentage)
{
return(length);
}
double meters = GetMeters(length, lengthUnit);
double result = 0;
switch (accUnit)
{
case AccelerationUnit.FeetPerSecondSquared:
result = meters / footToMeters;
break;
case AccelerationUnit.MetersPerSecondSquared:
result = meters;
break;
case AccelerationUnit.PixelsPerSecondSquared:
default:
result = 0;
break;
}
return((float)result);
}
/// <summary>
/// Get unit abbreviation string.
/// </summary>
/// <param name="unit">Unit to get abbreviation for.</param>
/// <returns>Unit abbreviation string.</returns>
/// <param name="cultureName">Name of culture (ex: "en-US") to use when parsing number and unit. Defaults to <see cref="GlobalConfiguration.DefaultCulture" /> if null.</param>
public static string GetAbbreviation(AccelerationUnit unit, [CanBeNull] string cultureName)
{
IFormatProvider provider = GetFormatProviderFromCultureName(cultureName);
return(UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit, provider));
}
public static Acceleration From(double value, AccelerationUnit fromUnit)
public static Acceleration From(decimal value, AccelerationUnit fromUnit)
{
return(new Acceleration((decimal)value, fromUnit));
}
public static string GetAbbreviation(AccelerationUnit unit)
{
return(GetAbbreviation(unit, null));
}
protected static string CreateSuffix(SymbolFormat format, AccelerationUnit unit)
{
return default(Acceleration).ToString(unit, format).Trim('0');
}
