public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env) { // 実引数取得 SequenceData anotherSequence = (args[0] as SequenceSingleSelectParameter).Value; bool appendTitle = ((BooleanParameter)args[1]).Value; // ラベル化 ICSLabelSequence one = env.SelectedSequence.GetLabelSequence(); ICSLabelSequence another = anotherSequence.GetLabelSequence(); if (appendTitle) { // タイトル付与 foreach (var label in one.EnumerateLabels().ToList()) { one.SetLabel(label.BeginTime, label.EndTime, env.SelectedSequence.Title + "-" + label.LabelText); } } // 他方のラベルを追加 foreach (var label in another.EnumerateLabels()) { if (appendTitle) { one.SetLabel(label.BeginTime, label.EndTime, anotherSequence.Title + "-" + label.LabelText, true); } else { one.SetLabel(label, true); } } // SequenceDataとして返す return(SequenceData.FromLabelSequence(one, env.SelectedSequence.Title + "-merge-" + anotherSequence.Title)); }
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env) { LabelReplaceParameter replace = args[0] as LabelReplaceParameter; env.SelectedSequence.Borders.ReplaceBorderName(replace.Value); return(null); }
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env) { var glue = ((StringParameter)args[0]).Value; var type = ((SingleSelectParameter)args[1]).Value; var skip = ((BooleanParameter)args[2]).Value; var labelSequence = env.SelectedSequence.GetLabelSequence(); ICSLabelSequence ret = new ICSLabelSequence(); ICSLabel prev = null; foreach (var label in labelSequence.EnumerateLabels()) { if (skip && label.IsEmptyLabel) { continue; } string name = label.LabelText; if (prev != null) { name = prev.LabelText + glue + label.LabelText; } if (prev != null || type == 0) { if (type == 0) { ret.SetLabel(label.BeginTime, label.EndTime, name); } else { ret.SetLabel(prev.BeginTime, prev.EndTime, name); } } prev = label; } return(SequenceData.FromLabelSequence(ret, PathEx.GiveName("AppendPrev", env.SelectedSequence.Title))); }
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env) { TimeSeriesValues values = new TimeSeriesValues(env.SelectedSequence.Values.ColumnNames); foreach (var pair in env.SelectedSequence.Values.Enumerate()) { decimal?[] tmp = new decimal?[env.SelectedSequence.Values.ColumnCount]; if (pair.Value.All(x => x.HasValue)) { try { decimal sum = pair.Value.Sum(x => x.Value); if (sum != 0) { for (int i = 0; i < tmp.Length; i++) { tmp[i] = pair.Value[i].Value / sum; } } } catch (OverflowException) { tmp = new decimal?[env.SelectedSequence.Values.ColumnCount]; } } values.SetValue(pair.Key, tmp); } SequenceData ret = new SequenceData(values, null, PathEx.GiveName("Normal", env.SelectedSequence.Title)); ret.Type = SequenceType.Numeric; return(ret); }
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env) { NumberParameter offset = args[0] as NumberParameter; NumberParameter scale = args[1] as NumberParameter; SingleSelectParameter mode = args[2] as SingleSelectParameter; bool offsetFirst = mode.Value == 0; TimeSeriesValues ret = new TimeSeriesValues(env.SelectedSequence.Values.ColumnNames); foreach (var pair in env.SelectedSequence.Values.Enumerate()) { decimal?[] row = new decimal?[pair.Value.Length]; for (int i = 0; i < row.Length; i++) { decimal?tmp = pair.Value[i]; if (tmp.HasValue) { if (offsetFirst) { tmp = tmp.Value + offset.Value; } tmp = tmp.Value * scale.Value; if (!offsetFirst) { tmp = tmp.Value + offset.Value; } } row[i] = tmp; } ret[pair.Key] = row; } return(new SequenceData(ret, null, PathEx.GiveName("OffsetScale", env.SelectedSequence.Title))); }
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env) { var labelSequence = env.SelectedSequence.GetLabelSequence(); var labels = (args[0] as LabelSelectParameter).Value; var beforeStart = (args[1] as NumberParameter).Value; var afterStart = (args[2] as NumberParameter).Value; var beforeEnd = (args[3] as NumberParameter).Value; var afterEnd = (args[4] as NumberParameter).Value; ICSLabelSequence tmp = new ICSLabelSequence(); foreach (var label in labelSequence.EnumerateLabels()) { if (labels.Contains(label.LabelText)) { decimal preStart = label.BeginTime - beforeStart; decimal postStart = label.BeginTime + afterStart; if (postStart > preStart) { tmp.SetLabel(preStart, postStart, label.LabelText + "_begin"); } decimal preEnd = label.EndTime - beforeEnd; decimal postEnd = label.EndTime + afterEnd; if (postEnd > preEnd) { tmp.SetLabel(preEnd, postEnd, label.LabelText + "_end"); } } } return(SequenceData.FromLabelSequence(tmp, PathEx.GiveName("Boundary", env.SelectedSequence.Title), null)); }
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env) { SequenceMultiSelectParameter others = args[0] as SequenceMultiSelectParameter; List <TimeSeriesValues> sequences = new List <TimeSeriesValues>(); sequences.Add(env.SelectedSequence.Values); sequences.AddRange(others.Value.Select(d => d.Values)); List <string> columnNames = new List <string>(); int sequenceIndex = 0; foreach (TimeSeriesValues sequence in sequences) { sequenceIndex++; foreach (string name in sequence.ColumnNames) { columnNames.Add(string.Format("{0}.{1}", sequenceIndex, name)); } } TimeSeriesValues values = new TimeSeriesValues(columnNames); foreach (var pair in TimeSeriesValuesCalculation.EnumerateCompositeSequences(sequences)) { values[pair.Key] = pair.Value; } return(new SequenceData(values, null, PathEx.GiveName("Composite", new string[] { env.SelectedSequence.Title }.Union(others.Value.Select(d => d.Title))))); }
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env) { var cond = args[0] as SingleSelectParameter; var operand = args[1] as SequenceMultiSelectParameter; List <SequenceData> targets = new List <SequenceData>(); targets.Add(env.SelectedSequence); foreach (var sequence in operand.Value) { if (sequence != env.SelectedSequence) { targets.Add(sequence); } } Func <decimal?[], int> condFunc = (x) => - 1; string opName = ""; switch (cond.Value) { case 0: condFunc = (x) => { if (!x.Any(v => v.HasValue)) { return(-1); } return(x.Select((v, i) => new KeyValuePair <int, decimal?>(i, v)).Aggregate((a, b) => (!a.Value.HasValue ? b : !b.Value.HasValue ? a : a.Value.Value > b.Value.Value ? a : b)).Key); }; opName = "Greatest"; break; case 1: condFunc = (x) => { if (!x.Any(v => v.HasValue)) { return(-1); } return(x.Select((v, i) => new KeyValuePair <int, decimal?>(i, v)).Aggregate((a, b) => (!a.Value.HasValue ? b : !b.Value.HasValue ? a : a.Value.Value < b.Value.Value ? a : b)).Key); }; opName = "Least"; break; case 2: condFunc = (x) => { for (int i = 0; i < x.Length; i++) { if (x[i].HasValue) { return(i); } } return(-1); }; opName = "NotEmpty"; break; } var labels = ToLabelByCondition(targets, condFunc); return(SequenceData.FromLabelSequence(labels, PathEx.GiveName(opName, targets.Select(p => p.Title)))); }
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env) { decimal hz = ((NumberParameter)args[0]).Value; SequenceData ret = new SequenceData(TimeSeriesValuesCalculation.GetResampled(env.SelectedSequence.Values, 1M / hz), new LabelingBorders(env.SelectedSequence.Borders), PathEx.GiveName("Resampled", env.SelectedSequence.Title, hz.ToString())); ret.Type = SequenceType.Numeric; return(ret); }
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env) { var border = ((LabelSelectParameter)args[0]).Value; var left = ((NumberParameter)args[1]).Value; var right = ((NumberParameter)args[2]).Value; var percent = ((BooleanParameter)args[3]).Value; var withEmpty = ((BooleanParameter)args[4]).Value; ICSLabelSequence current = env.SelectedSequence.GetLabelSequence(); ICSLabelSequence ret = env.SelectedSequence.GetLabelSequence(); var currentLabels = current.EnumerateLabels().ToList(); for (int i = 0; i < currentLabels.Count; i++) { if (border.Contains(currentLabels[i].LabelText)) { decimal begin, end; if (percent) { begin = currentLabels[i].BeginTime - left * currentLabels[i].Duration / 100; end = currentLabels[i].EndTime + right * currentLabels[i].Duration / 100; } else { begin = currentLabels[i].BeginTime - left; end = currentLabels[i].EndTime + right; } if (begin > end) { begin += (end - begin) / 2; end = begin; } if (begin < end) { ret.SetLabel(begin, end, currentLabels[i].LabelText); } if (begin > currentLabels[i].BeginTime) { string prev = ""; if (i > 0 && !withEmpty) { prev = currentLabels[i - 1].LabelText; } ret.SetLabel(currentLabels[i].BeginTime, begin, prev); } if (end < currentLabels[i].EndTime) { string post = ""; if (i < currentLabels.Count - 1 && !withEmpty) { post = currentLabels[i + 1].LabelText; } ret.SetLabel(end, currentLabels[i].EndTime, post); } } } return(SequenceData.FromLabelSequence(ret, PathEx.GiveName("extend", env.SelectedSequence.Title))); }
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env) { var sequence = TimeSeriesValuesCalculation.Differentiate(env.SelectedSequence.Values); sequence.SetColumnNames(env.SelectedSequence.Values.ColumnNames.Select(n => "Diff " + n)); SequenceData ret = new SequenceData(sequence, null, PathEx.GiveName("Diff", env.SelectedSequence.Title)); ret.Type = SequenceType.Numeric; return(ret); }
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env) { var sequence = TimeSeriesValuesCalculation.AbsoluteLength(env.SelectedSequence.Values); sequence.ColumnNames[0] = "Abs Value"; SequenceData ret = new SequenceData(sequence, null, PathEx.GiveName("Abs", env.SelectedSequence.Title)); ret.Type = SequenceType.Numeric; return(ret); }
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env) { var keepEmpty = args[0] as BooleanParameter; var sequence = TimeSeriesValuesCalculation.AverageFlat(env.SelectedSequence.Values, keepEmpty.Value); sequence.SetColumnNames(env.SelectedSequence.Values.ColumnNames.Select(n => "Avg " + n)); SequenceData ret = new SequenceData(sequence, null, PathEx.GiveName("Average", env.SelectedSequence.Title)); ret.Type = SequenceType.Numeric; return(ret); }
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env) { var timeBefore = ((NumberParameter)args[0]).Value; var timeAfter = ((NumberParameter)args[1]).Value; var exclude = ((NumberParameter)args[2]).Value; var sequence = TimeSeriesValuesCalculation.TimeSmooth(env.SelectedSequence.Values, timeBefore + timeAfter, -timeAfter, exclude); SequenceData ret = new SequenceData(sequence, new LabelingBorders(env.SelectedSequence.Borders), PathEx.GiveName("Smooth", env.SelectedSequence.Title)); ret.Type = SequenceType.Numeric; return(ret); }
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env) { var stddev = ((NumberParameter)args[0]).Value; var details = (int)((NumberParameter)args[1]).Value; var exclude = ((NumberParameter)args[2]).Value; var sequence = TimeSeriesValuesCalculation.Gaussian(env.SelectedSequence.Values, stddev, details, exclude); sequence.SetColumnNames(env.SelectedSequence.Values.ColumnNames.Select(n => "Gauss " + n).ToArray()); SequenceData ret = new SequenceData(sequence, new LabelingBorders(env.SelectedSequence.Borders), PathEx.GiveName("Gaussian", env.SelectedSequence.Title, stddev.ToString())); ret.Type = SequenceType.Numeric; return(ret); }
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env) { SequenceColumnSelectParameter column = args[0] as SequenceColumnSelectParameter; int tmp = env.SelectedSequence.Borders.TargetColumnIndex; env.SelectedSequence.Borders.TargetColumnIndex = column.Value; ICSLabelSequence labelSeq = env.SelectedSequence.GetLabelSequence(); if (tmp != column.Value) { env.SelectedSequence.Borders.TargetColumnIndex = tmp; } return(SequenceData.FromLabelSequence(labelSeq, PathEx.GiveName("LabelOf", env.SelectedSequence.Title))); }
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env) { SequenceColumnMultiSelectParameter si = args[0] as SequenceColumnMultiSelectParameter; List <int> indices = si.Value.Where(i => 0 <= i && i < env.SelectedSequence.Values.ColumnNames.Length).ToList(); TimeSeriesValues val = new TimeSeriesValues(indices.Select(i => env.SelectedSequence.Values.ColumnNames[i])); foreach (var pair in env.SelectedSequence.Values.Enumerate()) { val.SetValue(pair.Key, indices.Select(i => pair.Value[i]).ToArray()); } SequenceData ret = new SequenceData(val, new LabelingBorders(env.SelectedSequence.Borders), PathEx.GiveName("Extracted", env.SelectedSequence.Title)); ret.Type = SequenceType.Numeric; return(ret); }
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env) { var rows = ((SequenceMultiSelectParameter)args[0]).Value; var others = rows.Select(p => p.GetLabelSequence()).ToList(); var sep = (StringParameter)args[1]; var multi = (BooleanParameter)args[2]; var useEmpty = (BooleanParameter)args[3]; if (others.Count == 0) { return(null); } var current = env.SelectedSequence.GetLabelSequence(); var ret = new ICSLabelSequence(); foreach (var label in current.EnumerateLabels()) { if (label.LabelText == "" && !useEmpty.Value) { continue; } var clips = others.Select(r => r.ClipLabelsBetween(label.BeginTime, label.EndTime, ICSLabelSequence.ClipLabelsMode.CutBorder)); string name = label.LabelText; foreach (var clip in clips) { var texts = clip.Where(c => useEmpty.Value || c.LabelText != "").ToList(); if (multi.Value) { foreach (var text in texts) { name += sep.Value + text.LabelText; } } else { if (texts.Count > 0) { name += sep.Value + texts[0].LabelText; } } ret.SetLabel(label.ChangeText(name)); } } return(SequenceData.FromLabelSequence(ret, PathEx.GiveName("ContainsProduct", new string[] { env.SelectedSequence.Title }.Union(rows.Select(p => p.Title))))); }
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env) { var operand = (args[0] as SequenceSingleSelectParameter).Value; var sameOnly = ((BooleanParameter)args[1]).Value; var one = env.SelectedSequence.GetLabelSequence(); var another = operand.GetLabelSequence(); var l1 = one.EnumerateLabels().GetEnumerator(); var l2 = another.EnumerateLabels().GetEnumerator(); if (!(l1.MoveNext() && l2.MoveNext())) { return(null); } ICSLabelSequence tmp = new ICSLabelSequence(); while (true) { // (not A) or B === A => B if ((!sameOnly || l1.Current.LabelText == l2.Current.LabelText) && !l1.Current.IsEmptyLabel && !l2.Current.IsEmptyLabel) { decimal begin = Math.Max(l1.Current.BeginTime, l2.Current.BeginTime); decimal end = Math.Min(l1.Current.EndTime, l2.Current.EndTime); if (end > begin) { tmp.SetLabel(begin, end, l1.Current.LabelText); } } if (l1.Current.EndTime < l2.Current.EndTime) { if (!l1.MoveNext()) { break; } } else { if (!l2.MoveNext()) { break; } } } return(SequenceData.FromLabelSequence(tmp, env.SelectedSequence.Title + "-intersect-" + operand.Title)); }
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env) { var labels = ((LabelSelectParameter)args[0]); SequenceData ret = new SequenceData(new TimeSeriesValues(env.SelectedSequence.Values), new LabelingBorders(env.SelectedSequence.Borders), PathEx.GiveName("extract", env.SelectedSequence.Title)); ret.Type = SequenceType.Label; if (!labels.Value.Contains(ret.Borders.DefaultName)) { env.SelectedSequence.Borders.DefaultName = ""; } foreach (var pair in ret.Borders.Enumerate().ToList()) { if (!labels.Value.Contains(pair.Value)) { ret.Borders.SetBorder(pair.Key, ""); } } return(ret); }
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env) { var another = ((SequenceSingleSelectParameter)args[0]).Value; var labels = ((LabelSelectParameter)args[1]).Value; var row = another.GetLabelSequence(); var current = env.SelectedSequence.GetLabelSequence(); var ret = new ICSLabelSequence(); var l1 = current.EnumerateLabels().GetEnumerator(); var l2 = row.EnumerateLabels().GetEnumerator(); if (l1.MoveNext() && l2.MoveNext()) { while (true) { if (labels.Contains(l2.Current.LabelText)) { var begin1 = l1.Current.BeginTime <= l2.Current.BeginTime && l2.Current.BeginTime < l1.Current.EndTime; var end1 = l1.Current.BeginTime <= l2.Current.EndTime && l2.Current.EndTime < l1.Current.EndTime; var begin2 = l2.Current.BeginTime <= l1.Current.BeginTime && l1.Current.BeginTime < l2.Current.EndTime; var end2 = l2.Current.BeginTime <= l1.Current.EndTime && l1.Current.EndTime < l2.Current.EndTime; if (begin1 || end1 || begin2 || end2) { ret.SetLabel(l1.Current); } } if (l1.Current.EndTime < l2.Current.EndTime) { if (!l1.MoveNext()) { break; } } else { if (!l2.MoveNext()) { break; } } } } return(SequenceData.FromLabelSequence(ret, PathEx.GiveName("Contains", env.SelectedSequence.Title, another.Title))); }
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env) { SequenceSingleSelectParameter operand = args[0] as SequenceSingleSelectParameter; TimeSeriesValues ret = new TimeSeriesValues("InnerProduct"); int count = Math.Min(env.SelectedSequence.Values.ColumnCount, operand.Value.Values.ColumnCount); using (IEnumerator <KeyValuePair <decimal, decimal?[]> > one = env.SelectedSequence.Values.Enumerate().GetEnumerator()) using (IEnumerator <KeyValuePair <decimal, decimal?[]> > another = operand.Value.Values.Enumerate().GetEnumerator()) { bool oneAlive = one.MoveNext(); bool anotherAlive = another.MoveNext(); while (oneAlive && anotherAlive) { decimal?value = 0; for (int i = 0; i < count; i++) { if (one.Current.Value[i].HasValue && another.Current.Value[i].HasValue) { value = value.Value + one.Current.Value[i].Value * another.Current.Value[i].Value; } else { value = null; break; } } // 後にある時刻のところに値を入れる // 前にある方を進める if (one.Current.Key < another.Current.Key) { ret.SetValue(another.Current.Key, value); oneAlive = one.MoveNext(); } else { ret.SetValue(one.Current.Key, value); anotherAlive = another.MoveNext(); } } } return(new SequenceData(ret, null, PathEx.GiveName("InnerProduct", env.SelectedSequence.Title, operand.Value.Title))); }
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env) { var operand = args[0] as SequenceMultiSelectParameter; var sep = args[1] as StringParameter; var useEmpty = args[2] as BooleanParameter; List <SequenceData> sequences = new List <SequenceData>(); sequences.Add(env.SelectedSequence); sequences.AddRange(operand.Value); ICSLabelSequence ret = new ICSLabelSequence(); var timeList = TimeSeriesValuesCalculation.MergeTimeList(sequences.Select(p => p.Values)).ToList(); if (timeList.Count != 0) { var lastTime = timeList.Last(); foreach (var time in timeList) { if (time < lastTime) { StringBuilder tmp = new StringBuilder(); bool empty = true; foreach (var sequence in sequences) { var label = sequence.GetLabelAt(time); if (label != "" || useEmpty.Value) { if (!empty) { tmp.Append(sep.Value); } tmp.Append(label); empty = false; } } ret.SetLabel(time, lastTime, tmp.ToString()); } } } return(SequenceData.FromLabelSequence(ret, PathEx.GiveName("Product", sequences.Select(p => p.Title)))); }
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env) { var row = ((SequenceSingleSelectParameter)args[0]).Value; var labels = ((LabelSelectParameter)args[1]).Value; TimeSeriesValues newSeq = new TimeSeriesValues(env.SelectedSequence.Values.ColumnNames); foreach (var label in row.GetLabelSequence().EnumerateLabels()) { newSeq.SetValue(label.BeginTime, new decimal?[env.SelectedSequence.Values.ColumnCount]); newSeq.SetValue(label.EndTime, new decimal?[env.SelectedSequence.Values.ColumnCount]); } foreach (var pair in env.SelectedSequence.Values.Enumerate()) { if (labels.Contains(row.GetLabelAt(pair.Key))) { newSeq.SetValue(pair.Key, pair.Value); } } SequenceData ret = new SequenceData(newSeq, new LabelingBorders(env.SelectedSequence.Borders), PathEx.GiveName("ClipBy", new string[] { env.SelectedSequence.Title }.Union(labels))); ret.Type = SequenceType.Numeric; return(ret); }
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env) { ICSLabelSequence labelSequence = env.SelectedSequence.GetLabelSequence(); if (labelSequence == null) { MessageBox.Show("ラベルが空でした", this.GetType().ToString()); return(null); } if (env.Controller.WholeEndTime > 0) { labelSequence.SetLabel(0, env.Controller.WholeEndTime, "", true); } TimeSeriesValues sequence = new TimeSeriesValues("value"); Dictionary <string, int> indexInfo = new Dictionary <string, int>(); var labelTexts = labelSequence.GetLabelTexts(true); int count = 0; foreach (var labelText in labelTexts) { indexInfo[labelText] = count; count++; } sequence.SetValue(0, new decimal?[1]); sequence.SetValue(labelSequence.Duration, new decimal?[1]); foreach (var label in labelSequence.EnumerateLabels()) { var value = new decimal?[1] { indexInfo[label.LabelText] }; sequence.SetValue(label.BeginTime, value); } SequenceData ret = new SequenceData(sequence, null, PathEx.GiveName("labelNum", env.SelectedSequence.Title)); ret.Type = SequenceType.Numeric; return(ret); }
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env) { int check = ((SingleSelectParameter)args[0]).Value; ICSLabelSequence current = env.SelectedSequence.GetLabelSequence(); ICSLabelSequence ret = new ICSLabelSequence(); ICSLabel prev = null; foreach (var label in current.EnumerateLabels()) { switch (check) { case 0: if (label.IsEmptyLabel) { ret.SetLabel(label.BeginTime, label.EndTime, "On"); } break; case 1: if (label.IsEmptyLabel && prev != null) { ret.SetLabel(label.BeginTime, label.EndTime, prev.LabelText); } break; case 2: if (prev != null && prev.IsEmptyLabel) { ret.SetLabel(prev.BeginTime, prev.EndTime, label.LabelText); } break; } prev = label; } return(SequenceData.FromLabelSequence(ret, PathEx.GiveName("Empty-of", env.SelectedSequence.Title))); }
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env) { return(new SequenceData(env.SelectedSequence)); }
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env) { var mode = args[0] as SingleSelectParameter; var threshold = args[1] as NumberParameter; var correct = args[2] as SequenceSingleSelectParameter; var correctSequence = correct.Value; ICSLabelSequence ret = new ICSLabelSequence(); decimal correctCount = 0, obtainCount = 0, matchCount = 0; switch (mode.Value) { case 0: var common = TimeSeriesValuesCalculation.MergeTimeList(new[] { env.SelectedSequence.Values, correctSequence.Values }).ToList(); for (int i = 0; i < common.Count - 1; i++) { string o = env.SelectedSequence.GetLabelAt(common[i]); string c = correctSequence.GetLabelAt(common[i]); if (o == "" && c == "") { continue; } decimal interval = common[i + 1] - common[i]; if (o != "") { obtainCount += interval; } if (c != "") { correctCount += interval; } if (o == c) { matchCount += interval; } ret.SetLabel(common[i], common[i + 1], o == c ? "Match" : o == "" ? "False Negative" : c == "" ? "False Positive" : "Mismatch"); } break; case 1: case 2: SequenceData main, sub; if (mode.Value == 1) { main = correctSequence; sub = env.SelectedSequence; } else { main = env.SelectedSequence; sub = correctSequence; } var subLabel = sub.GetLabelSequence(); foreach (var label in main.GetLabelSequence().EnumerateLabels()) { decimal denom = label.Duration; if (label.LabelText != "") { var clip = subLabel.ClipLabelsBetween(label.BeginTime, label.EndTime, ICSLabelSequence.ClipLabelsMode.CutBorder); decimal numer = clip.Where(l => l.LabelText == label.LabelText).Select(l => l.Duration).Sum(); if (numer >= denom * threshold.Value) { matchCount++; ret.SetLabel(label.ChangeText("Match")); } else { ret.SetLabel(label.ChangeText(mode.Value == 1 ? "False Negative" : "False Positive")); } obtainCount++; correctCount++; } else { var clip = subLabel.ClipLabelsBetween(label.BeginTime, label.EndTime, ICSLabelSequence.ClipLabelsMode.CutBorder); var missClip = clip.Where(l => l.LabelText != "").ToList(); var missCount = missClip.Count; if (mode.Value == 1) { obtainCount += missCount; } else { correctCount += missCount; } foreach (var m in missClip) { ret.SetLabel(m.ChangeText(mode.Value == 1 ? "False Positive" : "False Negative")); } } } break; } return(SequenceData.FromLabelSequence(ret, PathEx.GiveName("PrecisionRecall", env.SelectedSequence.Title, correctSequence.Title))); }
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env) { env.SelectedSequence.Borders.RemoveBorderSameToPrevious(); return(null); }
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env) { var target = ((LabelSelectParameter)args[0]).Value; var length = ((NumberParameter)args[1]).Value; var action = ((SingleSelectParameter)args[2]).Value; var border = ((BooleanParameter)args[3]).Value; var glue = ((SingleSelectParameter)args[4]).Value; ICSLabelSequence ret = env.SelectedSequence.GetLabelSequence(); var names = ret.GetLabelTexts(); string tmpLabel = "tmpToRemove"; while (names.Contains(tmpLabel)) { tmpLabel += "-"; } foreach (var label in ret.EnumerateLabels().Where(l => target.Contains(l.LabelText)).ToList()) { if (action == 0) { if (label.Duration < length || (border && label.Duration == length)) { ret.SetLabel(label.BeginTime, label.EndTime, tmpLabel); } } else { if (label.Duration > length || (border && label.Duration == length)) { ret.SetLabel(label.BeginTime, label.EndTime, tmpLabel); } } } ret.RemoveBorderSameAsPrevious(); var labels = ret.EnumerateLabels().ToList(); for (int i = 0; i < labels.Count; i++) { if (labels[i].LabelText == tmpLabel) { string to = ""; switch (glue) { case 1: if (i > 0 && i < labels.Count - 1) { if (labels[i - 1].LabelText == labels[i + 1].LabelText) { to = labels[i - 1].LabelText; } } break; case 2: if (i > 0) { to = labels[i - 1].LabelText; } break; case 3: if (i < labels.Count - 1) { to = labels[i + 1].LabelText; } break; } ret.SetLabel(labels[i].BeginTime, labels[i].EndTime, to); } } ret.RemoveBorderSameAsPrevious(); return(SequenceData.FromLabelSequence(ret, PathEx.GiveName("Filtered", env.SelectedSequence.Title, (action == 0 ? "Lt" : "Gt") + length.ToString()))); }