public MBeanAttributeInfo CreateMBeanAttributeInfo(PropertyInfo info)
{
Descriptor descriptor = new Descriptor();
OpenType openType = OpenType.CreateOpenType(info.PropertyType);
descriptor.SetField(OpenTypeDescriptor.Field, openType);
object[] tmp = info.GetCustomAttributes(typeof(OpenMBeanAttributeAttribute), false);
if (tmp.Length > 0)
{
OpenMBeanAttributeAttribute attr = (OpenMBeanAttributeAttribute)tmp[0];
if (attr.LegalValues != null && (attr.MinValue != null || attr.MaxValue != null))
{
throw new OpenDataException("Cannot specify both min/max values and legal values.");
}
IComparable defaultValue = (IComparable)attr.DefaultValue;
OpenInfoUtils.ValidateDefaultValue(openType, defaultValue);
descriptor.SetField(DefaultValueDescriptor.Field, defaultValue);
if (attr.LegalValues != null)
{
OpenInfoUtils.ValidateLegalValues(openType, attr.LegalValues);
descriptor.SetField(LegalValuesDescriptor.Field, attr.LegalValues);
}
else
{
OpenInfoUtils.ValidateMinMaxValue(openType, defaultValue, attr.MinValue, attr.MaxValue);
descriptor.SetField(MinValueDescriptor.Field, attr.MinValue);
descriptor.SetField(MaxValueDescriptor.Field, attr.MaxValue);
}
}
return new MBeanAttributeInfo(info.Name, InfoUtils.GetDescrition(info, info, "MBean attribute"), openType.Representation.AssemblyQualifiedName,
info.CanRead, info.CanWrite, descriptor);
}
/// <summary>
/// Creates new MBeanOperationInfo object.
/// </summary>
/// <param name="name">The name of the method.</param>
/// <param name="description">A human readable description of the operation.</param>
/// <param name="returnType">The type of the method's return value.</param>
/// <param name="signature">MBeanParameterInfo objects describing the parameters(arguments) of the method. It should be an empty list if operation has no parameters.</param>
/// <param name="impact">The impact of the method.</param>
/// <param name="descriptor">Initial descriptor values.</param>
public MBeanOperationInfo(string name, string description, string returnType, IEnumerable<MBeanParameterInfo> signature, OperationImpact impact, Descriptor descriptor)
: base(name, description, descriptor)
{
_returnType = returnType;
_signature = new List<MBeanParameterInfo>(signature).AsReadOnly();
_impact = impact;
}
public Device(Descriptor descriptor, int baudRate)
{
Descriptor = descriptor;
port = new SerialPort(
portName: descriptor.Port,
baudRate: baudRate,
parity: Parity.None,
dataBits: 8,
stopBits: StopBits.One);
port.ErrorReceived += (s, e) =>
{
throw new ApplicationException(string.Format(
"Serial error: {0}", e.EventType));
};
port.DtrEnable = false;
port.Open();
Thread.Sleep(50);
port.DtrEnable = true;
reader = new BinaryReader(port.BaseStream);
writer = new BinaryWriter(port.BaseStream);
port.ReadTimeout = 5000;
byte r;
do r = reader.ReadByte();
while (r != ready);
port.ReadTimeout = 500;
}
public void SetDescriptorDistance(Descriptor desc, double distance)
{
switch (desc)
{
case Descriptor.NONE:
break;
case Descriptor.CLD:
CLDDiff = distance;
break;
case Descriptor.DCD:
DCDDiff = distance;
break;
case Descriptor.EHD:
EHDDiff = distance;
break;
case Descriptor.SCD:
SCDDiff = distance;
break;
case Descriptor.CEDD:
CEDDDiff = distance;
break;
case Descriptor.FCTH:
FCTHDiff = distance;
break;
default:
break;
}
}
public TypeToolObject(BinaryPSDReader reader)
: base(reader)
{
BinaryPSDReader r = this.GetDataReader();
ushort Version = r.ReadUInt16(); //1= Photoshop 5.0
this.Transform = new Matrix2D(r);
ushort TextDescriptorVersion = r.ReadUInt16(); //=50. For Photoshop 6.0.
if (true)
this.TxtDescriptor = new DynVal(r, true);
else
{
uint XTextDescriptorVersion = r.ReadUInt32(); //=16. For Photoshop 6.0.
this.TextDescriptor = new Descriptor(r);
}
this.Data = r.ReadBytes((int)r.BytesToEnd);
////ushort WarpDescriptorVersion = r.ReadUInt16(); //=50. For Photoshop 6.0.
////uint XWarpDescriptorVersion = r.ReadUInt32(); //=16. For Photoshop 6.0.
////Descriptor warpDescriptor = new Descriptor(r);
//this.WarpDescriptor = new DynVal(r, true);
//this.WarpRect = ERectangleF.FromLTRB((float)r.ReadPSDDouble(), (float)r.ReadPSDDouble(), (float)r.ReadPSDDouble(), (float)r.ReadPSDDouble());
////this.WarpRect.Left = r.ReadPSDDouble();
////double warpRectTop = r.ReadPSDDouble();
////double warpRectRight = r.ReadPSDDouble();
////double warpRectBottom = r.ReadPSDDouble();
//this.Data = null;
}
/// <summary>Defaults.</summary>
/// <param name="d">The Descriptor to process.</param>
/// <param name="x">The Vector to process.</param>
/// <param name="y">The Vector to process.</param>
/// <param name="activation">The activation.</param>
/// <returns>A Network.</returns>
public static Network Default(Descriptor d, Matrix x, Vector y, IFunction activation)
{
var nn = new Network();
// set output to number of choices of available
// 1 if only two choices
var distinct = y.Distinct().Count();
var output = distinct > 2 ? distinct : 1;
// identity funciton for bias nodes
IFunction ident = new Ident();
// set number of hidden units to (Input + Hidden) * 2/3 as basic best guess.
var hidden = (int)Math.Ceiling((decimal)(x.Cols + output) * 2m / 3m);
// creating input nodes
nn.In = new Node[x.Cols + 1];
nn.In[0] = new Node { Label = "B0", Activation = ident };
for (var i = 1; i < x.Cols + 1; i++)
{
nn.In[i] = new Node { Label = d.ColumnAt(i - 1), Activation = ident };
}
// creating hidden nodes
var h = new Node[hidden + 1];
h[0] = new Node { Label = "B1", Activation = ident };
for (var i = 1; i < hidden + 1; i++)
{
h[i] = new Node { Label = string.Format("H{0}", i), Activation = activation };
}
// creating output nodes
nn.Out = new Node[output];
for (var i = 0; i < output; i++)
{
nn.Out[i] = new Node { Label = GetLabel(i, d), Activation = activation };
}
// link input to hidden. Note: there are
// no inputs to the hidden bias node
for (var i = 1; i < h.Length; i++)
{
for (var j = 0; j < nn.In.Length; j++)
{
Edge.Create(nn.In[j], h[i]);
}
}
// link from hidden to output (full)
for (var i = 0; i < nn.Out.Length; i++)
{
for (var j = 0; j < h.Length; j++)
{
Edge.Create(h[j], nn.Out[i]);
}
}
return nn;
}
/// <summary>Gets a label.</summary>
/// <param name="n">The Node to process.</param>
/// <param name="d">The Descriptor to process.</param>
/// <returns>The label.</returns>
private static string GetLabel(int n, Descriptor d)
{
if (d.Label.Type.IsEnum)
return Enum.GetName(d.Label.Type, n);
else if (d.Label is StringProperty && ((StringProperty)d.Label).AsEnum)
return ((StringProperty)d.Label).Dictionary[n];
else return d.Label.Name;
}
private void SetFieldValuesFromDescriptor(Descriptor descriptor)
{
Field = new List<FeatureDescriptorTypeField>();
foreach (string fieldName in descriptor.GetFieldNames())
{
Field.Add(new FeatureDescriptorTypeField(fieldName, descriptor.GetFieldValue(fieldName)));
}
}
public void NotifyCompleted(Descriptor descriptor)
{
running.Remove(descriptor);
if (running.Count == 0)
{
if (AllCompleted != null) AllCompleted(this, new EventArgs());
}
}
/// <summary>Constructor.</summary>
/// <param name="descriptor">the descriptor.</param>
public DecisionTreeGenerator(Descriptor descriptor)
{
Depth = 5;
Width = 2;
Descriptor = descriptor;
ImpurityType = typeof(Entropy);
Hint = double.Epsilon;
}
public static bool IsParentNode(Descriptor descriptor)
{
bool result = false;
if (descriptor.DescriptorType.DescriptorTypeName == "To")
{
result = true;
}
return result;
}
/// <summary>Generates.</summary>
/// <param name="desc">The description.</param>
/// <param name="examples">The examples.</param>
/// <param name="linker">The linker.</param>
/// <returns>A Cluster.</returns>
public Cluster Generate(Descriptor desc, IEnumerable<object> examples, ILinker linker)
{
// Load data
var exampleArray = examples.ToArray();
Descriptor = desc;
Matrix X = Descriptor.Convert(examples).ToMatrix();
return GenerateClustering(X, linker, exampleArray);
}
/// <summary>
/// Constructs an <see cref="NetMX.MBeanInfo"/>.
/// </summary>
/// <param name="className">Name of the MBean described by this MBeanInfo.</param>
/// <param name="description">Human readable description of the MBean. </param>
/// <param name="attributes">List of MBean attributes. It should be an empty list if MBean contains no attributes.</param>
/// <param name="constructors">List of MBean constructors. It should be an empty list if MBean contains no constructors.</param>
/// <param name="operations">List of MBean operations. It should be an empty list if MBean contains no operations.</param>
/// <param name="notifications">List of MBean notifications. It should be an empty list if MBean contains no notifications.</param>
/// <param name="descriptor">Initial descriptor values.</param>
public MBeanInfo(string className, string description, IEnumerable<MBeanAttributeInfo> attributes, IEnumerable<MBeanConstructorInfo> constructors, IEnumerable<MBeanOperationInfo> operations, IEnumerable<MBeanNotificationInfo> notifications, Descriptor descriptor)
{
_className = className;
_description = description;
_attributes = new List<MBeanAttributeInfo>(attributes).AsReadOnly();
_constructors = new List<MBeanConstructorInfo>(constructors).AsReadOnly();
_operations = new List<MBeanOperationInfo>(operations).AsReadOnly();
_notifications = new List<MBeanNotificationInfo>(notifications).AsReadOnly();
_descriptor = descriptor;
}
public void ReadFrom_FromAStreamWithNonHexadecimalCharacters_ThrowsException()
{
var descriptorBytes = Encoding.ASCII.GetBytes("zz\0e82fe33199f25c242213ada825358e91c4261753\0b\03\0foo\0");
var expected = new Descriptor("e82fe33199f25c242213ada825358e91c4261753", DescriptorType.File, "foo");
using (var stream = new MemoryStream(descriptorBytes))
{
Assert.That(() => Descriptor.ReadFrom(stream), Throws.InstanceOf<InvalidOperationException>());
}
}
public Cluster Generate(Descriptor descriptor, IEnumerable<object> examples, int k, IDistance metric = null)
{
var data = examples.ToArray();
Descriptor = descriptor;
Matrix X = Descriptor.Convert(examples).ToMatrix();
var assignments = Generate(X, k, metric);
return GenerateClustering(X, assignments, data);
}
/// <summary>
/// Returns a Vector of positive and negative labels in 1 - 0 form.
/// </summary>
/// <param name="examples">Object examples.</param>
/// <param name="descriptor">Descriptor.</param>
/// <param name="truthLabel">The truth label's value (see <see cref="LabelAttribute"/>).</param>
/// <returns></returns>
public static Vector ChangeClassLabels(object[] examples, Descriptor descriptor, object truthLabel)
{
Vector y = new Vector(examples.Length);
for (int i = 0; i < y.Length; i++)
{
y[i] = (descriptor.GetValue(examples.ElementAt(i), descriptor.Label).Equals(truthLabel) ? 1.0 : 0.0);
}
return y;
}
public Device(ref Descriptor desc, FeatureLevel featureLevel = FeatureLevel.Level_12_0)
: base(ref desc)
{
if (desc.DebugDevice)
{
var debugInterface = SharpDX.Direct3D12.DebugInterface.Get();
if (debugInterface != null)
{
debugInterface.EnableDebugLayer();
}
else
{
Log.Error("Failed to obtain DX12 debug layer.");
}
}
// Use first adapter that is supported.
using (SharpDX.DXGI.Factory dxgiFactory = new Factory4())
{
for (int adapterIndex = 0;; ++adapterIndex)
{
var adapter = dxgiFactory.GetAdapter(adapterIndex);
if (adapter == null)
{
// TODO: Throw exception
return;
}
try
{
DeviceD3D12 = new SharpDX.Direct3D12.Device(adapter, (SharpDX.Direct3D.FeatureLevel) featureLevel);
Adapter = adapter;
break;
}
catch (Exception)
{
DeviceD3D12 = null;
adapter.Dispose();
}
}
}
// Get Resource handle increment sizes.
descriptorHandleIncrementSize[(int)DescriptorHeap.Descriptor.ResourceDescriptorType.Sampler] = DeviceD3D12.GetDescriptorHandleIncrementSize(DescriptorHeapType.Sampler);
descriptorHandleIncrementSize[(int)DescriptorHeap.Descriptor.ResourceDescriptorType.DepthStencil] = DeviceD3D12.GetDescriptorHandleIncrementSize(DescriptorHeapType.DepthStencilView);
descriptorHandleIncrementSize[(int)DescriptorHeap.Descriptor.ResourceDescriptorType.RenderTarget] = DeviceD3D12.GetDescriptorHandleIncrementSize(DescriptorHeapType.RenderTargetView);
descriptorHandleIncrementSize[(int)DescriptorHeap.Descriptor.ResourceDescriptorType.ShaderResource] = DeviceD3D12.GetDescriptorHandleIncrementSize(DescriptorHeapType.ConstantBufferViewShaderResourceViewUnorderedAccessView);
Memory.Enums.InitLookupTables();
Log.Info("Successfully created a DX12 device with adapter \"{0}\"", Adapter.Description.Description);
}
protected Descriptor GetDescriptorFromFieldValues()
{
Descriptor descriptor = new Descriptor();
if (Field != null)
{
foreach (FeatureDescriptorTypeField field in Field)
{
descriptor.SetField(field.Name, field.Value.Deserialize());
}
}
return descriptor;
}
public void AddItem(string item, string name, IProgressBar progress)
{
if (Running) throw new Exception("Resource Downloader was already started.");
string resourceUrl = UrlResourceName(category, item, name);
Downloader downloader = new Downloader();
downloader.Open("GET", new Uri(resourceUrl, UriKind.RelativeOrAbsolute));
Descriptor descriptor = new Descriptor(this, downloader, progress);
descriptors.Add(resourceUrl, descriptor);
}
public void ReadFrom_FromAStreamWithAValidFolderDescriptor_ReturnsTheDescriptor()
{
var descriptorBytes = Encoding.ASCII.GetBytes("28\0e82fe33199f25c242213ada825358e91c4261753\0t\03\0foo\0");
var expected = new Descriptor("e82fe33199f25c242213ada825358e91c4261753", DescriptorType.Folder, "foo");
using (var stream = new MemoryStream(descriptorBytes))
{
var descriptor = Descriptor.ReadFrom(stream);
Assert.That(descriptor, Is.EqualTo(expected));
}
}
/// <summary>Constructor.</summary>
/// <exception cref="InvalidOperationException">Thrown when the requested operation is invalid.</exception>
/// <param name="depth">(Optional) The depth.</param>
/// <param name="width">(Optional) the width.</param>
/// <param name="descriptor">(Optional) the descriptor.</param>
/// <param name="impurityType">(Optional) type of the impurity.</param>
/// <param name="hint">(Optional) the hint.</param>
public DecisionTreeGenerator(
int depth = 5,
int width = 2,
Descriptor descriptor = null,
Type impurityType = null,
double hint = double.Epsilon)
{
if (width < 2)
throw new InvalidOperationException("Cannot set dt tree width to less than 2!");
Descriptor = descriptor;
Depth = depth;
Width = width;
ImpurityType = impurityType ?? typeof(Entropy);
Hint = hint;
}
public static Guid GetMapId(Node node, Descriptor descriptor)
{
Node altNode = ConditionHelper.GetAlternateNode(descriptor);
bool isNodeParent = ConditionHelper.IsParentNode(descriptor);
Guid mapId = Guid.Empty;
if (!isNodeParent)
{
mapId = altNode.NodeUid;
}
else
{
mapId = node.NodeUid;
}
return mapId;
}
private Descriptor Generate()
{
Descriptor d = new Descriptor();
d.Features = new Property[]
{
new Property { Name = "Age" },
new Property { Name = "Height" },
new DateTimeProperty(DateTimeFeature.DayOfWeek | DateTimeFeature.Month) { Name = "BirthDate" },
new Property { Name = "Weight" },
new Property { Name = "Good" },
};
return d;
}
private IEnumerable<Descriptor> ReadDescriptors(IBitStream bitstream)
{
while (!bitstream.ChunkFinished) {
var desc = bitstream.ReadProtobufVarInt();
var wireType = desc & 7;
var fieldnum = desc >> 3;
if ((wireType != 2) || (fieldnum != 1))
throw new InvalidDataException();
var length = bitstream.ReadProtobufVarInt();
bitstream.BeginChunk(length * 8);
var descriptor = new Descriptor();
descriptor.Parse(bitstream);
yield return descriptor;
bitstream.EndChunk();
}
}
public bool Evaluate(Node node, Relationship relationship, Descriptor descriptor)
{
Guid searchId = Guid.Empty;
bool? evaluation = new bool?();
switch (Context)
{
case ConditionContext.Node:
searchId = node.NodeUid;
break;
case ConditionContext.Relationship:
searchId = relationship.RelationshipUid;
break;
case ConditionContext.Descriptor:
searchId = descriptor.DescriptorUid;
break;
case ConditionContext.NodeType:
searchId = node.NodeTypeUid.Value;
break;
case ConditionContext.RelationshipType:
searchId = relationship.RelationshipTypeUid.Value;
break;
case ConditionContext.DescriptorType:
searchId = descriptor.DescriptorTypeUid.Value;
break;
default:
break;
}
switch (Operator)
{
case ComparisonOperators.Equal:
evaluation = SearchValue == searchId;
break;
case ComparisonOperators.NotEqual:
evaluation = SearchValue != searchId;
break;
default:
evaluation = false;
break;
}
return evaluation.Value;
}
/// <summary>
/// Constructs an MBeanAttributeInfo object.
/// </summary>
/// <param name="name">The name of the attribute.</param>
/// <param name="description">The type or class name of the attribute.</param>
/// <param name="type">A human readable description of the attribute.</param>
/// <param name="isReadable">True if the attribute has a getter method, false otherwise.</param>
/// <param name="isWritable">True if the attribute has a setter method, false otherwise.</param>
/// <param name="descriptor">Initial descriptor values.</param>
public MBeanAttributeInfo(string name, string description, string type, bool isReadable, bool isWritable, Descriptor descriptor)
: base(name, description, descriptor)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
if (description == null)
{
throw new ArgumentNullException("description");
}
if (type == null)
{
throw new ArgumentNullException("type");
}
_type = type;
_isReadable = isReadable;
_isWritable = isWritable;
}
public static Descriptor GetAlternateDescriptor(Descriptor descriptor)
{
Descriptor result = null;
if (descriptor.Relationship != null && descriptor.Relationship.Descriptors != null)
{
foreach (Descriptor desc in descriptor.Relationship.Descriptors)
{
if (desc.DescriptorUid == descriptor.DescriptorUid)
{
continue;
}
else
{
result = desc;
}
}
}
return result;
}
public void Descriptor_Dictionary_Serialization_Test()
{
Descriptor d = new Descriptor();
var dictionary = StringHelpers.BuildWordDictionary(WordStrings)
.Select(k => k.Key)
.ToArray();
d.Features = new Property[]
{
new Property { Name = "Age", Type = typeof(int) },
new Property { Name = "Height", Type = typeof(decimal) },
new StringProperty { Name = "Words", Dictionary = dictionary },
new Property { Name = "Weight", Type = typeof(double) },
new Property { Name = "Good", Type = typeof(bool) },
};
Serialize(d);
}
/// <summary>Defaults.</summary>
/// <param name="d">The Descriptor to process.</param>
/// <param name="x">The Vector to process.</param>
/// <param name="y">The Vector to process.</param>
/// <param name="activationFunction">The activation.</param>
/// <param name="outputFunction">The ouput function for hidden nodes (Optional).</param>
/// <param name="epsilon">epsilon</param>
/// <returns>A Network.</returns>
public static Network Create(this Network network, Descriptor d, Matrix x, Vector y, IFunction activationFunction, IFunction outputFunction = null, double epsilon = double.NaN)
{
// set output to number of choices of available
// 1 if only two choices
int distinct = y.Distinct().Count();
int output = distinct > 2 ? distinct : 1;
// identity funciton for bias nodes
IFunction ident = new Ident();
// set number of hidden units to (Input + Hidden) * 2/3 as basic best guess.
int hidden = (int)System.Math.Ceiling((double)(x.Cols + output) * 2.0 / 3.0);
return network.Create(x.Cols, output, activationFunction, outputFunction,
fnNodeInitializer: new Func<int, int, Neuron>((l, i) =>
{
if (l == 0) return new Neuron(false) { Label = d.ColumnAt(i - 1), ActivationFunction = activationFunction, NodeId = i, LayerId = l };
else if (l == 2) return new Neuron(false) { Label = Network.GetLabel(i, d), ActivationFunction = activationFunction, NodeId = i, LayerId = l };
else return new Neuron(false) { ActivationFunction = activationFunction, NodeId = i, LayerId = l };
}), hiddenLayers: hidden);
}
public MBeanOperationInfo CreateMBeanOperationInfo(MethodInfo info)
{
Descriptor descriptor = new Descriptor();
object[] attrTmp = info.GetCustomAttributes(typeof(OpenMBeanOperationAttribute), false);
if (attrTmp.Length == 0)
{
throw new OpenDataException("Open MBean operation have to have its impact specified.");
}
OpenMBeanOperationAttribute attr = (OpenMBeanOperationAttribute)attrTmp[0];
if (attr.Impact == OperationImpact.Unknown)
{
throw new OpenDataException("Open MBean operation have to have its impact specified.");
}
OpenType openType = info.ReturnType != null ? OpenType.CreateOpenType(info.ReturnType) : SimpleType.Void;
descriptor.SetField(OpenTypeDescriptor.Field, openType);
return new MBeanOperationInfo(info.Name, InfoUtils.GetDescrition(info, info, "MBean operation"),
openType.Representation.AssemblyQualifiedName,
info.GetParameters().Select(x => CreateMBeanParameterInfo(x)), attr.Impact,
descriptor);
}
/// <summary>Builds a tree.</summary>
/// <param name="x">The Matrix to process.</param>
/// <param name="y">The Vector to process.</param>
/// <param name="depth">The depth.</param>
/// <param name="used">The used.</param>
/// <returns>A Node.</returns>
private Node BuildTree(Matrix x, Vector y, int depth, List <int> used, Tree tree)
{
if (depth < 0)
{
return(BuildLeafNode(y.Mode()));
}
var tuple = GetBestSplit(x, y, used);
var col = tuple.Item1;
var gain = tuple.Item2;
var measure = tuple.Item3;
// uh oh, need to return something?
// a weird node of some sort...
// but just in case...
if (col == -1)
{
return(BuildLeafNode(y.Mode()));
}
used.Add(col);
Node node = new Node
{
Column = col,
Gain = gain,
IsLeaf = false,
Name = Descriptor.ColumnAt(col)
};
// populate edges
List <Edge> edges = new List <Edge>(measure.Segments.Length);
for (int i = 0; i < measure.Segments.Length; i++)
{
// working set
var segment = measure.Segments[i];
var edge = new Edge()
{
ParentId = node.Id,
Discrete = measure.Discrete,
Min = segment.Min,
Max = segment.Max
};
IEnumerable <int> slice;
if (edge.Discrete)
{
// get discrete label
edge.Label = Descriptor.At(col).Convert(segment.Min).ToString();
// do value check for matrix slicing
slice = x.Indices(v => v[col] == segment.Min);
}
else
{
// get range label
edge.Label = string.Format("{0} <= x < {1}", segment.Min, segment.Max);
// do range check for matrix slicing
slice = x.Indices(v => v[col] >= segment.Min && v[col] < segment.Max);
}
// something to look at?
// if this number is 0 then this edge
// leads to a dead end - the edge will
// not be built
if (slice.Any())
{
Vector ySlice = y.Slice(slice);
// only one answer, set leaf
if (ySlice.Distinct().Count() == 1)
{
var child = BuildLeafNode(ySlice[0]);
tree.AddVertex(child);
edge.ChildId = child.Id;
}
// otherwise continue to build tree
else
{
var child = BuildTree(x.Slice(slice), ySlice, depth - 1, used, tree);
tree.AddVertex(child);
edge.ChildId = child.Id;
}
edges.Add(edge);
}
}
// problem, need to convert
// parent to terminal node
// with mode
if (edges.Count <= 1)
{
var val = y.Mode();
node.IsLeaf = true;
node.Value = val;
}
tree.AddVertex(node);
if (edges.Count > 1)
{
foreach (var e in edges)
{
tree.AddEdge(e);
}
}
return(node);
}
public IDocumentDescriptor GetDocument(string filename)
{
return(Descriptor.Document(this.intellisenseSession.GetDocumentAsByteArray(filename)));
}
private static BuildingRequestEventArgs SetupTest(string method, Uri uri, HeaderCollection headers, Descriptor descriptor)
{
return(new BuildingRequestEventArgs(method, uri, headers, descriptor, HttpStack.Auto));
}
public SimpleFSIndexInput(System.IO.FileInfo path, int bufferSize, int chunkSize)
: base(bufferSize)
{
file = new Descriptor(path, System.IO.FileAccess.Read);
this.chunkSize = chunkSize;
}
protected DescribedMap(Descriptor descriptor)
: base(descriptor)
{
}
public override string GetMessage(IFormatProvider formatProvider)
{
var format = Descriptor.GetMessageFormat();
return(string.Format(formatProvider, format, Args));
}
protected Fence(ref Descriptor desc, Device device, string label) : base(ref desc, device, label)
{
Create();
}
public HidDeviceWrap Initialize()
{
Error = null;
Opened = false;
_ready = false;
DevicePath = Device.DevicePath;
Change();
Task.Run(() =>
{
Opening = true;
try
{
//Stream = Device.Open();
Descriptor = Device.GetReportDescriptor();
MaxInputReportLength = Device.GetMaxInputReportLength();
InputReportCount = 0;
InputReportOffsets.Clear();
foreach (var report in Descriptor.InputReports)
{
InputReportOffsets.Add(report.ReportID, InputReportCount * MaxInputReportLength);
InputReportCount++;
}
InputLength = MaxInputReportLength * InputReportCount;
OutputLength = Device.GetMaxOutputReportLength();
_inputBytes = new byte[InputLength];
_rawInputBytes = new byte[MaxInputReportLength];
_outputBytes = new byte[OutputLength];
Receiver = Descriptor.CreateHidDeviceInputReceiver();
var options = new OpenConfiguration();
options.SetOption(OpenOption.Exclusive, false);
options.SetOption(OpenOption.Transient, false);
options.SetOption(OpenOption.Interruptible, false);
options.SetOption(OpenOption.Priority, OpenPriority.High);
Stream = Device.Open(options);
Receiver.Start(Stream);
Receiver.Received += (sender, args) =>
{
Opened = true;
_ready = true;
Change();
};
Opened = true;
}
catch (Exception e)
{
Opened = false;
Error = e;
}
Opening = false;
Change();
_ready = Opened;
});
return(this);
}
public string ToString(CultureInfo culture)
{
return(Descriptor.Translate(ToString(), CultureInfo.InvariantCulture, culture));
}
public void descirptor_is_read()
{
Descriptor.ShouldNotBeNull();
}
/// <summary>Defaults.</summary>
/// <param name="d">The Descriptor to process.</param>
/// <param name="x">The Vector to process.</param>
/// <param name="y">The Vector to process.</param>
/// <param name="activation">The activation.</param>
/// <returns>A Network.</returns>
public static Network Default(Descriptor d, Matrix x, Vector y, IFunction activation)
{
Network nn = new Network();
// set output to number of choices of available
// 1 if only two choices
int distinct = y.Distinct().Count();
int output = distinct > 2 ? distinct : 1;
// identity funciton for bias nodes
IFunction ident = new Ident();
// set number of hidden units to (Input + Hidden) * 2/3 as basic best guess.
int hidden = (int)System.Math.Ceiling((decimal)(x.Cols + output) * 2m / 3m);
// creating input nodes
nn.In = new Node[x.Cols + 1];
nn.In[0] = new Node {
Label = "B0", Activation = ident
};
for (int i = 1; i < x.Cols + 1; i++)
{
nn.In[i] = new Node {
Label = d.ColumnAt(i - 1), Activation = ident
}
}
;
// creating hidden nodes
Node[] h = new Node[hidden + 1];
h[0] = new Node {
Label = "B1", Activation = ident
};
for (int i = 1; i < hidden + 1; i++)
{
h[i] = new Node {
Label = String.Format("H{0}", i), Activation = activation
}
}
;
// creating output nodes
nn.Out = new Node[output];
for (int i = 0; i < output; i++)
{
nn.Out[i] = new Node {
Label = GetLabel(i, d), Activation = activation
}
}
;
// link input to hidden. Note: there are
// no inputs to the hidden bias node
for (int i = 1; i < h.Length; i++)
{
for (int j = 0; j < nn.In.Length; j++)
{
Edge.Create(nn.In[j], h[i]);
}
}
// link from hidden to output (full)
for (int i = 0; i < nn.Out.Length; i++)
{
for (int j = 0; j < h.Length; j++)
{
Edge.Create(h[j], nn.Out[i]);
}
}
return(nn);
}
/// <summary>
/// Gets the descriptor for this data source.
/// </summary>
/// <param name="alias">
/// The alias.
/// </param>
/// <param name="context">
/// The execution context.
/// </param>
/// <param name="reader">
/// The reader.
/// </param>
/// <returns>
/// The <see cref="System.Threading.Tasks.Task" />.
/// </returns>
public Task <IDataSourceDescriptor> GetDataSourceDescriptorAsync(string alias, [NotNull] IFileFormatExecutionContext context, StreamReader reader)
{
var separator = context.GetDefault("SEPARATOR", false) as string ?? ",";
return(Task.FromResult(Descriptor.ForDataSource(alias, CsvFileFormat.GetHeaders(CsvFileFormat.GetSplitter(separator), reader, separator).Where(header => header.Length > 0).Select(column => Descriptor.ForColumn(column, typeof(string))))));
}
protected override List <string> getCurrentScriptNames()
{
return(Descriptor.getScriptNamesClone());
}
public void ProcessVerticesWithWeights(Mesh mesh, VertexData vertData, Dictionary <string, int> boneNames, EVP1 envelopes, DRW1 partialWeight, bool doStrip = true)
{
Weight[] weights = new Weight[mesh.Vertices.Count];
for (int i = 0; i < mesh.Vertices.Count; i++)
{
int vertexid = i;
Weight vertWeight = new Weight();
foreach (Assimp.Bone bone in mesh.Bones)
{
foreach (VertexWeight weight in bone.VertexWeights)
{
if (weight.VertexID == vertexid)
{
vertWeight.AddWeight(weight.Weight, boneNames[bone.Name]);
}
}
}
vertWeight.reorderBones();
weights[vertexid] = vertWeight;
}
//Primitive prim = new Primitive(Enums.GXPrimitiveType.Triangles);
List <Enums.GXVertexAttribute> activeAttribs = Descriptor.GetActiveAttributes();
AttributeData.SetAttributesFromList(activeAttribs);
uint[] triindices = MakeTriIndexList(mesh);
List <PrimitiveBrawl> primlist;
if (doStrip)
{
//Console.WriteLine("Calculating triangle strips for Weighted");
TriStripper stripper = new TriStripper(triindices, weights);
primlist = stripper.Strip();
}
else
{
//Console.WriteLine("Calculating triangle list for Weighted");
primlist = new List <PrimitiveBrawl>();
PrimitiveBrawl prim = new PrimitiveBrawl(PrimType.TriangleList); // Trilist
foreach (uint index in triindices)
{
prim.Indices.Add(index);
}
primlist.Add(prim);
}
//Console.WriteLine(String.Format("Done, {0} primitives", primlist.Count));
Packet pack = new Packet();
List <Weight> packetWeights = new List <Weight>();
int numMatrices = 0;
foreach (PrimitiveBrawl primbrawl in primlist)
{
int numNewMatricesForFirstThreeVerts = 0;
if (!packetWeights.Contains(weights[primbrawl.Indices[0]]))
{
numNewMatricesForFirstThreeVerts++;
}
if (!packetWeights.Contains(weights[primbrawl.Indices[1]]))
{
numNewMatricesForFirstThreeVerts++;
}
if (!packetWeights.Contains(weights[primbrawl.Indices[2]]))
{
numNewMatricesForFirstThreeVerts++;
}
if (numMatrices + numNewMatricesForFirstThreeVerts > MaxMatricesPerPacket)
{
// We won't be able to fit even the first 3 vertices of this primitive without going over the matrix limit.
// So we need to start a new packet.
packetWeights.Clear();
numMatrices = 0;
Packets.Add(pack);
pack = new Packet();
}
Primitive prim = new Primitive((Enums.GXPrimitiveType)primbrawl.Type);
int currvert = -1;
int maxvert = primbrawl.Indices.Count - 1;
Enums.GXPrimitiveType primtype = (Enums.GXPrimitiveType)primbrawl.Type;
if (primtype == Enums.GXPrimitiveType.TriangleStrip)
{
//Console.WriteLine("Doing Tristrip");
foreach (int vertIndex in primbrawl.Indices)
{
currvert++;
Weight vertWeight = weights[vertIndex];
int oldmat = numMatrices;
if (!packetWeights.Contains(vertWeight))
{
packetWeights.Add(vertWeight);
numMatrices++;
}
//Console.WriteLine(String.Format("Added {0} matrices, is now {1}", numMatrices - oldmat, numMatrices));
// There are too many matrices, we need to create a new packet
if (numMatrices > MaxMatricesPerPacket)
{
// If we break up and the resulting TriStrip becomes invalid,
// then we need to handle those cases.
//Console.WriteLine(String.Format("Breaking up because over the limit: {0}", numMatrices));
if (prim.PrimitiveType == Enums.GXPrimitiveType.TriangleStrip)
{
Debug.Assert(prim.Vertices.Count >= 3);
}
else if (prim.PrimitiveType == Enums.GXPrimitiveType.Triangles)
{
Debug.Assert(prim.Vertices.Count % 3 == 0);
}
pack.Primitives.Add(prim);
Primitive newprim = new Primitive(Enums.GXPrimitiveType.TriangleStrip);
Vertex prev3 = new Vertex(prim.Vertices[prim.Vertices.Count - 3]);
Vertex prev2 = new Vertex(prim.Vertices[prim.Vertices.Count - 2]);
Vertex prev = new Vertex(prim.Vertices[prim.Vertices.Count - 1]);
bool isOdd = currvert % 2 != 0;
if (isOdd)
{
// Need to preserve whether each vertex is even or odd inside the triangle strip.
// Do this by adding an extra vertex from the previous packet to the start of this one.
newprim.Vertices.Add(prev3);
}
newprim.Vertices.Add(prev2);
newprim.Vertices.Add(prev);
prim = newprim;
packetWeights.Clear();
numMatrices = 0;
Packets.Add(pack);
Packet oldPack = pack;
pack = new Packet();
// Calculate matrices for current packet in case we added vertices
foreach (Vertex vertex in prim.Vertices)
{
if (!packetWeights.Contains(vertex.VertexWeight))
{
packetWeights.Add(vertex.VertexWeight);
numMatrices++;
}
// Re-add the matrix index for the duplicated verts to the new packet.
// And recalculate the matrix index index in each vert's attribute data.
uint oldMatrixIndexIndex = vertex.GetAttributeIndex(Enums.GXVertexAttribute.PositionMatrixIdx);
int matrixIndex = oldPack.MatrixIndices[(int)oldMatrixIndexIndex];
if (!pack.MatrixIndices.Contains(matrixIndex))
{
pack.MatrixIndices.Add(matrixIndex);
}
vertex.SetAttributeIndex(Enums.GXVertexAttribute.PositionMatrixIdx, (uint)pack.MatrixIndices.IndexOf(matrixIndex));
}
if (!packetWeights.Contains(vertWeight))
{
packetWeights.Add(vertWeight);
numMatrices++;
}
}
Vertex vert = new Vertex();
Weight curWeight = vertWeight;
vert.SetWeight(curWeight);
foreach (Enums.GXVertexAttribute attrib in activeAttribs)
{
switch (attrib)
{
case Enums.GXVertexAttribute.PositionMatrixIdx:
int newMatrixIndex = -1;
if (curWeight.WeightCount == 1)
{
newMatrixIndex = partialWeight.MeshWeights.IndexOf(curWeight);
}
else
{
if (!envelopes.Weights.Contains(curWeight))
{
envelopes.Weights.Add(curWeight);
}
int envIndex = envelopes.Weights.IndexOf(curWeight);
int drwIndex = partialWeight.MeshWeights.IndexOf(curWeight);
if (drwIndex == -1)
{
throw new System.Exception($"Model has unweighted vertices in mesh \"{mesh.Name}\". Please weight all vertices to at least one bone.");
}
newMatrixIndex = drwIndex;
partialWeight.Indices[drwIndex] = envIndex;
}
if (!pack.MatrixIndices.Contains(newMatrixIndex))
{
pack.MatrixIndices.Add(newMatrixIndex);
}
vert.SetAttributeIndex(Enums.GXVertexAttribute.PositionMatrixIdx, (uint)pack.MatrixIndices.IndexOf(newMatrixIndex));
break;
case Enums.GXVertexAttribute.Position:
List <Vector3> posData = (List <Vector3>)vertData.GetAttributeData(Enums.GXVertexAttribute.Position);
Vector3 vertPos = mesh.Vertices[vertIndex].ToOpenTKVector3();
if (curWeight.WeightCount == 1)
{
Matrix4 ibm = envelopes.InverseBindMatrices[curWeight.BoneIndices[0]];
Vector3 transVec = Vector3.TransformPosition(vertPos, ibm);
if (!posData.Contains(transVec))
{
posData.Add(transVec);
}
AttributeData.Positions.Add(transVec);
vert.SetAttributeIndex(Enums.GXVertexAttribute.Position, (uint)posData.IndexOf(transVec));
}
else
{
if (!posData.Contains(vertPos))
{
posData.Add(vertPos);
}
AttributeData.Positions.Add(vertPos);
vert.SetAttributeIndex(Enums.GXVertexAttribute.Position, (uint)posData.IndexOf(vertPos));
}
break;
case Enums.GXVertexAttribute.Normal:
List <Vector3> normData = (List <Vector3>)vertData.GetAttributeData(Enums.GXVertexAttribute.Normal);
Vector3 vertNrm = mesh.Normals[vertIndex].ToOpenTKVector3();
if (curWeight.WeightCount == 1)
{
Matrix4 ibm = envelopes.InverseBindMatrices[curWeight.BoneIndices[0]];
vertNrm = Vector3.TransformNormal(vertNrm, ibm);
if (!normData.Contains(vertNrm))
{
normData.Add(vertNrm);
}
}
else
{
if (!normData.Contains(vertNrm))
{
normData.Add(vertNrm);
}
}
AttributeData.Normals.Add(vertNrm);
vert.SetAttributeIndex(Enums.GXVertexAttribute.Normal, (uint)normData.IndexOf(vertNrm));
break;
case Enums.GXVertexAttribute.Color0:
case Enums.GXVertexAttribute.Color1:
int colNo = (int)attrib - 11;
List <Color> colData = (List <Color>)vertData.GetAttributeData(Enums.GXVertexAttribute.Color0 + colNo);
Color vertCol = mesh.VertexColorChannels[colNo][vertIndex].ToSuperBMDColorRGBA();
if (colNo == 0)
{
AttributeData.Color_0.Add(vertCol);
}
else
{
AttributeData.Color_1.Add(vertCol);
}
vert.SetAttributeIndex(Enums.GXVertexAttribute.Color0 + colNo, (uint)colData.IndexOf(vertCol));
break;
case Enums.GXVertexAttribute.Tex0:
case Enums.GXVertexAttribute.Tex1:
case Enums.GXVertexAttribute.Tex2:
case Enums.GXVertexAttribute.Tex3:
case Enums.GXVertexAttribute.Tex4:
case Enums.GXVertexAttribute.Tex5:
case Enums.GXVertexAttribute.Tex6:
case Enums.GXVertexAttribute.Tex7:
int texNo = (int)attrib - 13;
List <Vector2> texCoordData = (List <Vector2>)vertData.GetAttributeData(Enums.GXVertexAttribute.Tex0 + texNo);
Vector2 vertTexCoord = mesh.TextureCoordinateChannels[texNo][vertIndex].ToOpenTKVector2();
vertTexCoord = new Vector2(vertTexCoord.X, 1.0f - vertTexCoord.Y);
switch (texNo)
{
case 0:
AttributeData.TexCoord_0.Add(vertTexCoord);
break;
case 1:
AttributeData.TexCoord_1.Add(vertTexCoord);
break;
case 2:
AttributeData.TexCoord_2.Add(vertTexCoord);
break;
case 3:
AttributeData.TexCoord_3.Add(vertTexCoord);
break;
case 4:
AttributeData.TexCoord_4.Add(vertTexCoord);
break;
case 5:
AttributeData.TexCoord_5.Add(vertTexCoord);
break;
case 6:
AttributeData.TexCoord_6.Add(vertTexCoord);
break;
case 7:
AttributeData.TexCoord_7.Add(vertTexCoord);
break;
}
vert.SetAttributeIndex(Enums.GXVertexAttribute.Tex0 + texNo, (uint)texCoordData.IndexOf(vertTexCoord));
break;
}
}
prim.Vertices.Add(vert);
}
}
else if (primtype == Enums.GXPrimitiveType.Triangles)
{
for (int j = 0; j < primbrawl.Indices.Count / 3; j++)
{
int vert1Index = (int)primbrawl.Indices[j * 3 + 0];
int vert2Index = (int)primbrawl.Indices[j * 3 + 1];
int vert3Index = (int)primbrawl.Indices[j * 3 + 2];
Weight vert1Weight = weights[vert1Index];
Weight vert2Weight = weights[vert2Index];
Weight vert3Weight = weights[vert3Index];
int oldcount = numMatrices;
if (!packetWeights.Contains(vert1Weight))
{
packetWeights.Add(vert1Weight);
numMatrices++;
}
if (!packetWeights.Contains(vert2Weight))
{
packetWeights.Add(vert2Weight);
numMatrices++;
}
if (!packetWeights.Contains(vert3Weight))
{
packetWeights.Add(vert3Weight);
numMatrices++;
}
// There are too many matrices, we need to create a new packet
if (numMatrices > MaxMatricesPerPacket)
{
//Console.WriteLine(String.Format("Making new packet because previous one would have {0}", numMatrices));
//Console.WriteLine(oldcount);
pack.Primitives.Add(prim);
Packets.Add(pack);
prim = new Primitive(Enums.GXPrimitiveType.Triangles);
pack = new Packet();
packetWeights.Clear();
numMatrices = 0;
if (!packetWeights.Contains(vert1Weight))
{
packetWeights.Add(vert1Weight);
numMatrices++;
}
if (!packetWeights.Contains(vert2Weight))
{
packetWeights.Add(vert2Weight);
numMatrices++;
}
if (!packetWeights.Contains(vert3Weight))
{
packetWeights.Add(vert3Weight);
numMatrices++;
}
}
int[] vertexIndexArray = new int[] { vert1Index, vert2Index, vert3Index };
Weight[] vertWeightArray = new Weight[] { vert1Weight, vert2Weight, vert3Weight };
for (int i = 0; i < 3; i++)
{
Vertex vert = new Vertex();
int vertIndex = vertexIndexArray[i];
Weight curWeight = vertWeightArray[i];
vert.SetWeight(curWeight);
foreach (Enums.GXVertexAttribute attrib in activeAttribs)
{
switch (attrib)
{
case Enums.GXVertexAttribute.PositionMatrixIdx:
int newMatrixIndex = -1;
if (curWeight.WeightCount == 1)
{
newMatrixIndex = partialWeight.MeshWeights.IndexOf(curWeight);
}
else
{
if (!envelopes.Weights.Contains(curWeight))
{
envelopes.Weights.Add(curWeight);
}
int envIndex = envelopes.Weights.IndexOf(curWeight);
int drwIndex = partialWeight.MeshWeights.IndexOf(curWeight);
if (drwIndex == -1)
{
throw new System.Exception($"Model has unweighted vertices in mesh \"{mesh.Name}\". Please weight all vertices to at least one bone.");
}
newMatrixIndex = drwIndex;
partialWeight.Indices[drwIndex] = envIndex;
}
if (!pack.MatrixIndices.Contains(newMatrixIndex))
{
pack.MatrixIndices.Add(newMatrixIndex);
}
vert.SetAttributeIndex(Enums.GXVertexAttribute.PositionMatrixIdx, (uint)pack.MatrixIndices.IndexOf(newMatrixIndex));
break;
case Enums.GXVertexAttribute.Position:
List <Vector3> posData = (List <Vector3>)vertData.GetAttributeData(Enums.GXVertexAttribute.Position);
Vector3 vertPos = mesh.Vertices[vertIndex].ToOpenTKVector3();
if (curWeight.WeightCount == 1)
{
Matrix4 ibm = envelopes.InverseBindMatrices[curWeight.BoneIndices[0]];
Vector3 transVec = Vector3.TransformPosition(vertPos, ibm);
if (!posData.Contains(transVec))
{
posData.Add(transVec);
}
AttributeData.Positions.Add(transVec);
vert.SetAttributeIndex(Enums.GXVertexAttribute.Position, (uint)posData.IndexOf(transVec));
}
else
{
if (!posData.Contains(vertPos))
{
posData.Add(vertPos);
}
AttributeData.Positions.Add(vertPos);
vert.SetAttributeIndex(Enums.GXVertexAttribute.Position, (uint)posData.IndexOf(vertPos));
}
break;
case Enums.GXVertexAttribute.Normal:
List <Vector3> normData = (List <Vector3>)vertData.GetAttributeData(Enums.GXVertexAttribute.Normal);
Vector3 vertNrm = mesh.Normals[vertIndex].ToOpenTKVector3();
if (curWeight.WeightCount == 1)
{
Matrix4 ibm = envelopes.InverseBindMatrices[curWeight.BoneIndices[0]];
vertNrm = Vector3.TransformNormal(vertNrm, ibm);
if (!normData.Contains(vertNrm))
{
normData.Add(vertNrm);
}
}
else
{
if (!normData.Contains(vertNrm))
{
normData.Add(vertNrm);
}
}
AttributeData.Normals.Add(vertNrm);
vert.SetAttributeIndex(Enums.GXVertexAttribute.Normal, (uint)normData.IndexOf(vertNrm));
break;
case Enums.GXVertexAttribute.Color0:
case Enums.GXVertexAttribute.Color1:
int colNo = (int)attrib - 11;
List <Color> colData = (List <Color>)vertData.GetAttributeData(Enums.GXVertexAttribute.Color0 + colNo);
Color vertCol = mesh.VertexColorChannels[colNo][vertIndex].ToSuperBMDColorRGBA();
if (colNo == 0)
{
AttributeData.Color_0.Add(vertCol);
}
else
{
AttributeData.Color_1.Add(vertCol);
}
vert.SetAttributeIndex(Enums.GXVertexAttribute.Color0 + colNo, (uint)colData.IndexOf(vertCol));
break;
case Enums.GXVertexAttribute.Tex0:
case Enums.GXVertexAttribute.Tex1:
case Enums.GXVertexAttribute.Tex2:
case Enums.GXVertexAttribute.Tex3:
case Enums.GXVertexAttribute.Tex4:
case Enums.GXVertexAttribute.Tex5:
case Enums.GXVertexAttribute.Tex6:
case Enums.GXVertexAttribute.Tex7:
int texNo = (int)attrib - 13;
List <Vector2> texCoordData = (List <Vector2>)vertData.GetAttributeData(Enums.GXVertexAttribute.Tex0 + texNo);
Vector2 vertTexCoord = mesh.TextureCoordinateChannels[texNo][vertIndex].ToOpenTKVector2();
vertTexCoord = new Vector2(vertTexCoord.X, 1.0f - vertTexCoord.Y);
switch (texNo)
{
case 0:
AttributeData.TexCoord_0.Add(vertTexCoord);
break;
case 1:
AttributeData.TexCoord_1.Add(vertTexCoord);
break;
case 2:
AttributeData.TexCoord_2.Add(vertTexCoord);
break;
case 3:
AttributeData.TexCoord_3.Add(vertTexCoord);
break;
case 4:
AttributeData.TexCoord_4.Add(vertTexCoord);
break;
case 5:
AttributeData.TexCoord_5.Add(vertTexCoord);
break;
case 6:
AttributeData.TexCoord_6.Add(vertTexCoord);
break;
case 7:
AttributeData.TexCoord_7.Add(vertTexCoord);
break;
}
vert.SetAttributeIndex(Enums.GXVertexAttribute.Tex0 + texNo, (uint)texCoordData.IndexOf(vertTexCoord));
break;
}
}
prim.Vertices.Add(vert);
}
}
}
/*
* if (prim.PrimitiveType == Enums.GXPrimitiveType.TriangleStrip) {
* Debug.Assert(prim.Vertices.Count >= 3);
* }
* else if (prim.PrimitiveType == Enums.GXPrimitiveType.Triangles) {
* Debug.Assert(prim.Vertices.Count % 3 == 0);
* }*/
//Console.WriteLine(String.Format("We had this many matrices: {0}", numMatrices));
pack.Primitives.Add(prim);
}
Packets.Add(pack);
int mostmatrices = 0;
if (true)
{
List <Weight> packWeights = new List <Weight>();
foreach (Packet packet in Packets)
{
int matrices = 0;
foreach (Primitive prim in packet.Primitives)
{
foreach (Vertex vert in prim.Vertices)
{
if (!packWeights.Contains(vert.VertexWeight))
{
packWeights.Add(vert.VertexWeight);
matrices++;
}
}
if (prim.PrimitiveType == Enums.GXPrimitiveType.TriangleStrip)
{
Debug.Assert(prim.Vertices.Count >= 3);
}
else if (prim.PrimitiveType == Enums.GXPrimitiveType.Triangles)
{
Debug.Assert(prim.Vertices.Count % 3 == 0);
}
}
if (matrices > mostmatrices)
{
mostmatrices = matrices;
}
//Debug.Assert(matrices <= MaxMatricesPerPacket);
//Console.WriteLine(matrices);
packWeights.Clear();
}
}
//Console.WriteLine(String.Format("Most matrices: {0}", mostmatrices));
}
select(Descriptor: descriptor, Args: args)
)
.ToDictionary(r => r.Descriptor, r => r.Args);
public void ProcessVerticesWithoutWeights(Mesh mesh, VertexData vertData)
{
Packet pack = new Packet();
List <Enums.GXVertexAttribute> activeAttribs = Descriptor.GetActiveAttributes();
AttributeData.SetAttributesFromList(activeAttribs);
//Console.WriteLine("Calculating triangle strips");
uint[] triindices = MakeTriIndexList(mesh);
TriStripper stripper = new TriStripper(triindices);
List <PrimitiveBrawl> primlist = stripper.Strip();
//Console.WriteLine(String.Format("Done, {0} primitives", primlist.Count));
foreach (PrimitiveBrawl primbrawl in primlist)
{
//Primitive prim = new Primitive(Enums.GXPrimitiveType.TriangleStrip);
Primitive prim = new Primitive((Enums.GXPrimitiveType)primbrawl.Type);
//Console.WriteLine(String.Format("Primitive type {0}", (Enums.GXPrimitiveType)primbrawl.Type));
foreach (int vertIndex in primbrawl.Indices)
{
Vertex vert = new Vertex();
Weight rootWeight = new Weight();
rootWeight.AddWeight(1.0f, 0);
vert.SetWeight(rootWeight);
//int vertIndex = face.Indices[i];
foreach (Enums.GXVertexAttribute attrib in activeAttribs)
{
switch (attrib)
{
case Enums.GXVertexAttribute.Position:
List <Vector3> posData = (List <Vector3>)vertData.GetAttributeData(Enums.GXVertexAttribute.Position);
Vector3 vertPos = mesh.Vertices[vertIndex].ToOpenTKVector3();
if (!posData.Contains(vertPos))
{
posData.Add(vertPos);
}
AttributeData.Positions.Add(vertPos);
vert.SetAttributeIndex(Enums.GXVertexAttribute.Position, (uint)posData.IndexOf(vertPos));
break;
case Enums.GXVertexAttribute.Normal:
List <Vector3> normData = (List <Vector3>)vertData.GetAttributeData(Enums.GXVertexAttribute.Normal);
Vector3 vertNrm = mesh.Normals[vertIndex].ToOpenTKVector3();
if (!normData.Contains(vertNrm))
{
normData.Add(vertNrm);
}
AttributeData.Normals.Add(vertNrm);
vert.SetAttributeIndex(Enums.GXVertexAttribute.Normal, (uint)normData.IndexOf(vertNrm));
break;
case Enums.GXVertexAttribute.Color0:
case Enums.GXVertexAttribute.Color1:
int colNo = (int)attrib - 11;
List <Color> colData = (List <Color>)vertData.GetAttributeData(Enums.GXVertexAttribute.Color0 + colNo);
Color vertCol = mesh.VertexColorChannels[colNo][vertIndex].ToSuperBMDColorRGBA();
if (colNo == 0)
{
AttributeData.Color_0.Add(vertCol);
}
else
{
AttributeData.Color_1.Add(vertCol);
}
vert.SetAttributeIndex(Enums.GXVertexAttribute.Color0 + colNo, (uint)colData.IndexOf(vertCol));
break;
case Enums.GXVertexAttribute.Tex0:
case Enums.GXVertexAttribute.Tex1:
case Enums.GXVertexAttribute.Tex2:
case Enums.GXVertexAttribute.Tex3:
case Enums.GXVertexAttribute.Tex4:
case Enums.GXVertexAttribute.Tex5:
case Enums.GXVertexAttribute.Tex6:
case Enums.GXVertexAttribute.Tex7:
int texNo = (int)attrib - 13;
List <Vector2> texCoordData = (List <Vector2>)vertData.GetAttributeData(Enums.GXVertexAttribute.Tex0 + texNo);
Vector2 vertTexCoord = mesh.TextureCoordinateChannels[texNo][vertIndex].ToOpenTKVector2();
vertTexCoord = new Vector2(vertTexCoord.X, 1.0f - vertTexCoord.Y);
switch (texNo)
{
case 0:
AttributeData.TexCoord_0.Add(vertTexCoord);
break;
case 1:
AttributeData.TexCoord_1.Add(vertTexCoord);
break;
case 2:
AttributeData.TexCoord_2.Add(vertTexCoord);
break;
case 3:
AttributeData.TexCoord_3.Add(vertTexCoord);
break;
case 4:
AttributeData.TexCoord_4.Add(vertTexCoord);
break;
case 5:
AttributeData.TexCoord_5.Add(vertTexCoord);
break;
case 6:
AttributeData.TexCoord_6.Add(vertTexCoord);
break;
case 7:
AttributeData.TexCoord_7.Add(vertTexCoord);
break;
}
vert.SetAttributeIndex(Enums.GXVertexAttribute.Tex0 + texNo, (uint)texCoordData.IndexOf(vertTexCoord));
break;
}
}
//triindices[vertIndex] = 1;
prim.Vertices.Add(vert);
}
pack.Primitives.Add(prim);
}
pack.MatrixIndices.Add(0);
Packets.Add(pack);
Bounds.GetBoundsValues(AttributeData.Positions);
}
public override async Task ReportsDiagnostic_WhenUsingReEntrantReturnsForAnyArgsViaMethodCall(string method, string reEntrantCall)
{
var plainMethodName = method.Replace("SubstituteExtensions.", string.Empty).Replace("(Of Integer)", string.Empty);
var source = $@"Imports NSubstitute
Namespace MyNamespace
Interface IFoo
Function Bar() As Integer
End Interface
Interface IBar
Function Foo() As Integer
End Interface
Public Class FooTests
Public Sub Test()
Dim substitute = NSubstitute.Substitute.[For](Of IFoo)()
{method}(substitute.Bar(), [|ReturnThis()|], [|OtherReturn()|])
End Sub
Private Function ReturnThis() As Integer
Return OtherReturn()
End Function
Private Function OtherReturn() As Integer
Dim substitute = NSubstitute.Substitute.[For](Of IBar)()
{reEntrantCall}
Return 1
End Function
End Class
End Namespace
";
var textParserResult = TextParser.GetSpans(source);
var diagnosticMessages = new[]
{
$"{plainMethodName}() is set with a method that itself calls ReturnsForAnyArgs. This can cause problems with NSubstitute. Consider replacing with a lambda: {plainMethodName}(Function(x) ReturnThis()).",
$"{plainMethodName}() is set with a method that itself calls ReturnsForAnyArgs. This can cause problems with NSubstitute. Consider replacing with a lambda: {plainMethodName}(Function(x) OtherReturn())."
};
var diagnostics = textParserResult.Spans.Select((span, idx) => CreateDiagnostic(Descriptor.OverrideMessage(diagnosticMessages[idx]), span.Span, span.LineSpan)).ToArray();
await VerifyDiagnostic(textParserResult.Text, diagnostics);
}
protected override HttpParameterBinding CreateInnerBinding(IEnumerable <MediaTypeFormatter> perRequestFormatters)
{
return(Descriptor.BindWithFormatter(perRequestFormatters, bodyModelValidator: null));
}
protected void RawDataAdd(byte[] aRawData)
{
Descriptor.RawDataAdd(aRawData);
}
private bool BuildParameterDescriptor(
Descriptor descriptor, FbParameter parameter, int index)
{
Charset charset = this.connection.InnerConnection.Database.Charset;
FbDbType type = parameter.FbDbType;
// Check the parameter character set
if (parameter.Charset != FbCharset.Default)
{
int idx = Charset.SupportedCharsets.IndexOf((int)parameter.Charset);
charset = Charset.SupportedCharsets[idx];
}
else
{
if (type == FbDbType.Guid)
{
charset = Charset.SupportedCharsets["OCTETS"];
}
}
// Set parameter Data Type
descriptor[index].DataType =
(short)TypeHelper.GetFbType((DbDataType)type, parameter.IsNullable);
// Set parameter Sub Type
switch (type)
{
case FbDbType.Binary:
descriptor[index].SubType = 0;
break;
case FbDbType.Text:
descriptor[index].SubType = 1;
break;
case FbDbType.Guid:
descriptor[index].SubType = (short)charset.ID;
break;
case FbDbType.Char:
case FbDbType.VarChar:
descriptor[index].SubType = (short)charset.ID;
if (parameter.Size > 0)
{
short len = (short)(parameter.Size * charset.BytesPerCharacter);
descriptor[index].Length = len;
}
break;
}
// Set parameter length
if (descriptor[index].Length == 0)
{
descriptor[index].Length = TypeHelper.GetSize((DbDataType)type);
}
// Verify parameter
if (descriptor[index].SqlType == 0 || descriptor[index].Length == 0)
{
return(false);
}
return(true);
}
protected void RawDataClear()
{
Descriptor.RawDataClear();
}
public override byte[] Rebuild()
{
FileOutput f = new FileOutput();
f.endian = Endianness.Little;
FileOutput fv = new FileOutput();
fv.endian = Endianness.Little;
f.WriteShort(format);
f.WriteShort(unknown);
f.WriteInt(flags);
f.WriteInt(mode);
bool hasNameTable = (flags & 2) > 0;
f.WriteInt(mesh.Count);
int vertSize = 0;
// Vertex Bank
for (int i = 0; i < 1; i++)
{
if (mode == 0 || i == 0)
{
Descriptor des = descript[i];
if (format != 4)
{
foreach (Vertex v in vertices)
{
for (int k = 0; k < des.type.Length; k++)
{
fv.Align(2, 0x00);
switch (des.type[k])
{
case 0: //Position
writeType(fv, v.pos.X, des.format[k], des.scale[k]);
writeType(fv, v.pos.Y, des.format[k], des.scale[k]);
writeType(fv, v.pos.Z, des.format[k], des.scale[k]);
break;
case 1: //Normal
writeType(fv, v.nrm.X, des.format[k], des.scale[k]);
writeType(fv, v.nrm.Y, des.format[k], des.scale[k]);
writeType(fv, v.nrm.Z, des.format[k], des.scale[k]);
break;
case 2: //Color
writeType(fv, v.col.X, des.format[k], des.scale[k]);
writeType(fv, v.col.Y, des.format[k], des.scale[k]);
writeType(fv, v.col.Z, des.format[k], des.scale[k]);
writeType(fv, v.col.W, des.format[k], des.scale[k]);
break;
case 3: //Tex0
writeType(fv, v.tx[0].X, des.format[k], des.scale[k]);
writeType(fv, v.tx[0].Y, des.format[k], des.scale[k]);
break;
case 4: //Tex1
writeType(fv, v.tx[1].X, des.format[k], des.scale[k]);
writeType(fv, v.tx[1].Y, des.format[k], des.scale[k]);
break;
case 5: //Bone Index
fv.WriteByte(v.node[0]);
fv.WriteByte(v.node[1]);
break;
case 6: //Bone Weight
writeType(fv, v.weight[0], des.format[k], des.scale[k]);
writeType(fv, v.weight[1], des.format[k], des.scale[k]);
break;
//default:
// Console.WriteLine("WTF is this");
}
}
}
vertSize = fv.Size();
fv.Align(32, 0xFF);
}
}
for (int j = 0; j < mesh.Count; j++)
{
foreach (List <int> l in mesh[j].faces)
{
foreach (int index in l)
{
fv.WriteShort(index);
}
fv.Align(32, 0xFF);
}
}
}
for (int i = 0; i < mesh.Count; i++)
{
if (i == 0 && mode == 1)
{
descript[0].WriteDescription(f);
f.WriteInt(vertSize);
}
f.WriteInt(mesh[i].nodeList.Count);
//Console.WriteLine(mesh[i].faces.Count + " " + mesh[i].nodeList.Count);
for (int j = 0; j < mesh[i].nodeList.Count; j++)
{
f.WriteInt(mesh[i].nodeList[j].Count);
for (int k = 0; k < mesh[i].nodeList[j].Count; k++)
{
f.WriteInt(mesh[i].nodeList[j][k]);
}
f.WriteInt(mesh[i].faces[j].Count);
// TODO: This stuff
if (hasNameTable)
{
//int nameId = d.readInt();
}
/*if (mode == 0)
* {
* if (format == 4)
* {
* int[] buffer = new int[primitiveCount];
* for (int k = 0; k < primitiveCount; k++)
* {
* buffer[k] = d.readShort();
* }
* d.align(4);
* List<int> buf = new List<int>();
* buf.AddRange(buffer);
* m.faces.Add(buf);
* }
* else
* {
* Descriptor des = new Descriptor();
* des.ReadDescription(d);
* descript.Add(des);
* }
*
* }*/
}
}
// TODO: STRING TABLE
/*if (hasNameTable)
* {
* for (int i = 0; i < mesh.Count; i++)
* {
* int index = d.readByte();
* nameTable.Add(d.readString());
* }
* }*/
if (format != 4)
{
f.Align(32, 0xFF);
}
f.WriteOutput(fv);
return(f.GetBytes());
}
private void RegisterAsType(Descriptor nullClientDescriptor, Type p1)
{
throw new NotImplementedException();
}
protected DescriptorHeap(ref Descriptor desc, Device device, string label) : base(ref desc, device, label)
{
associatedResources = new Resource[desc.NumResourceDescriptors];
Create();
}
/// <summary>
/// Generate an <see cref="IReinforcementModel"/> based on a set of examples and transitions.
/// </summary>
/// <exception cref="InvalidOperationException">Thrown when the requested operation is invalid.</exception>
/// <param name="descriptor">The description.</param>
/// <param name="examples1">Example training set or state/action pairs.</param>
/// <param name="transitionDescriptor">(Optional) Descriptor for extracting transition state/reward information from <paramref name="examples2"/> set.</param>
/// <param name="examples2">(Optional) Corresponding training set where each item represents a transition state from <paramref name="examples1"/> and a reward label.</param>
/// <returns>IReinforcementModel.</returns>
public IReinforcementModel Generate(Descriptor descriptor, IEnumerable <object> examples1, Descriptor transitionDescriptor, IEnumerable <object> examples2)
{
if (examples1.Count() == 0)
{
throw new InvalidOperationException("Empty example set.");
}
bool hasTransitionStates = (examples2 != null && examples2.Any());
this.Descriptor = descriptor;
this.TransitionDescriptor = transitionDescriptor;
if (Descriptor.Features == null || Descriptor.Features.Length == 0)
{
throw new InvalidOperationException("Invalid State Descriptor: Empty feature set!");
}
if (Descriptor.Label == null)
{
throw new InvalidOperationException("Invalid State Descriptor: Empty label!");
}
if (hasTransitionStates)
{
if (TransitionDescriptor == null || TransitionDescriptor.Features == null || TransitionDescriptor.Features.Length == 0)
{
throw new ArgumentNullException($"Transition Descriptor was null. A transition desciptor is required for '{nameof(examples2)}'.");
}
if (examples2.Count() != examples1.Count())
{
throw new InvalidOperationException($"Length of '{nameof(examples1)}' must match length of '{nameof(examples2)}'.");
}
}
var doubles = this.Descriptor.Convert(examples1);
var(states, actions) = doubles.ToExamples();
Matrix statesP = null;
Vector rewards = Vector.Rand(actions.Length);
if (hasTransitionStates)
{
var doubles2 = this.TransitionDescriptor.Convert(examples2);
(statesP, rewards) = doubles2.ToExamples();
}
else
{
statesP = new Matrix(states.Rows, states.Cols);
// assume temporal
for (int i = 0; i < states.Rows - 1; i++)
{
statesP[i, VectorType.Row] = states[i + 1, VectorType.Row];
}
}
return(Generate(states, actions, statesP, rewards));
}
protected override string GetCategory(Descriptor desc)
{
return(string.Empty);
}
public MapChange(long transactionId, Descriptor descriptor, TransactionType operation)
{
TransactionId = transactionId;
Descriptor = descriptor;
Operation = operation;
}
/// <summary>
/// Generates an <see cref="IReinforcementModel"/> from a descriptor and examples.
/// </summary>
/// <typeparam name="T">Object type</typeparam>
/// <param name="descriptor">The description.</param>
/// <param name="examples1">Example training set.</param>
/// <param name="examples2">(Optional) Corresponding training set where each item represents a transition from <paramref name="examples1"/>.</param>
/// <returns>IReinforcementModel</returns>
public IReinforcementModel Generate <T>(Descriptor descriptor, IEnumerable <T> examples1, IEnumerable <T> examples2) where T : class
{
return(Generate(descriptor, examples1 as IEnumerable <object>, examples2 as IEnumerable <object>));
}
public void OnLobby(Descriptor descriptor)
{
desc = descriptor;
tb.text = desc.Name();
}
public override async Task ReportsDiagnostic_WhenUsingReEntrantReturnsForAnyArgsViaMethodCall(string method, string reEntrantCall)
{
var plainMethodName = method.Replace("<int>", string.Empty);
var source = $@"using NSubstitute;
namespace MyNamespace
{{
public interface IFoo
{{
int Bar();
}}
public interface IBar
{{
int Foo();
}}
public class FooTests
{{
public void Test()
{{
var substitute = Substitute.For<IFoo>();
substitute.Bar().{method}([|ReturnThis()|], [|OtherReturn()|]);
}}
private int ReturnThis()
{{
return OtherReturn();
}}
private int OtherReturn()
{{
var substitute = Substitute.For<IBar>();
{reEntrantCall}
return 1;
}}
}}
}}";
var textParserResult = TextParser.GetSpans(source);
var diagnosticMessages = new[]
{
$"{plainMethodName}() is set with a method that itself calls ReturnsForAnyArgs. This can cause problems with NSubstitute. Consider replacing with a lambda: {plainMethodName}(x => ReturnThis()).",
$"{plainMethodName}() is set with a method that itself calls ReturnsForAnyArgs. This can cause problems with NSubstitute. Consider replacing with a lambda: {plainMethodName}(x => OtherReturn())."
};
var diagnostics = textParserResult.Spans.Select((span, idx) => CreateDiagnostic(Descriptor.OverrideMessage(diagnosticMessages[idx]), span.Span, span.LineSpan)).ToArray();
await VerifyDiagnostic(textParserResult.Text, diagnostics);
}
