/// <summary>
/// Convert from one Measurement to another. This takes care of finding
/// a ConvertProc out of the converters dictionary and applies it; throws
/// an Exception if the (incoming.BaseUnit -> outgoingUnits) converter
/// function cannot be found.
/// </summary>
/// <param name="from">The Measurement to convert</param>
/// <param name="to">The units of measure to convert to</param>
/// <returns>Converted Measurement</returns>
public static IMeasurement Convert(IMeasurement from, string to)
{
// Identity transformation always works. We do handle
// differences in exponent
if (_SIUnits.BaseUnit(to) == from.BaseUnit)
{
if (_SIUnits.Exponent(to) == from.Exponent)
{
return(from);
}
var toExp = _SIUnits.Exponent(to);
var expDiff = from.Exponent - toExp;
return(new Measurement(from.Quantity * (decimal)Math.Pow(10, expDiff), toExp, _SIUnits.BaseUnit(to)));
}
// Can we find a converter for these two units? Use TryGetValue()
// to avoid the KeyNotFoundException that gets thrown using the
// traditional [] lookup--we want to throw our own exception.
//
ConvertProc converter = null;
if (converters.TryGetValue(new Tuple <string, string>(from.BaseUnit, to), out converter))
{
return(converter(from));
}
// I dunno what the hell you're trying to convert
//
throw new Exception(
String.Format(
"Unrecognized Measurement conversion: {0} to {1}",
from.BaseUnit, to));
}
public void InputDataConversion()
{
IDictionary <string, object> config = new Dictionary <string, object>(2);
config["param1"] = 10;
config["param2"] = 1;
IMeasurement srate = new Measurement(1000, "Hz");
IInputData data = new InputData(this.Data,
srate,
DateTimeOffset.Now,
new PipelineNodeConfiguration(IOData.STREAM_CONFIGURATION_NAME, new Dictionary <string, object>()))
.DataWithExternalDeviceConfiguration(devFake, new Dictionary <string, object>());
Converters.Clear();
ConvertProc fooConversion = (m) => new Measurement(m.QuantityInBaseUnit * 10, 1, "foo");
Converters.Register("V", "foo", fooConversion);
IInputData expected = new InputData(data,
data.Data.Select(m => new Measurement(m.QuantityInBaseUnit * 10, 1, "foo")).ToList());
Assert.NotNull(expected.NodeConfigurationWithName(IOData.STREAM_CONFIGURATION_NAME));
IInputData actual = data.DataWithUnits("foo");
Assert.AreEqual(expected.Data, actual.Data);
Assert.That(actual.NodeConfigurationWithName(IOData.EXTERNAL_DEVICE_CONFIGURATION_NAME),
Is.EqualTo(expected.NodeConfigurationWithName(IOData.EXTERNAL_DEVICE_CONFIGURATION_NAME)));
Assert.That(actual.NodeConfigurationWithName(IOData.STREAM_CONFIGURATION_NAME),
Is.EqualTo(expected.NodeConfigurationWithName(IOData.STREAM_CONFIGURATION_NAME)));
Assert.AreEqual(expected.InputTime, actual.InputTime);
}
/// <summary>
/// Register a ConvertProc routine as the code to use when converting
/// a Measurement from the "from" units to the "to" units
/// </summary>
/// <param name="from">The unit type converting from</param>
/// <param name="to">The unit type to conver to</param>
/// <param name="proc">The code to do the conversion</param>
public static void Register(string from, string to, ConvertProc proc)
{
// Overwrite on duplication
ConvertProc obj;
if (converters.TryGetValue(new Tuple <string, string>(from, to), out obj))
{
converters.Remove(new Tuple <string, string>(from, to));
}
converters.Add(new Tuple <string, string>(from, to), proc);
}
public void InputDataConversionViaProc()
{
IDictionary <string, object> config = new Dictionary <string, object>(2);
config["param1"] = 10;
config["param2"] = 1;
IMeasurement srate = new Measurement(1000, "Hz");
IOutputData outData = new OutputData(this.Data,
srate, false)
.DataWithExternalDeviceConfiguration(devFake, new Dictionary <string, object>())
.DataWithStreamConfiguration(streamFake, new Dictionary <string, object>());
outData.OutputTime = DateTimeOffset.Now;
Converters.Clear();
ConvertProc fooConversion = (m) => new Measurement(m.QuantityInBaseUnit * 10, 1, "foo");
Converters.Register("V", "foo", fooConversion);
IOutputData expected = new OutputData(outData,
outData.Data.Select(m => new Measurement(m.QuantityInBaseUnit * 10, 1, "foo")).ToList())
{
OutputTime = outData.OutputTime
};
IOutputData actual = outData.DataWithConversion((m) => new Measurement(m.QuantityInBaseUnit * 10, 1, "foo"));
Assert.AreEqual(expected.Data, actual.Data);
Assert.AreEqual(expected.NodeConfigurationWithName(IOData.EXTERNAL_DEVICE_CONFIGURATION_NAME),
actual.NodeConfigurationWithName(IOData.EXTERNAL_DEVICE_CONFIGURATION_NAME));
Assert.AreEqual(expected.NodeConfigurationWithName(IOData.STREAM_CONFIGURATION_NAME),
actual.NodeConfigurationWithName(IOData.STREAM_CONFIGURATION_NAME));
Assert.AreEqual(expected.OutputTime, actual.OutputTime);
}
