/// <summary> /// import CSV file into subset /// </summary> /// <param name="path"></param> /// <returns></returns> public Subset GetDataTableFromCsv(string path) { if (string.IsNullOrWhiteSpace(path)) { throw new ArgumentException(); } Subset mySubset = new Subset(); TextFieldParser parser = new TextFieldParser(path); parser.TextFieldType = FieldType.Delimited; parser.SetDelimiters(","); while (!parser.EndOfData) { Line myline = new Line(); //Processing row string[] fields = parser.ReadFields(); foreach (string field in fields) { //TODO: Process field string t = field; myline.LineInformation.Add(field); } mySubset.Nomenclature.Add(myline); } parser.Close(); return(mySubset); }
private void Init(IQueryable <T> superset, int pageNumber, int pageSize) { if (pageSize < 1) { throw new ArgumentOutOfRangeException(nameof(pageSize), pageSize, "PageSize cannot be less than 1."); } PageSize = pageSize; PageNumber = 1; PageCount = TotalItemCount > 0 ? (int)Math.Ceiling(TotalItemCount / (double)PageSize) : 0; if (pageNumber > 0 && pageNumber <= PageCount) { PageNumber = pageNumber; } HasPreviousPage = PageNumber > 1; HasNextPage = PageNumber < PageCount; IsFirstPage = PageNumber == 1; IsLastPage = PageNumber >= PageCount; FirstItemOnPage = (PageNumber - 1) * PageSize + 1; var num = FirstItemOnPage + PageSize - 1; LastItemOnPage = num > TotalItemCount ? TotalItemCount : num; if (superset == null || TotalItemCount <= 0) { return; } var skipCount = pageNumber == 1 ? 0 : (pageNumber - 1) * pageSize; Subset.AddRange(superset.Skip(skipCount).Take(pageSize).ToList()); }
public void UpdateTreeView(Subset poigneegaz) { treeView1.BeginUpdate(); int i = 0; foreach (Line li in poigneegaz.Nomenclature) { if (li.CompoCost == 0) { treeView1.Nodes.Add(li.Designation); } if (li.CompoCost != 0) { treeView1.Nodes[i].Nodes.Add(li.Designation); i++; } } //treeView1.Nodes.Add("Parent"); //treeView1.Nodes[0].Nodes.Add("Child 1"); //treeView1.Nodes[0].Nodes.Add("Child 2"); //treeView1.Nodes[0].Nodes[1].Nodes.Add("Grandchild"); //treeView1.Nodes[0].Nodes[1].Nodes[0].Nodes.Add("Great Grandchild"); treeView1.EndUpdate(); }
protected override Subset <DefinitionInstruction> Join(Subset <DefinitionInstruction> left, Subset <DefinitionInstruction> right) { var result = left.Clone(); result.Union(right); return(result); }
/// <summary> /// Merge the subsets of two items if they are not in the same set by grouping their parents. /// </summary> /// <param name="x">The first item.</param> /// <param name="y">The second item.</param> public void Union([NotNull] T x, [NotNull] T y) { if (Comparer.Equals(x, y)) { return; } T xroot = Find(x); T yroot = Find(y); if (Comparer.Equals(xroot, yroot)) { return; } if (Items[xroot].Rank > Items[yroot].Rank) { Items[yroot].Parent = xroot; } else { Subset xsubset = Items[xroot]; Subset ysubset = Items[yroot]; xsubset.Parent = yroot; if (xsubset.Rank < ysubset.Rank) { ysubset.Rank += xsubset.Rank; } } }
public void CheckArrays(Subset aSubset = null) { if (aSubset == null) { aSubset = this; } if (aSubset.mNormals.Count > 0) { CheckFilled <Vector3>(ref mNormals, Vector3.zero, mPoints.Count); } if (aSubset.mUVs.Count > 0) { CheckFilled <Vector2>(ref mUVs, Vector2.zero, mPoints.Count); } if (aSubset.mLightUVs.Count > 0) { CheckFilled <Vector2>(ref mLightUVs, Vector2.zero, mPoints.Count); } if (aSubset.mTangents.Count > 0) { CheckFilled <Vector4>(ref mTangents, Vector4.zero, mPoints.Count); } if (aSubset.mColors.Count > 0) { CheckFilled <Color>(ref mColors, Color.white, mPoints.Count); } }
public SubsetList CreateSubsets(IEnumerable <SubResult> subResults) { var result = new SubsetList(); if (subResults == null) { return(result); } var metadata = MetadataHelper.GetInitializedMetadata(_domainService); foreach (var subResult in subResults) { var dbSetInfo = metadata.dbSets[subResult.dbSetName]; if (result.Any(r => r.dbSetName == subResult.dbSetName)) { throw new DomainServiceException(string.Format("The included results already have {0} entities", dbSetInfo.dbSetName)); } var rowGenerator = new RowGenerator(dbSetInfo, subResult.Result, _dataHelper); var current = new Subset { dbSetName = dbSetInfo.dbSetName, rows = rowGenerator.CreateDistinctRows(), names = dbSetInfo.GetNames() }; result.Add(current); } return(result); }
public void MakeSet([NotNull] T item) { Subset subset = Items[item]; subset.Parent = item; subset.Rank = 0; }
public static void FindMinimumSpaningTree(UnDirectedGraph g) { DisJointSets dj = new DisJointSets(); Subset[] subsets = new Subset[g.Vertices.Length]; List <Edge> edgeList = new List <Edge>(); dj.MakeSet(subsets); for (int i = 0; i < g.Vertices.Length; i++) { edgeList.AddRange(g.Vertices[i].Edges); } edgeList = edgeList.OrderBy(o => o.Weight).ToList(); foreach (var edge in edgeList) { int x = dj.FindSet(subsets, edge.Source.Index); int y = dj.FindSet(subsets, edge.Destination.Index); if (x != y) { Console.Write($"({edge.Source.Index},{edge.Destination.Index}) "); dj.Union(subsets, x, y); } } }
public void Given_Generated_Subsets_SortSubsets_Change_Order_Descending_Subsets_By_Total_Items_Value() { var subset1 = new Subset(); subset1.Items.Add(new Item(1, 1, 1)); subset1.Items.Add(new Item(1, 1, 6)); var subset2 = new Subset(); subset2.Items.Add(new Item(1, 6, 2)); var subset3 = new Subset(); subset3.Items.Add(new Item(1, 1, 24)); _container.AddSubset(subset1); _container.AddSubset(subset2); _container.AddSubset(subset3); _container.SortSubsets(); Assert.Multiple(() => { Assert.AreEqual(subset3, _container.Subsets[0]); Assert.AreEqual(subset1, _container.Subsets[1]); Assert.AreEqual(subset2, _container.Subsets[2]); }); }
public void Given_Subsets_Which_Items_Fits_Container_FindBestSubset_Returns_Subset_With_Highest_TotalValue() { var subset1 = new Subset(); subset1.Items.Add(new Item(1, 1, 1)); subset1.Items.Add(new Item(1, 1, 6)); var subset2 = new Subset(); subset2.Items.Add(new Item(1, 1, 2)); var subset3 = new Subset(); subset3.Items.Add(new Item(1, 1, 24)); var subset4 = new Subset(); subset4.Items.Add(new Item(1, 1, 4)); subset4.Items.Add(new Item(1, 1, 14)); subset4.Items.Add(new Item(1, 1, 8)); _container.AddSubset(subset1); _container.AddSubset(subset2); _container.AddSubset(subset3); _container.SortSubsets(); var subset = _container.FindBestSubset(); Assert.AreEqual(subset3, subset); }
protected override Subset <IVariable> Join(Subset <IVariable> left, Subset <IVariable> right) { var result = left.Clone(); result.Union(right); return(result); }
public TwisterAlgorithm( Subset subset, bool chunkPositivePMI = true, bool chunkAveragePMI = true, int compressTagOccurence = 0, int compressCorpusOccurence = 0, LogicalOperatorEnum op = LogicalOperatorEnum.AND, bool useRxy = true ) : base(subset) { _chunkPositivePMI = chunkPositivePMI; _chunkAveragePMI = chunkAveragePMI; if (compressCorpusOccurence > 0 && compressTagOccurence > 0) { // tOcc <= _compressTagOccurence // cOcc <= _compressCorpusOccurence var tPe = Expression.Parameter(typeof(int)); var cPe = Expression.Parameter(typeof(int)); var tConst = Expression.Constant(compressTagOccurence); var cConst = Expression.Constant(compressCorpusOccurence); var left = Expression.LessThanOrEqual(tPe, tConst); var right = Expression.LessThanOrEqual(cPe, cConst); var exp = (op == LogicalOperatorEnum.AND) ? Expression.And(left, right) : Expression.Or(left, right); Expression <Func <int, int, bool> > le = Expression.Lambda <Func <int, int, bool> >(exp, tPe, cPe); _compiledExpression = le.Compile(); } }
private static void subset_complement_test() //****************************************************************************80 // // Purpose: // // SUBSET_COMPLEMENT_TEST tests SUBSET_COMPLEMENT. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 06 January 2016 // // Author: // // John Burkardt // { Console.WriteLine(""); Console.WriteLine("SUBSET_COMPLEMENT_TEST"); Console.WriteLine(" SUBSET_COMPLEMENT returns the complement of a subset."); Console.WriteLine(""); const int n = 5; int seed = 123456789; int[] s1 = Subset.subset_random(n, ref seed); typeMethods.i4vec_transpose_print(n, s1, " Subset S1: "); int[] s2 = Subset.subset_complement(n, s1); typeMethods.i4vec_transpose_print(n, s2, " S2 = complement of S1:"); }
private async Task InitAsync(IQueryable <T> superset, int pageNumber, int pageSize) { if (pageNumber < 1) { throw new ArgumentOutOfRangeException("pageNumber: " + pageNumber, "PageNumber cannot be below 1."); } if (pageSize < 1) { throw new ArgumentOutOfRangeException("pageSize: " + pageSize, "PageSize cannot be less than 1."); } TotalItemCount = (superset == null) ? 0 : superset.Count <T>(); PageSize = pageSize; PageNumber = pageNumber; PageCount = (TotalItemCount > 0) ? ((int)Math.Ceiling(((double)TotalItemCount) / PageSize)) : 0; HasPreviousPage = PageNumber > 1; HasNextPage = PageNumber < PageCount; IsFirstPage = PageNumber == 1; IsLastPage = PageNumber >= PageCount; FirstItemOnPage = ((PageNumber - 1) * PageSize) + 1; var num = (FirstItemOnPage + PageSize) - 1; LastItemOnPage = (num > TotalItemCount) ? TotalItemCount : num; if ((superset != null) && (TotalItemCount > 0)) { Subset.AddRange( (pageNumber == 1) ? await superset.Skip <T>(0).Take <T>(pageSize).ToListAsync <T>().ConfigureAwait(false) : await superset.Skip <T>(((pageNumber - 1) * pageSize)).Take <T>(pageSize).ToListAsync <T>().ConfigureAwait(false) ); } }
public PagedList(IMongoQueryable <T> superset, int pageNumber, int pageSize) { if (pageNumber < 1) { throw new ArgumentOutOfRangeException("pageNumber", pageNumber, "PageNumber cannot be below 1."); } if (pageSize < 1) { throw new ArgumentOutOfRangeException("pageSize", pageSize, "PageSize cannot be less than 1."); } TotalItemCount = superset == null ? 0 : superset.Count(); PageSize = pageSize; PageNumber = pageNumber; PageCount = TotalItemCount > 0 ? (int)Math.Ceiling(TotalItemCount / (double)PageSize) : 0; HasPreviousPage = PageNumber > 1; HasNextPage = PageNumber < PageCount; IsFirstPage = PageNumber == 1; IsLastPage = PageNumber >= PageCount; FirstItemOnPage = (PageNumber - 1) * PageSize + 1; var numberOfLastItemOnPage = FirstItemOnPage + PageSize - 1; LastItemOnPage = numberOfLastItemOnPage > TotalItemCount ? TotalItemCount : numberOfLastItemOnPage; if (superset != null && TotalItemCount > 0) { Subset.AddRange(pageNumber == 1 ? superset.Skip(0).Take(pageSize).ToList() : superset.Skip((pageNumber - 1) * pageSize).Take(pageSize).ToList() ); } }
//Kruskals min span algorithm //1. Take all edges from the tree and sort them based on weight. (or in our case Enemy) //2. Loop through edges and find the subset of either end of the edge. //3. If they aren't in the same subset unify them by rank. //4. If they are it means this edge we want to add will make a cycle. We don't like cycles. So we destroy that edge. //5. Update the edges public void Kruskal() { if (Rooms == null || Halls == null || Rooms.Count < 1 || Halls.Count < 1) GetEdgesAndRooms(); //sort edges(halls) by weight (enemy) List<Hall> sorted_edges = Halls.OrderBy(o => o.Enemy).ToList(); Subset[] subsets = new Subset[_roomCount]; //If necessary? Dictionary<int, int> ids = new Dictionary<int, int>(); //init subset and ids dictonary for (int i = 0; i < _roomCount; ++i) { subsets[i].parent = i; subsets[i].rank = 0; //map indices to roomid ids.Add(Rooms[i].Id, i); } //loop through edges for (int j = 0; j < _edgeCount; ++j) { int ia = ids[sorted_edges[j].enda.Id]; int ib = ids[sorted_edges[j].endb.Id]; int x = Find(subsets, ia); int y = Find(subsets, ib); if (x != y) { Union(subsets, x, y); } else { sorted_edges[j].IsDestroyed = true; } } Halls = sorted_edges; UpdateEdges(); }
public static bool IsCycle(UnDirectedGraph g) { DisJointSets dj = new DisJointSets(); Subset[] subsets = new Subset[g.Vertices.Length]; dj.MakeSet(subsets); for (int i = 0; i < g.Vertices.Length; i++) { int u = i; foreach (var edge in g.Vertices[i].Edges) { int v = edge.Destination.Index; int x = dj.FindSet(subsets, u); int y = dj.FindSet(subsets, v); if (x == y) { return(true); } dj.Union(subsets, x, y); } } return(false); }
public SerializablePagedList(IEnumerable <T> superset, int pageNumber, int pageSize) : this(superset.AsQueryable <T>(), pageNumber, pageSize) { // set source to blank list if superset is null to prevent exceptions TotalItemCount = superset == null ? 0 : superset.Count(); PageSize = pageSize; PageNumber = pageNumber; PageCount = TotalItemCount > 0 ? (int)Math.Ceiling(TotalItemCount / (double)PageSize) : 0; HasPreviousPage = PageNumber > 1; HasNextPage = PageNumber < PageCount; IsFirstPage = PageNumber == 1; IsLastPage = PageNumber >= PageCount; FirstItemOnPage = (PageNumber - 1) * PageSize + 1; var numberOfLastItemOnPage = FirstItemOnPage + PageSize - 1; LastItemOnPage = numberOfLastItemOnPage > TotalItemCount ? TotalItemCount : numberOfLastItemOnPage; // add items to internal list if (superset != null && TotalItemCount > 0) { Subset.AddRange(pageNumber == 1 ? superset.Skip(0).Take(pageSize).ToList() : superset.Skip((pageNumber - 1) * pageSize).Take(pageSize).ToList() ); } }
public static Graph.Edge[] SolvePar(Graph.Edge[] edges, int verticesCount) { var mst = new Graph.Edge[verticesCount - 1]; Sort.StartSortPar(edges); int i = 0; int e = 0; var subsets = new Subset[verticesCount]; for (int v = 0; v < verticesCount; v++) { subsets[v].Parent = v; subsets[v].Rank = 0; } while (e < verticesCount - 1) { Graph.Edge nextEdge = edges[i++]; int x = Find(subsets, nextEdge.src); int y = Find(subsets, nextEdge.dest); if (x != y) { mst[e++] = nextEdge; Union(subsets, x, y); } } return(mst); }
public virtual void CalculateMetrics(FeatureSubsetModel <IPredictorProducing <TOutput> > model, ISubsetSelector subsetSelector, Subset subset, Batch batch, bool needMetrics) { if (!needMetrics || model == null || model.Metrics != null) { return; } using (var ch = Host.Start("Calculate metrics")) { RoleMappedData testData = subsetSelector.GetTestData(subset, batch); // Because the training and test datasets are drawn from the same base dataset, the test data role mappings // are the same as for the train data. IDataScorerTransform scorePipe = ScoreUtils.GetScorer(model.Predictor, testData, Host, testData.Schema); // REVIEW: Should we somehow allow the user to customize the evaluator? // By what mechanism should we allow that? var evalComp = GetEvaluatorSubComponent(); RoleMappedData scoredTestData = RoleMappedData.Create(scorePipe, GetColumnRoles(testData.Schema, scorePipe.Schema)); IEvaluator evaluator = evalComp.CreateInstance(Host); // REVIEW: with the new evaluators, metrics of individual models are no longer // printed to the Console. Consider adding an option on the combiner to print them. // REVIEW: Consider adding an option to the combiner to save a data view // containing all the results of the individual models. var metricsDict = evaluator.Evaluate(scoredTestData); if (!metricsDict.TryGetValue(MetricKinds.OverallMetrics, out IDataView metricsView)) { throw Host.Except("Evaluator did not produce any overall metrics"); } // REVIEW: We're assuming that the metrics of interest are always doubles here. var metrics = EvaluateUtils.GetMetrics(metricsView, getVectorMetrics: false); model.Metrics = metrics.ToArray(); ch.Done(); } }
/// <summary> /// Initializes a new instance of a type deriving from <see cref = "BasePagedList{T}" /> and sets properties needed to calculate position and size data on the subset and superset. /// </summary> /// <param name="subset">The single subset this collection should represent.</param> /// <param name = "pageNumber">The one-based index of the subset of objects contained by this instance.</param> /// <param name = "pageSize">The maximum size of any individual subset.</param> /// <param name = "totalItemCount">The size of the superset.</param> protected internal PagedList(IEnumerable <T> subset, int pageNumber, int pageSize, int totalItemCount) { if (pageNumber < 1) { throw new ArgumentOutOfRangeException($"pageNumber = {pageNumber}. PageNumber cannot be below 1."); } if (pageSize < 1) { throw new ArgumentOutOfRangeException($"pageSize = {pageSize}. PageSize cannot be less than 1."); } // set source to blank list if superset is null to prevent exceptions TotalItemCount = totalItemCount; PageNumber = pageNumber; PageSize = pageSize; PageCount = TotalItemCount > 0 ? (int)Math.Ceiling(TotalItemCount / (double)PageSize) : 0; HasPreviousPage = PageNumber > 1; HasNextPage = PageNumber < PageCount; IsFirstPage = PageNumber == 1; IsLastPage = PageNumber == PageCount; FirstItemOnPage = (PageNumber - 1) * PageSize + 1; var numberOfLastItemOnPage = FirstItemOnPage + PageSize - 1; LastItemOnPage = numberOfLastItemOnPage > TotalItemCount ? TotalItemCount : numberOfLastItemOnPage; Subset.AddRange(subset); }
public SubsetList CreateSubsets(IEnumerable <SubResult> subResults) { SubsetList result = new SubsetList(); if (subResults == null) { return(result); } foreach (SubResult subResult in subResults) { DbSetInfo dbSetInfo = _metadata.DbSets[subResult.dbSetName]; if (result.Any(r => r.dbSetName == subResult.dbSetName)) { throw new DomainServiceException(string.Format("The included sub results already have DbSet {0} entities", dbSetInfo.dbSetName)); } RowGenerator rowGenerator = new RowGenerator(dbSetInfo, subResult.Result, _dataHelper); Subset current = new Subset { dbSetName = dbSetInfo.dbSetName, rows = rowGenerator.CreateDistinctRows(), names = dbSetInfo.GetNames() }; result.Add(current); } return(result); }
public override void CalculateMetrics(FeatureSubsetModel <IPredictorProducing <TOutput> > model, ISubsetSelector subsetSelector, Subset subset, Batch batch, bool needMetrics) { base.CalculateMetrics(model, subsetSelector, subset, batch, needMetrics); var vm = model.Predictor as IValueMapper; Host.Check(vm != null, "Predictor doesn't implement the expected interface"); var map = vm.GetMapper <VBuffer <Single>, TOutput>(); TOutput[] preds = new TOutput[100]; int count = 0; var data = subsetSelector.GetTestData(subset, batch); using (var cursor = new FeatureFloatVectorCursor(data, CursOpt.AllFeatures)) { while (cursor.MoveNext()) { Utils.EnsureSize(ref preds, count + 1); map(in cursor.Features, ref preds[count]); count++; } } Array.Resize(ref preds, count); _predictions[model] = preds; }
public SerializablePagedList(IEnumerable <T> superset, int pageNumber, int pageSize, int totalCount) : this(superset.AsQueryable <T>(), pageNumber, pageSize) { // set source to blank list if superset is null to prevent exceptions TotalItemCount = totalCount; PageSize = pageSize; PageNumber = pageNumber; PageCount = TotalItemCount > 0 ? (int)Math.Ceiling(TotalItemCount / (double)PageSize) : 0; HasPreviousPage = PageNumber > 1; HasNextPage = PageNumber < PageCount; IsFirstPage = PageNumber == 1; IsLastPage = PageNumber >= PageCount; FirstItemOnPage = (PageNumber - 1) * PageSize + 1; var numberOfLastItemOnPage = FirstItemOnPage + PageSize - 1; LastItemOnPage = numberOfLastItemOnPage > TotalItemCount ? TotalItemCount : numberOfLastItemOnPage; // add items to internal list if (superset == null || TotalItemCount <= 0 || Subset.Count > 0) { return; } var enumerable = superset as IList <T> ?? superset.ToList(); Subset.AddRange(enumerable.ToList()); }
private static void subset_enum_test() //****************************************************************************80 // // Purpose: // // SUBSET_ENUM_TEST tests SUBSET_ENUM. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 27 November 2015 // // Author: // // John Burkardt // { int n; Console.WriteLine(""); Console.WriteLine("SUBSET_ENUM_TEST"); Console.WriteLine(" SUBSET_ENUM enumerates subsets of a set of N items."); Console.WriteLine(""); for (n = 0; n <= 10; n++) { int subset_num = Subset.subset_enum(n); Console.WriteLine(" " + n.ToString().PadLeft(2) + " " + subset_num.ToString().PadLeft(6) + ""); } }
async Task Init(IQueryable <T> superset, int pageNumber, int pageSize) { if (pageNumber < 1) { throw new ArgumentOutOfRangeException("pageNumber", pageNumber, "PageNumber cannot be below 1."); } if (pageSize < 1) { throw new ArgumentOutOfRangeException("pageSize", pageSize, "PageSize cannot be less than 1."); } TotalItemCount = superset == null ? 0 : await superset.CountAsync(); PageSize = pageSize; PageNumber = pageNumber; PageCount = TotalItemCount > 0 ? (int)Math.Ceiling(TotalItemCount / (double)PageSize) : 0; HasPreviousPage = PageNumber > 1; HasNextPage = PageNumber < PageCount; IsFirstPage = PageNumber == 1; IsLastPage = PageNumber >= PageCount; FirstItemOnPage = (PageNumber - 1) * PageSize + 1; var num = FirstItemOnPage + PageSize - 1; LastItemOnPage = num > TotalItemCount ? TotalItemCount : num; if (superset == null || TotalItemCount <= 0) { return; } Subset.AddRange(pageNumber == 1 ? await superset.Skip(0).Take(pageSize).ToListAsync() : await superset.Skip((pageNumber - 1) * pageSize).Take(pageSize).ToListAsync()); }
public PagedList(IQueryable <T> superset, Expression <Func <T> > keySelector, int pageNumber, int pageSize) { if (pageNumber < 1) { throw new ArgumentOutOfRangeException(nameof(pageNumber)); } if (pageSize < 1) { throw new ArgumentOutOfRangeException(nameof(pageSize)); } // set source to blank list if superset is null to prevent exceptions TotalItemCount = superset == null ? 0 : superset.Count(); PageSize = pageSize; PageNumber = pageNumber; PageCount = TotalItemCount > 0 ? (int)Math.Ceiling(TotalItemCount / (double)PageSize) : 0; HasPreviousPage = PageNumber > 1; HasNextPage = PageNumber < PageCount; IsFirstPage = PageNumber == 1; IsLastPage = PageNumber >= PageCount; FirstItemOnPage = (PageNumber - 1) * PageSize + 1; var numberOfLastItemOnPage = FirstItemOnPage + PageSize - 1; LastItemOnPage = numberOfLastItemOnPage > TotalItemCount ? TotalItemCount : numberOfLastItemOnPage; // add items to internal list if (superset != null && TotalItemCount > 0) { Subset.AddRange(pageNumber == 1 ? superset.Take(pageSize).ToList() : superset.Skip((pageNumber - 1) * pageSize).Take(pageSize).ToList()); } }
private void RuleInfoGUI() { if (m_SelectionState.Rule == null) { return; } if (m_SelectionState.Rule.Conditions == null) { m_TargetState.UndoTarget.MarkDirty("Initialized Conditions"); m_SelectionState.Rule.Conditions = new RSConditionData[0]; } if (m_SelectionState.Rule.Actions == null) { m_TargetState.UndoTarget.MarkDirty("Initialized Actions"); m_SelectionState.Rule.Actions = new RSActionData[0]; } RuleGUILayout.RuleData(m_TargetState.UndoTarget, m_SelectionState.Rule, m_SelectionState.Table, GetBaseFlags(), m_Context); EditorGUILayout.Separator(); m_ScrollState.RuleScroll = GUILayout.BeginScrollView(m_ScrollState.RuleScroll, false, false); { EditorGUILayout.LabelField(Content.RuleConditionListLabel, RSGUIStyles.SubHeaderStyle); if (m_ConditionList == null) { ConfigureConditionList(m_SelectionState.Rule, ref m_ConditionList); } m_ConditionList.array = m_SelectionState.Rule.Conditions; m_ConditionList.DoLayout(); using (new EditorGUI.DisabledScope(m_SelectionState.Rule.Conditions.Length == 0)) { Subset currentSubset = m_SelectionState.Rule.ConditionSubset; Subset nextSubset = (Subset)EditorGUILayout.EnumPopup(Content.RuleConditionSubsetLabel, currentSubset); if (currentSubset != nextSubset) { m_TargetState.UndoTarget.MarkDirty("Changed Rule Conditions Subset"); m_SelectionState.Rule.ConditionSubset = nextSubset; } } EditorGUILayout.Separator(); EditorGUILayout.LabelField(Content.RuleActionListLabel, EditorStyles.boldLabel); if (m_ActionList == null) { ConfigureActionList(m_SelectionState.Rule, ref m_ActionList); } m_ActionList.array = m_SelectionState.Rule.Actions; m_ActionList.DoLayout(); } GUILayout.EndScrollView(); }
public void OverallTest() { var set = new Subset <int>(new[] { 0, 1, 2, 4 }); var subset = new Subset <int>(set, new[] { 3 }); Contract.Assert(subset.Count == 1); Contract.Assert(subset[0] == 4); }
public CLabelFeatureDataSubset(CLabelFeatureData labelFeatureData, Subset subset) : base(labelFeatureData) { this.cSubSet = 0; this.mapTbl = new int[labelFeatureData.NumDataPoint]; for (int i = 0; i < labelFeatureData.NumDataPoint; i++) { if (subset.Keep(i)) { this.mapTbl[this.cSubSet++] = i; } } }
void LoadFromOBJFile(string filename) { var file = new StreamReader(filename); var directory = Path.GetDirectoryName(filename); var positions = new List<Vector4>(); var textureCoords = new List<Vector2>(); var normals = new List<Vector3>(); Subset subset = null; while (true) { string nextLine = file.ReadLine(); if (nextLine == null) // end of file break; var terms = nextLine.Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries); if (terms.Length == 0) // empty line continue; var command = terms[0]; if (command == "#" || command == "") { // comment } else if (command == "v") // position { float x = float.Parse(terms[1]); float y = float.Parse(terms[2]); float z = float.Parse(terms[3]); positions.Add(new Vector4(x, y, z, 1)); } else if (command == "vt") // texture coord { float u = float.Parse(terms[1]); float v = float.Parse(terms[2]); textureCoords.Add(new Vector2(u, v)); } else if (command == "vn") // normal { float x = float.Parse(terms[1]); float y = float.Parse(terms[2]); float z = float.Parse(terms[3]); normals.Add(new Vector3(x, y, z)); } else if (command == "f") // face { for (int i = 0; i < 3; i++) { // TODO: suppoprt relative (negative) indices var indices = terms[1 + i].Split('/'); var vertex = new VertexPositionNormalTexture(); vertex.position = positions[int.Parse(indices[0]) - 1]; // OBJ indices are 1-based if (indices[1] != "") // optional texture coords vertex.texture = textureCoords[int.Parse(indices[1]) - 1]; if (indices[2] != "") // optional normal vertex.normal = normals[int.Parse(indices[2]) - 1]; vertices.Add(vertex); subset.length++; } } else if (command == "mtllib") // .mtl file reference { LoadMTLFile(directory + "/" + terms[1]); } else if (command == "usemtl") // material { var name = terms[1]; Material material = null; if (materials.ContainsKey(name)) material = materials[name]; else { material = new Material(); materials.Add(name, material); } subset = new Subset(); subset.material = material; subset.start = vertices.Count; // next vertex to be created subsets.Add(subset); } else { // unimplemented or unrecognized command } } file.Close(); }
public void GetSubsets() { int i = 0; while(i < subsetCount) { //Debug.Log("Subset [" + i + "]"); Subset sub = new Subset(); sub.offset = FTell(); sub.useFloat = useFloat; subset.Add(sub); sub.Start(); size += sub.size; i++; } }