/// <summary>
/// Adds and a single new peak filter.
/// </summary>
internal void AddPeakFilter(PeakFilter toAdd)
{
List <PeakFilter> existing = new List <PeakFilter>(this.PeakFilters);
existing.Add(toAdd);
this.SetPeakFilters(existing.ToArray());
}
/// <summary>
/// Constructor.
/// </summary>
public ArgsClusterer(string id, IMatrixProvider source, PeakFilter sigFilter, ConfigurationMetric distance, ObsFilter atypes, bool splitGroups, EClustererStatistics suppressMetric, object[] parameters, string clusterNamePrefix)
: base(id, source, parameters)
{
this.PeakFilter = sigFilter;
this.Distance = distance;
this.ObsFilter = atypes;
this.SplitGroups = splitGroups;
this.Statistics = suppressMetric;
this.OverrideShortName = clusterNamePrefix;
}
void setFilter_Click(object sender, EventArgs e)
{
object tag = (((ToolStripMenuItem)sender).Tag);
if (tag is ObsFilter)
{
this._obsFilter = (ObsFilter)tag;
}
else
{
this._peakFilter = (PeakFilter)tag;
}
this.UpdateScores();
}
/// <summary>
///
/// </summary>
public GraphicEqualizerSettings()
{
var sampleRate = Program.CurrentSamplingRate;
double defaultGain = 0;
gain31HzFilter = new PeakFilter(sampleRate, 31, f_BandWidth31Hz, defaultGain);
gain62HzFilter = new PeakFilter(sampleRate, 62, f_BandWidth62Hz, defaultGain);
gain125HzFilter = new PeakFilter(sampleRate, 125, f_BandWidth125Hz, defaultGain);
gain250HzFilter = new PeakFilter(sampleRate, 250, f_BandWidth250Hz, defaultGain);
gain500HzFilter = new PeakFilter(sampleRate, 500, f_BandWidth500Hz, defaultGain);
gain1000HzFilter = new PeakFilter(sampleRate, 1000, f_BandWidth1000Hz, defaultGain);
gain2000HzFilter = new PeakFilter(sampleRate, 2000, f_BandWidth2000Hz, defaultGain);
gain4000HzFilter = new PeakFilter(sampleRate, 4000, f_BandWidth4000Hz, defaultGain);
gain8000HzFilter = new PeakFilter(sampleRate, 8000, f_BandWidth8000Hz, defaultGain);
gain16000HzFilter = new PeakFilter(sampleRate, 16000, f_BandWidth16000Hz, defaultGain);
}
/// <summary>
/// Initializes a new instance of the <see cref="EqualizerChannelFilter" /> class.
/// </summary>
/// <param name="sampleRate">The sampleRate of the audio data to process.</param>
/// <param name="centerFrequency">The center frequency to adjust.</param>
/// <param name="bandWidth">The bandWidth.</param>
/// <param name="gain">The gain value in dB.</param>
public EqualizerChannelFilter(int sampleRate, double centerFrequency, double bandWidth, double gain)
{
if (sampleRate <= 0)
{
throw new ArgumentOutOfRangeException("sampleRate");
}
if (centerFrequency <= 0)
{
throw new ArgumentOutOfRangeException("centerFrequency");
}
if (bandWidth <= 0)
{
throw new ArgumentOutOfRangeException("bandWidth");
}
_biQuadFilter = new PeakFilter(sampleRate, centerFrequency, bandWidth, gain);
}
private FrmPca(Core core, FrmMain frmMain)
{
this.InitializeComponent();
UiControls.SetIcon(this);
UiControls.ColourMenuButtons(this.toolStrip1);
this._frmMain = frmMain;
this._core = core;
this._peakFilter = PeakFilter.Empty;
this._obsFilter = ObsFilter.Empty;
this._selectedCorrection = core.Options.SelectedMatrixProvider;
this._colourBy._colourByPeak = ColumnManager.GetColumns <Peak>(this._core).First(z => z.Id == Peak.ID_COLUMN_CLUSTERCOMBINATION);
this._colourBy._colourByObervation = ColumnManager.GetColumns <ObservationInfo>(this._core).First(z => z.Id == nameof(ObservationInfo.Group));
this._regressAgainst._colourByPeak = this._colourBy._colourByPeak;
this._regressAgainst._colourByObervation = this._colourBy._colourByObervation;
this._chart.AddControls(this.toolStripDropDownButton1);
this._chart.Style.LegendDisplay = ELegendDisplay.Visible;
this.UpdateScores();
}
/// <summary>
/// All the filters for a particular peak filter
/// </summary>
public static DataSet <PeakFilter.Condition> ForPeakFilterConditions(Core core, PeakFilter of)
{
return(new DataSet <PeakFilter.Condition>()
{
Core = core,
ListTitle = "Peak filter conditions",
ListSource = of != null?of.Conditions.Cast <PeakFilter.Condition>() : new PeakFilter.Condition[0],
HandleEdit = z => FrmEditPeakFilterCondition.Show(z.Owner, core, z.DefaultValue, z.ReadOnly),
ListSupportsReorder = true,
Icon = Resources.ListIconFilter,
});
}
public ResultClusterer ExecuteAlgorithm(Core core, int isPreview, bool doNotCluster, ArgsClusterer args, ConfigurationClusterer tag, ProgressReporter prog, out IntensityMatrix vmatrixOut, out DistanceMatrix dmatrixOut)
{
IReadOnlyList <Peak> peaks;
if (isPreview > 0 && isPreview < core.Peaks.Count)
{
List <Peak> p = core.Peaks.ToList();
p.Shuffle();
p = p.GetRange(0, Math.Min(isPreview, p.Count)).ToList();
// Make sure any seed peaks are in the list
foreach (Peak peak in tag.Args.Parameters.OfType <WeakReference <Peak> >().Select(par => (par).GetTargetOrThrow()))
{
p.Insert(0, peak);
p.RemoveAt(p.Count - 1);
}
peaks = p;
}
else
{
peaks = core.Peaks;
}
// FILTER PEAKS
PeakFilter pfilter = args.PeakFilter ?? PeakFilter.Empty;
IntensityMatrix src = args.SourceMatrix;
Filter <Peak> .Results filter = pfilter.Test(peaks);
Cluster insigs;
if (filter.Failed.Count == 0)
{
insigs = null;
}
else
{
insigs = new Cluster("Insig", tag);
insigs.States |= Session.Main.Cluster.EStates.Insignificants;
// We still need the vmatrix for plotting later
IntensityMatrix operational = src.Subset(args.PeakFilter, args.ObsFilter, ESubsetFlags.InvertPeakFilter);
if (args.SplitGroups)
{
operational = operational.SplitGroups();
}
for (int index = 0; index < operational.NumRows; index++)
{
Vector p = new Vector(operational, index);
insigs.Assignments.Add(new Assignment(p, insigs, double.NaN));
}
}
// CREATE VMATRIX AND FILTER OBSERVATIONS
PeakFilter temp = new PeakFilter("filtered in", null, new[] { new PeakFilter.ConditionPeak(Filter.ELogicOperator.And, false, filter.Failed, Filter.EElementOperator.IsNot) });
IntensityMatrix vmatrix = src.Subset(args.PeakFilter, args.ObsFilter, ESubsetFlags.None);
if (args.SplitGroups)
{
vmatrix = vmatrix.SplitGroups();
}
prog.Enter("Creating distance matrix");
DistanceMatrix dmatrix = RequiresDistanceMatrix ? DistanceMatrix.Create(core, vmatrix, args.Distance, prog) : null;
prog.Leave();
IEnumerable <Cluster> clusters;
if (doNotCluster)
{
vmatrixOut = vmatrix;
dmatrixOut = dmatrix;
return(null);
}
// CLUSTER USING VMATRIX OR DMATRIX
prog.Enter("Clustering");
clusters = Cluster(vmatrix, dmatrix, args, tag, prog);
prog.Leave();
vmatrixOut = vmatrix;
dmatrixOut = dmatrix;
List <Cluster> result = new List <Cluster>();
if (insigs != null)
{
result.Add(insigs);
}
result.AddRange(clusters);
return(new ResultClusterer(result));
}
private PeakFilter.Condition GetSelection(out string error)
{
if (!this._radAnd.Checked && !this._radOr.Checked)
{
error = "Select AND or OR";
return(null);
}
PeakFilter.ELogicOperator op = this._radAnd.Checked ? PeakFilter.ELogicOperator.And : PeakFilter.ELogicOperator.Or;
bool negate = this.checkBox1.Checked;
if (this._chkIsInCluster.Checked)
{
var sel = this._cbClusters.GetSelectionOrNull();
if (sel == null)
{
error = "Select one or more clusters";
return(null);
}
var en = this._lsoPats.SelectedItem;
if (!en.HasValue)
{
error = "Select the cluster set operator";
return(null);
}
error = null;
return(new PeakFilter.ConditionCluster(op, negate, en.Value, sel));
}
else if (this._chkIsInSet.Checked)
{
var sel = this._cbPeaks.GetSelectionOrNull();
if (sel == null)
{
error = "Select one or more PEAKs";
return(null);
}
var en = this._lsoPeaks.SelectedItem;
if (!en.HasValue)
{
error = "Select the PEAK element operator";
return(null);
}
error = null;
return(new PeakFilter.ConditionPeak(op, negate, sel, en.Value));
}
else if (this._chkIsFlaggedWith.Checked)
{
var sel = this._cbFlags.GetSelectionOrNull();
if (sel == null)
{
error = "Select one or more FLAGs";
return(null);
}
var en = this._lsoFlags.SelectedItem;
if (!en.HasValue)
{
error = "Select the FLAG set operator";
return(null);
}
error = null;
return(new PeakFilter.ConditionFlags(op, negate, en.Value, sel));
}
else if (this._chkIsStatistic.Checked)
{
var sel = (ConfigurationStatistic)this._lstIsStatistic.SelectedItem;
if (sel == null)
{
error = "Select the STATISTIC";
return(null);
}
var en = this._lsoStats.SelectedItem;
if (!en.HasValue)
{
error = "Select the STATISTIC operator";
return(null);
}
double va;
if (!double.TryParse(this._txtStatisticValue.Text, out va))
{
error = "Enter a valid value to compare against";
return(null);
}
error = null;
return(new PeakFilter.ConditionStatistic(op, negate, en.Value, sel, va));
}
else if (this._radFilter.Checked)
{
if (!this._ecbFilter.HasSelection)
{
error = "Select the FILTER";
return(null);
}
PeakFilter sel = this._ecbFilter.SelectedItem;
var en = this._lsoFilter.SelectedItem;
if (!en.HasValue)
{
error = "Select the FILTER operator";
return(null);
}
error = null;
return(new PeakFilter.ConditionFilter(op, negate, sel, en.Value == Filter.EElementOperator.Is));
}
else
{
error = "Select a comparison";
return(null);
}
}
private void _btnMarkAsOutlier_Click(object sender, EventArgs e)
{
object item = this._chart.SelectedItem.DataPoint.Tag;
ObservationInfo observationInfo = item as ObservationInfo;
Peak peak = item as Peak;
bool safeToReplace = false;
if (peak != null)
{
List <PeakFilter.Condition> filters = new List <PeakFilter.Condition>(this._peakFilter.Conditions.Cast <PeakFilter.Condition>());
bool needsNewFilter = true;
foreach (PeakFilter.Condition filter in filters)
{
PeakFilter.ConditionPeak klalkq = filter as PeakFilter.ConditionPeak;
if (klalkq != null &&
klalkq.CombiningOperator == Filter.ELogicOperator.And &&
klalkq.Negate == false &&
klalkq.PeaksOp == Filter.EElementOperator.IsNot)
{
needsNewFilter = false;
List <Peak> strong;
if (!klalkq.Peaks.TryGetStrong(out strong))
{
FrmMsgBox.ShowError(this, "Couldn't modify current filter because it contains expired data.");
return;
}
filters.Remove(klalkq);
filters.Add(new PeakFilter.ConditionPeak(Filter.ELogicOperator.And, false, strong.ConcatSingle(peak), Filter.EElementOperator.IsNot));
safeToReplace = filters.Count == 1;
break;
}
}
if (needsNewFilter)
{
filters.Add(new PeakFilter.ConditionPeak(Filter.ELogicOperator.And, false, new[] { peak }, Filter.EElementOperator.IsNot));
}
PeakFilter newFilter = new PeakFilter(null, null, filters);
if (safeToReplace)
{
this._core.SetPeakFilters(this._core.PeakFilters.ReplaceSingle(this._peakFilter, newFilter).ToArray());
}
else
{
this._core.SetPeakFilters(this._core.PeakFilters.ConcatSingle(newFilter).ToArray());
}
this._peakFilter = newFilter;
this.UpdateScores();
return;
}
if (observationInfo == null)
{
bool needsNewFilter2 = true;
List <ObsFilter.Condition> filters2 = new List <ObsFilter.Condition>(this._obsFilter.Conditions.Cast <ObsFilter.Condition>());
foreach (ObsFilter.ConditionObservation fikaklq in filters2)
{
ObsFilter.ConditionObservation qkklqq = fikaklq as ObsFilter.ConditionObservation;
if (qkklqq != null &&
qkklqq.CombiningOperator == Filter.ELogicOperator.And &&
qkklqq.Negate == false &&
qkklqq.Operator == Filter.EElementOperator.IsNot)
{
needsNewFilter2 = false;
filters2.Remove(qkklqq);
filters2.Add(new ObsFilter.ConditionObservation(Filter.ELogicOperator.And, false, Filter.EElementOperator.IsNot, qkklqq.Possibilities.ConcatSingle(observationInfo)));
safeToReplace = filters2.Count == 1;
break;
}
}
if (needsNewFilter2)
{
filters2.Add(new ObsFilter.ConditionObservation(Filter.ELogicOperator.And, false, Filter.EElementOperator.IsNot, new[] { observationInfo }));
}
ObsFilter obsFilter = new ObsFilter(null, null, filters2);
if (safeToReplace)
{
this._core.SetObsFilters(this._core.ObsFilters.ReplaceSingle(this._obsFilter, obsFilter).ToArray());
}
else
{
this._core.SetObsFilters(this._core.ObsFilters.ConcatSingle(obsFilter).ToArray());
}
this._obsFilter = obsFilter;
this.UpdateScores();
}
}
/// <summary>
/// 获取子列表
/// </summary>
/// <param name="peakList">峰列表</param>
/// <returns>子列表</returns>
private static List <SubList> GetSublist(List <Peak> peakList)
{
List <SubList> lst = new List <SubList>();
int start = -1;
int natural = 0;
int i = 0;
//int j = 0;
//bool flag = false;
int peaklistcount = peakList.Count;
while (i < peaklistcount)
{
if (start != -1)
{
//20141023zhangrongzhou
//if (peakList[i].PeakState == Peak.PeakStates.ps_natural) natural = i;
if (PeakFilter.MatchBaselinePeak(peakList[i]))
{
natural = i;
}
//20141023
if (peakList[i].BaseLineEnd)
{
if (natural < start)
{
natural = start;
}
lst.Add(new SubList(start, natural));
start = -1;
}
}
else
{
//if (peakList[i].PeakState == Peak.PeakStates.ps_natural)
if (PeakFilter.MatchBaselinePeak(peakList[i]))
//20141023
{
start = i;
continue;
}
}
i++;
}
if (start != -1)
{
if (natural < start)
{
natural = start;
}
lst.Add(new SubList(start, natural));
}
//20120612zhangrongzhou
////search first natural peak
//for (j = 0; j < peaklistcount; j++)
// if (peakList[j].PeakState == Peak.PeakStates.ps_natural)
// {
// start = j;
// break;
// }
////
//for (i = j; i < peaklistcount; i++)
//{
// if (peakList[i].PeakState == Peak.PeakStates.ps_natural) natural = i;
// if (peakList[i].BaseLineEnd)
// {
// lst.Add(new SubList(start, natural));
// flag = true;
// start = i + 1;
// }
// else if (flag)
// {
// if (peakList[i].PeakState != Peak.PeakStates.ps_natural)
// start++;
// else
// flag = false;
// }
//}
//if (start < i)
// lst.Add(new SubList(start, i - 1));
return(lst);
}
