/// <summary>
/// 返回指定类型的对象，其值等效于指定字符串对象。
/// </summary>
/// <param name="context"> </param>
/// <param name="input"> 需要转换类型的字符串对象 </param>
/// <param name="outputType"> 换转后的类型 </param>
/// <param name="success"> 是否成功 </param>
protected override Uri ChangeType(ConvertContext context, string input, Type outputType, out bool success)
{
if (input == null)
{
success = true;
return(null);
}
Uri result;
input = input.TrimStart();
if ((input.Length > 10) && (input[6] != '/'))
{
if (Uri.TryCreate("http://" + input, UriKind.Absolute, out result))
{
success = true;
return(result);
}
}
if (Uri.TryCreate(input, UriKind.Absolute, out result))
{
success = true;
return(result);
}
context.AddException(input + "不是一个有效的url");
success = false;
return(null);
}
/// <summary>
/// 返回指定类型的对象，其值等效于指定字符串对象。
/// </summary>
/// <param name="context"> </param>
/// <param name="input"> 需要转换类型的字符串对象 </param>
/// <param name="outputType"> 换转后的类型 </param>
/// <param name="success"> 是否成功 </param>
protected override IList ChangeType(ConvertContext context, string input, Type outputType, out bool success)
{
input = input?.Trim();
if ((input == null) || (input.Length <= 1))
{
success = false;
return(null);
}
if ((input[0] == '[') && (input[input.Length - 1] == ']'))
{
try
{
var result = ComponentServices.ToJsonObject(outputType, input);
success = true;
return((IList)result);
}
catch (Exception ex)
{
context.AddException(ex);
success = false;
return(null);
}
}
var arr = input.Split(_Separator, StringSplitOptions.None);
return(ChangeType(context, arr, outputType, out success));
}
public void ExecAutoConvertWithoutUndo(params Material[] mats)
{
foreach (var mat in mats)
{
if (mat == null)
{
continue;
}
if (!Validate(mat))
{
continue;
}
var ctx = new ConvertContext();
ctx.target = mat;
ctx.oldMaterial = new Material(mat);
ctx.oldProps = ShaderSerializedProperty.AsDict(ctx.oldMaterial);
foreach (var cnv in converters)
{
cnv(ctx);
}
Debug.LogFormat("[WF] Convert {0}: {1} -> {2}", ctx.target, ctx.oldMaterial.shader.name, ctx.target.shader.name);
}
}
public AddLayerArgument Convert(Add layer, ConvertContext context)
{
return(new AddLayerArgument
{
Count = (uint)(layer.Output.Dimensions.GetSize())
});
}
/// <summary>
/// 返回指定类型的对象，其值等效于指定对象。
/// </summary>
/// <param name="context"> </param>
/// <param name="input"> 需要转换类型的对象 </param>
/// <param name="outputType"> 换转后的类型 </param>
/// <param name="success"> 是否成功 </param>
/// <returns> </returns>
protected override ValueType ChangeTypeImpl(ConvertContext context, object input, Type outputType,
out bool success)
{
context.AddException("无法为值类型(struct)提供转换");
success = false;
return(null);
}
public SoftmaxLayerArgument Convert(Softmax layer, ConvertContext context)
{
return(new SoftmaxLayerArgument
{
Channels = (uint)layer.Input.Dimensions[1]
});
}
/// <summary>
/// 返回指定类型的对象，其值等效于指定字符串对象。
/// </summary>
/// <param name="context"> </param>
/// <param name="input"> 需要转换类型的字符串对象 </param>
/// <param name="outputType"> 换转后的类型 </param>
/// <param name="success"> 是否成功 </param>
protected override IDictionary <K, V> ChangeType(ConvertContext context, string input, Type outputType,
out bool success)
{
input = input?.Trim() ?? "";
if (input.Length == 0)
{
var keyConvertor = context.Get <K>();
var valueConvertor = context.Get <V>();
var builder = new DictionaryBuilder(context, outputType, keyConvertor, valueConvertor);
// ReSharper disable once AssignmentInConditionalExpression
return((success = builder.TryCreateInstance()) ? builder.Instance : null);
}
if (input?.Length > 2)
{
if ((input[0] == '{') && (input[input.Length - 1] == '}'))
{
try
{
var result = ComponentServices.ToJsonObject(outputType, input);
success = true;
return((IDictionary <K, V>)result);
}
catch (Exception ex)
{
context.AddException(ex);
}
}
}
success = false;
return(null);
}
/// <summary>
/// 返回指定类型的对象，其值等效于指定字符串对象。
/// </summary>
/// <param name="context"> </param>
/// <param name="input"> 需要转换类型的字符串对象 </param>
/// <param name="outputType"> 换转后的类型 </param>
/// <param name="success"> 是否成功 </param>
protected override IDictionary ChangeType(ConvertContext context, string input, Type outputType,
out bool success)
{
if (string.IsNullOrWhiteSpace(input))
{
success = false;
return(null);
}
input = input.Trim();
if ((input[0] == '{') && (input[input.Length - 1] == '}'))
{
try
{
var result = ComponentServices.ToJsonObject(outputType, input);
success = true;
return((IDictionary)result);
}
catch (Exception ex)
{
context.AddException(ex);
}
}
success = false;
return(null);
}
public LogisticLayerArgument Convert(Logistic layer, ConvertContext context)
{
return(new LogisticLayerArgument
{
Channels = (uint)layer.Input.Dimensions[1]
});
}
public K210AddPaddingLayerArgument Convert(K210AddPadding layer, ConvertContext context)
{
return(new K210AddPaddingLayerArgument
{
Channels = (uint)layer.Input.Dimensions[1]
});
}
/// <summary>
/// 返回指定类型的对象，其值等效于指定对象。
/// </summary>
/// <param name="context"> </param>
/// <param name="input"> 需要转换类型的对象 </param>
/// <param name="outputType"> 换转后的类型 </param>
/// <param name="success"> 是否成功 </param>
protected override UIntPtr ChangeTypeImpl(ConvertContext context, object input, Type outputType,
out bool success)
{
var num = context.Get <ulong>().ChangeType(context, input, typeof(ulong), out success);
return(success ? new UIntPtr(num) : default(UIntPtr));
}
/// <summary>
/// 返回指定类型的对象，其值等效于指定字符串对象。
/// </summary>
/// <param name="context"> </param>
/// <param name="input"> 需要转换类型的字符串对象 </param>
/// <param name="outputType"> 换转后的类型 </param>
/// <param name="success"> 是否成功 </param>
protected override ICollection <T> ChangeType(ConvertContext context, string input, Type outputType,
out bool success)
{
input = input.Trim();
if (input.Length == 0)
{
var builder = new ListBuilder(context, outputType);
// ReSharper disable once AssignmentInConditionalExpression
return((success = builder.TryCreateInstance()) ? builder.Instance : null);
}
if ((input[0] == '[') && (input[input.Length - 1] == ']'))
{
try
{
var result = ComponentServices.ToJsonObject(outputType, input);
success = true;
return((ICollection <T>)result);
}
catch (Exception ex)
{
context.AddException(ex);
success = false;
return(null);
}
}
var arr = input.Split(_Separator, StringSplitOptions.None);
return(ChangeType(context, arr, outputType, out success));
}
public L2NormalizationLayerArgument Convert(L2Normalization layer, ConvertContext context)
{
return(new L2NormalizationLayerArgument
{
Channels = (uint)layer.Input.Dimensions[1]
});
}
/// <summary>
/// 返回指定类型的对象，其值等效于指定字符串对象。
/// </summary>
/// <param name="context"> </param>
/// <param name="input"> 需要转换类型的字符串对象 </param>
/// <param name="outputType"> 换转后的类型 </param>
/// <param name="success"> 是否成功 </param>
protected override object ChangeType(ConvertContext context, string input, Type outputType, out bool success)
{
try
{
if (outputType == typeof(object))
{
success = true;
return(input);
}
var type = Type.GetType(input, false, true);
if (type == null)
{
success = false;
return(null);
}
if (outputType.IsAssignableFrom(type) == false)
{
success = false;
return(null);
}
success = true;
return(Activator.CreateInstance(type, true));
}
catch (Exception ex)
{
context.AddException(ex);
}
success = false;
return(null);
}
private static void ConvertToStringConstantStack(Type type, object value, ConvertContext context)
{
if (context.MemberAccessStack.Count > 0)
{
var memberProperty = context.MemberAccessStack.Pop();
switch (memberProperty.Member.MemberType)
{
case MemberTypes.Field:
{
var field = memberProperty.Member as FieldInfo;
object fieldValue = field.GetValue(value);
ConvertToStringConstantStack(field.FieldType, fieldValue, context);
break;
}
case MemberTypes.Property:
{
var property = memberProperty.Member as PropertyInfo;
object propertyValue = property.GetValue(value);
ConvertToStringConstantStack(property.PropertyType, propertyValue, context);
break;
}
default:
throw new NotImplementedException();
}
context.MemberAccessStack.Push(memberProperty);
}
else
{
ConvertToStringValue(type, value, context);
}
}
/// <summary>
/// 返回指定类型的对象，其值等效于指定对象。
/// </summary>
/// <param name="context"> </param>
/// <param name="input"> 需要转换类型的对象 </param>
/// <param name="outputType"> 换转后的类型 </param>
/// <param name="success"> 是否成功 </param>
/// <returns> </returns>
protected override object ChangeTypeImpl(ConvertContext context, object input, Type outputType, out bool success)
{
if ((input == null) || input is DBNull)
{
success = true;
return(null);
}
var builder = new ObjectBuilder(context, outputType);
if (builder.TryCreateInstance() == false)
{
return(ReturnIfObject(input, outputType, out success));
}
var mapper = new Mapper(input);
if (mapper.Error != null)
{
return(ReturnIfObject(input, outputType, out success));
}
while (mapper.MoveNext())
{
var name = mapper.Key as string;
if ((name != null) && (builder.Set(name, mapper.Value) == false))
{
return(ReturnIfObject(input, outputType, out success));
}
}
success = true;
return(builder.Instance);
}
private static void ConvertToStringParameter(Expression exp, ConvertContext context)
{
var parameterExpression = exp as ParameterExpression;
if (context.UseIt)
{
if (parameterExpression.Name == context.ItStack.Peek())
{
context.Builder.Append("it.");
}
else
{
int rank = 0;
foreach (var pstack in context.ItStack)
{
if (pstack == parameterExpression.Name)
{
break;
}
rank++;
}
context.Builder.Append("oIt").Append(rank).Append('.');
}
}
ConvertToStringParameterStack(context);
}
/// <summary>
/// 初始化构造器
/// </summary>
/// <param name="context"> 转换上下文 </param>
/// <param name="type"> 需要构造的实例类型 </param>
public ListBuilder(ConvertContext context, Type type)
{
_context = context;
_type = type;
_convertor = context.Get <T>();
Instance = null;
}
public QuantizedAddLayerArgument Convert(QuantizedAdd layer, ConvertContext context)
{
var inputARange = context.Quantization.Distributions[layer.InputA.Connection.From].Global;
var inputBRange = context.Quantization.Distributions[layer.InputB.Connection.From].Global;
var outputRange = context.Quantization.Distributions[layer.Output].Global;
(var sa, var ba) = inputARange.GetScaleBias(8);
(var sb, var bb) = inputBRange.GetScaleBias(8);
(var so, var bo) = outputRange.GetScaleBias(8);
(var mulA, var shiftA) = Quantizer.ExtractValueAndShift(sb, 32, 32);
(var mulB, var shiftB) = Quantizer.ExtractValueAndShift(sa, 32, 32);
(var mulO, var shiftO) = Quantizer.ExtractValueAndShift(so / (sa * sb), 32, 32);
return(new QuantizedAddLayerArgument
{
InputAOffset = (int)ba,
InputAMul = (int)Math.Round(mulA),
InputAShift = shiftA,
InputBOffset = (int)bb,
InputBMul = (int)Math.Round(mulB),
InputBShift = shiftB,
OutputOffset = (int)(-bo),
OutputMul = (int)Math.Round(mulO),
OutputShift = shiftO,
Count = (uint)(layer.Output.Dimensions.GetSize())
});
}
public QuantizedMaxPool2dLayerArgument Convert(QuantizedMaxPool2d layer, ConvertContext context)
{
var inputRange = context.Quantization.Distributions[layer.Input.Connection.From].Global;
var outputRange = context.Quantization.Distributions[layer.Output].Global;
(var sa, var ba) = inputRange.GetScaleBias(8);
(var so, var bo) = outputRange.GetScaleBias(8);
(var mulO, var shiftO) = Quantizer.ExtractValueAndShift(so / sa, 32, 32);
return(new QuantizedMaxPool2dLayerArgument
{
InputWidth = (uint)layer.Input.Dimensions[3],
InputHeight = (uint)layer.Input.Dimensions[2],
InputChannels = (uint)layer.Input.Dimensions[1],
OutputWidth = (uint)layer.Output.Dimensions[3],
OutputHeight = (uint)layer.Output.Dimensions[2],
OutputChannels = (uint)layer.Output.Dimensions[1],
KernelWidth = (uint)layer.FilterWidth,
KernelHeight = (uint)layer.FilterHeight,
StrideWidth = (uint)layer.StrideWidth,
StrideHeight = (uint)layer.StrideHeight,
PaddingWidth = (uint)Layer.GetPadding(layer.Input.Dimensions[3], layer.Output.Dimensions[3], layer.StrideWidth, 1, layer.FilterWidth),
PaddingHeight = (uint)Layer.GetPadding(layer.Input.Dimensions[2], layer.Output.Dimensions[2], layer.StrideHeight, 1, layer.FilterHeight)
});
}
public ConcatenationLayerArgument Convert(Concatenation layer, ConvertContext context)
{
return(new ConcatenationLayerArgument
{
InputCount = (uint)layer.Inputs.Count
});
}
/// <summary>
/// 执行转换
/// </summary>
/// <param name="context">转换上下文</param>
/// <returns></returns>
public override IEnumerable <KeyValuePair <string, string> > Invoke(ConvertContext context)
{
if (context.Descriptor.IsSimpleType == true)
{
return(new[] { this.ToKeyValuePair(context) });
}
return(this.Next.Invoke(context));
}
/// <summary>
/// 执行转换
/// </summary>
/// <param name="context">转换上下文</param>
/// <returns></returns>
public override IEnumerable <KeyValuePair <string, string> > Invoke(ConvertContext context)
{
// 无条件解析为属性
// 因为其它转换器都无法解析此类型
// 只拆解第一层属性则不用递归
return(from ctx in this.GetPropertiesContexts(context)
select ctx.ToKeyValuePair());
}
/// <summary>
/// 执行转换
/// </summary>
/// <param name="context">转换上下文</param>
/// <returns></returns>
public override IEnumerable <KeyValuePair <string, string> > Invoke(ConvertContext context)
{
if (this.IsSupported(context.Type) == true)
{
return(new[] { this.GetKeyValuePair(context) });
}
return(this.Next.Invoke(context));
}
public GlobalAveragePool2dLayerArgument Convert(GlobalAveragePool layer, ConvertContext context)
{
return(new GlobalAveragePool2dLayerArgument
{
KernelSize = (uint)(layer.Input.Dimensions[2] * layer.Input.Dimensions[3]),
Channels = (uint)(layer.Input.Dimensions[1])
});
}
/// <summary>
/// 执行转换
/// </summary>
/// <param name="context">转换上下文</param>
/// <returns></returns>
public override IEnumerable <KeyValuePair <string, string> > Invoke(ConvertContext context)
{
if (context.Data == null)
{
return(context.ToKeyValuePairs());
}
return(this.Next.Invoke(context));
}
public DequantizeLayerArgument Convert(Dequantize layer, ConvertContext context)
{
return(new DequantizeLayerArgument
{
Count = (uint)(layer.Input.Dimensions.GetSize()),
QuantParam = context.Quantization.Distributions[layer.Input.Connection.From].Global.GetQuantizationParam(8)
});
}
/// <summary>
/// 执行转换
/// </summary>
/// <param name="context">转换上下文</param>
/// <returns></returns>
public sealed override IEnumerable <KeyValuePair <string, string> > Invoke(ConvertContext context)
{
if (this.IsSupported(context.DataType) == true)
{
return(context.ToKeyValuePairs());
}
return(this.Next.Invoke(context));
}
/// <summary>
/// 执行转换
/// </summary>
/// <param name="context">转换上下文</param>
/// <returns></returns>
public override IEnumerable <KeyValuePair <string, string> > Invoke(ConvertContext context)
{
if (context.Value == null)
{
return(new[] { this.ToKeyValuePair(context) });
}
return(this.Next.Invoke(context));
}
public QuantizeLayerArgument Convert(layers.Quantize layer, ConvertContext context)
{
return(new QuantizeLayerArgument
{
Count = (uint)layer.Input.Dimensions.GetSize(),
QuantParam = context.Quantization.Distributions[layer.Output].Global.GetQuantizationParam(8)
});
}
