public static Image<Gray, byte> ToScaledSmoothedCanny(this Image<Bgr,byte> image)
{
Image<Gray, Byte> grayFrame = image.Convert<Gray, Byte>();
Image<Gray, Byte> smallGrayFrame = grayFrame.PyrDown();
Image<Gray, Byte> smoothedGrayFrame = smallGrayFrame.PyrUp();
Image<Gray, Byte> cannyFrame = smoothedGrayFrame.Canny(new Gray(100), new Gray(60));
return cannyFrame;
}
/// <summary>
/// Extends Convert so that buffer offset of 0 and call to Array.Length are not needed.
/// <example>
/// decoder.Convert(bytes, chars, charIndex, charCount, flush, bytesUsed, charsUsed, completed);
/// </example>
/// </summary>
public static void Convert(this Decoder decoder, Byte[] bytes, Char[] chars, Int32 charIndex, Int32 charCount, Boolean flush, out Int32 bytesUsed, out Int32 charsUsed, out Boolean completed)
{
if(decoder == null) throw new ArgumentNullException("decoder");
if(bytes == null) throw new ArgumentNullException("bytes");
decoder.Convert(bytes, 0, bytes.Length, chars, charIndex, charCount, flush, out bytesUsed, out charsUsed, out completed);
}
/// <summary>
/// Extends Convert so that buffer offset of 0 and call to Array.Length are not needed.
/// <example>
/// encoder.Convert(chars, bytes, byteIndex, byteCount, flush, charsUsed, bytesUsed, completed);
/// </example>
/// </summary>
public static void Convert(this Encoder encoder, Char[] chars, Byte[] bytes, Int32 byteIndex, Int32 byteCount, Boolean flush, out Int32 charsUsed, out Int32 bytesUsed, out Boolean completed)
{
if(encoder == null) throw new ArgumentNullException("encoder");
if(chars == null) throw new ArgumentNullException("chars");
encoder.Convert(chars, 0, chars.Length, bytes, byteIndex, byteCount, flush, out charsUsed, out bytesUsed, out completed);
}
/// <summary>
/// Converts a value and handles typical bugs of Toolkit and official IValueConverters.
/// </summary>
/// <param name="vc"></param>
/// <param name="value"></param>
/// <param name="targetType"></param>
/// <param name="parameter"></param>
/// <param name="culture"></param>
/// <returns></returns>
public static object ConvertSafe(this IValueConverter vc, object value, Type targetType, object parameter, CultureInfo culture)
{
// WP7 Toolkit's time converters have a bug where dates of different time zones are not properly
// converted, and also crash the app. This fixes it.
// See https://github.com/WFoundation/WF.Player.WinPhone/issues/23
if (value is DateTime)
{
DateTime dtValue = (DateTime)value;
// Lets the converter try converting the raw value.
try
{
vc.Convert(dtValue, targetType, parameter, culture);
}
catch (NotSupportedException)
{
// Fix the value date time by converting it to local time.
DateTime fixedValue = dtValue.ToLocalTime();
// The conversion should be fine now.
try
{
return vc.Convert(fixedValue, targetType, parameter, culture);
}
catch (NotSupportedException)
{
// Despite all precautions, if the conversion still doesn't work, this probably means that
// the date is still considered to be "in the future". Let's assume it's not too far from the present...
try
{
return vc.Convert(DateTime.Now, targetType, parameter, culture);
}
catch (Exception)
{
// Great despair, and nothing much to be done...
return null;
}
}
}
}
// Let the wrapper converter handle other values.
return vc.Convert(value, targetType, parameter, culture);
}
/// <summary>
/// Converts persistence objects to immutable statistics objects
/// </summary>
/// <param name="dataArray">The persistence data objects.</param>
/// <returns>array of statistics objects</returns>
public static ExecutionStatistics[] FromPersistence(this ExecutionData[] dataArray)
{
return dataArray.Convert(
d => new ExecutionStatistics(
d.Name,
d.OpenCount,
d.CloseCount,
d.Counters,
d.RunningTime));
}
public static Image<Bgr, Byte> ColorLevel(this Image<Gray, Byte> src, ConnectLevel conn)
{
var dst = src.Convert<Bgr, Byte>();
var color = new Bgr(0, 0, 255);
foreach (var domain in conn.Domains) {
foreach (var p in domain.Points) {
dst[p.Y, p.X] = color;
}
}
return dst;
}
/// <summary>
/// Converts immutable statistics objects to the persistence objects
/// </summary>
/// <param name="statisticsArray">The immutable statistics objects.</param>
/// <returns>array of persistence objects</returns>
public static ExecutionData[] ToPersistence(this ExecutionStatistics[] statisticsArray)
{
return statisticsArray.Convert(es => new ExecutionData
{
CloseCount = es.CloseCount,
Counters = es.Counters,
Name = es.Name,
OpenCount = es.OpenCount,
RunningTime = es.RunningTime
});
}
public static ListViewGroupedModel<ConsignDetail> ToListViewGroupData(this ConsignDto dto)
{
var lst = dto.Convert();
var a = lst.ToLookup(l => l.Group)
.Select(l => new ListViewGroup<ConsignDetail>(l) {
Title = l.Key,
ShortTitle = l.Key,
});
return new ListViewGroupedModel<ConsignDetail>() {
Groups = new ObservableCollection<ListViewGroup<ConsignDetail>>(a)
};
}
public static IEnsuring Enumerable(this IBooleanCondition<Type> condition)
{
var concreteCondition = condition.Convert<ConditionTree<Type>>();
var isEnumerable = concreteCondition.Value.IsEnumerable();
if (!concreteCondition.IsNegated)
{
if (!isEnumerable)
{
if (concreteCondition.IsArgument)
{
var defaultException = new ArgumentException("The type is not enumerable.", concreteCondition.ArgumentName);
ConditionalException
.Throw(defaultException, concreteCondition.Exception);
}
ConditionalException
.Throw(new TypeIsNotEnumerableException(), concreteCondition.Exception);
}
}
else
{
if (isEnumerable)
{
if (concreteCondition.IsArgument)
{
var defaultException = new ArgumentException("The type is enumerable.", concreteCondition.ArgumentName);
ConditionalException
.Throw(defaultException, concreteCondition.Exception);
}
ConditionalException
.Throw(new TypeIsEnumerableException(), concreteCondition.Exception);
}
}
return EnsuringWrapper.Create();
}
public static global::Cairo.Color ToCairo(this IColor me)
{
Color.Bgra bgra = me.Convert<Color.Bgra>();
return new global::Cairo.Color(bgra.Red / 255.0, bgra.Green / 255.0, bgra.Blue / 255.0, bgra.Alpha / 255.0);
}
/// <summary>
/// Convert the specified time duration in the given unit to the
/// nanoseconds units.
/// </summary>
public static double ToNanos(this TimeUnit @from, long duration) {
return @from.Convert(duration, TimeUnit.Nanoseconds);
}
public static object Convert(this IStepArgumentTypeConverter converter, object value, Type typeToConvertTo, CultureInfo cultureInfo)
{
return converter.Convert(value, new RuntimeBindingType(typeToConvertTo), cultureInfo);
}
public static Pen AddColor(this Pen pen, Color addColor, float percent)
{
return pen.Convert(pen.Color.AddColor(addColor, percent));
}
public static Pen ToBlueGrayScale(this Pen pen)
{
return pen.Convert(pen.Color.ToBlueGrayScale());
}
public static object Call(this IValueConverter converter, object value)
{
return converter.Convert(value, null, null, null);
}
/// <summary>
/// Encodes the individual route values to be lower-case and containing hypens
/// instead of spaces.
/// It does not alter the controller and action route values
/// </summary>
/// <param name="route">Route value dictionary containing the route data</param>
public static RouteValueDictionary Encode(this RouteValueDictionary route)
{
return route.Convert(@" ", @"-", true);
}
/// <summary>
/// Decodes the individual route values to replace the hypens with spaces.
/// It does not alter the case of the value and does not alter the controller
/// and action route values
/// </summary>
/// <param name="route">Route value dictionary containing the route data</param>
public static RouteValueDictionary Decode(this RouteValueDictionary route)
{
return route.Convert(@"-", @" ", false);
}
public static string[] GetNames(this IList<INamable> namables)
{
return namables.Convert(namableToName);
}
/// <summary>
/// Convert the specified time duration in the given unit to the
/// seconds units.
/// </summary>
/// <returns></returns>
public static double ToMilliseconds(this TimeUnit @from, double duration) {
return @from.Convert(duration, TimeUnit.Milliseconds);
}
/// <summary>
/// Calculates magnitude of the specified complex image.
/// </summary>
/// <param name="image">Image.</param>
/// <param name="area">The specified working area.</param>
/// <returns>Magnitude image.</returns>
public static Gray<float>[,] Magnitude(this ComplexF[,] image, Rectangle area)
{
return image.Convert<ComplexF, Gray<float>>(convertComplexToMagnitude, area);
}
public static Pen Darker(this Pen pen, int div)
{
return pen.Convert(pen.Color.Darker(div));
}
/// <summary>
/// Convert the specified time duration in the given unit to the
/// nanoseconds units.
/// </summary>
/// <returns></returns>
public static long ToTicks(this TimeUnit @from, double duration) {
return (long) @from.Convert(duration, TimeUnit.Ticks);
}
public static Pen Brighter(this Pen pen, int div)
{
return pen.Convert(pen.Color.Brighter(div));
}
public static float ToPixels(this Quantity Q)
{
return (float)Q.Convert(Game.SI.px).Amount;
}
public static Pen ToNegative(this Pen pen)
{
return pen.Convert(pen.Color.ToNegative());
}
public static Image<Gray, byte> ToGray(this Image<Bgr, byte> image)
{
return image.Convert<Gray, byte>();
}
/// <summary>
/// Cast the value to another type.
/// </summary>
/// <param name="unit">Source unit.</param>
/// <param name="destinationType">Destination value type.</param>
/// <param name="security">Information about the instrument. Required when using <see cref="UnitTypes.Point"/> и <see cref="UnitTypes.Step"/>.</param>
/// <returns>Converted value.</returns>
public static Unit Convert(this Unit unit, UnitTypes destinationType, Security security)
{
return unit.Convert(destinationType, type => GetTypeValue(security, type));
}
public static object Convert(this IConverterStrategy strategy, string text)
{
return strategy.Convert(new ConversionRequest(text));
}
public static float ToMeters(this Quantity Q)
{
return (float)Q.Convert(Game.SI.m).Amount;
}
/// <summary>
/// Converts the grayscale image to a complex image where the specified image is taken as a real part.
/// </summary>
/// <param name="image">Real part of a complex image.</param>
/// <returns>Complex image.</returns>
public static ComplexF[,] ToComplex(this Gray<float>[,] image)
{
return image.Convert<Gray<float>, ComplexF>(convertGrayToComplex);
}
