internal static bool Represents(ObsFilter a, GroupInfo b)
{
if (a == null || a.Conditions.Count != 1)
{
return(false);
}
var x = a.Conditions[0] as ObsFilter.ConditionGroup;
if (x == null ||
x.Negate ||
x.Operator != Filter.EElementOperator.Is ||
x.Possibilities.Count != 1 ||
x.CombiningOperator != Filter.ELogicOperator.And)
{
return(false);
}
if (x.Possibilities[0] != b)
{
return(false);
}
return(true);
}
/// <summary>
/// Adds and a single new observation filter.
/// </summary>
internal void AddObsFilter(ObsFilter toAdd)
{
List <ObsFilter> existing = new List <ObsFilter>(this.ObsFilters);
existing.Add(toAdd);
this.SetObsFilters(existing.ToArray());
}
public readonly Peak VectorBPeak; // Which peak the second input vector comes from (only used if [VectorBSource] is AltPeak)
public ArgsStatistic(string id, IMatrixProvider source, ObsFilter atypes, EAlgoInputBSource bsrc, ObsFilter btypes, Peak compareTo, object[] parameters)
: base(id, source, parameters)
{
this.VectorAConstraint = atypes;
this.VectorBConstraint = btypes;
this.VectorBSource = bsrc;
this.VectorBPeak = compareTo;
}
public readonly ObsFilter Constraint; // (ONLY FOR TREND-BASED CORRECTIONS) Constraint on the input vector
public ArgsCorrection(string id, IMatrixProvider source, object[] parameters, ECorrectionMode mode, ECorrectionMethod method, GroupInfo controlGroup, ObsFilter constraint)
: base(id, source, parameters)
{
Mode = mode;
Method = method;
ControlGroup = controlGroup;
Constraint = constraint;
}
/// <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;
}
private static string CreatePartialKey(ObsFilter obsFilter, string key)
{
if (obsFilter != null)
{
return("Partial vector (" + obsFilter.ToString() + ")\\" + key);
}
else
{
return("Full vector\\" + key);
}
}
private void AllGroupsFilters(Core core, List <ObsFilter> results)
{
foreach (GroupInfo group in core.Groups)
{
if (!results.Any(z => Represents(z, group)))
{
ObsFilter.Condition cond = new ObsFilter.ConditionGroup(Filter.ELogicOperator.And, false, Filter.EElementOperator.Is, new GroupInfo[] { group });
ObsFilter toAdd = new ObsFilter(null, null, new[] { cond });
results.Add(toAdd);
}
}
}
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();
}
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 observation filter
/// </summary>
public static DataSet <ObsFilter.Condition> ForObsFilterConditions(Core core, ObsFilter of)
{
return(new DataSet <ObsFilter.Condition>()
{
Core = core,
ListTitle = "Observation filter conditions",
ListSource = of != null?of.Conditions.Cast <ObsFilter.Condition>() : new ObsFilter.Condition[0],
HandleEdit = z => FrmEditObsFilterCondition.Show(z.Owner, core, z.DefaultValue, z.ReadOnly),
ListSupportsReorder = true,
Icon = Resources.ListIconFilter,
});
}
/// <summary>
/// Determines what needs calculating.
/// </summary>
private void Thread_AddFilterToCalculationList([Const] Core core, [Const] ConfigurationMetric metric, [Const] IntensityMatrix vmatrix, [Const] DistanceMatrix dmatrix, [Const] EClustererStatistics statistics, [Const] Cluster[] realClusters, [Const] ObsFilter obsFilter, [MutableUnsafe] List <ForStat> needsCalculating, [MutableSafe] ProgressParallelHandler progP)
{
progP.SafeIncrement();
IntensityMatrix vmatFiltered;
DistanceMatrix dmatFiltered;
int[] filteredIndices;
if (obsFilter == null)
{
vmatFiltered = vmatrix;
dmatFiltered = dmatrix;
filteredIndices = null;
}
else
{
filteredIndices = vmatrix.Columns.Which(z => obsFilter.Test(z.Observation)).ToArray(); // TODO: Multuple iteration
vmatFiltered = vmatrix.Subset(null, obsFilter, ESubsetFlags.None);
dmatFiltered = null;
}
Dictionary <Cluster, IReadOnlyList <double> > centreVectors = new Dictionary <Cluster, IReadOnlyList <double> >();
foreach (Cluster cluster in realClusters)
{
/////////////////////
// ASSIGNMENT STATS
var centre = cluster.GetCentre(ECentreMode.Average, ECandidateMode.Assignments);
IReadOnlyList <double> centreVector = centre.Count != 0 ? centre[0] : null;
if (filteredIndices != null)
{
centreVector = centreVector.Extract(filteredIndices);
}
centreVectors.Add(cluster, centreVector);
}
foreach (Assignment ass in Assignments)
{
ForStat f = new ForStat();
f.Assignment = ass;
f.ObsFilter = obsFilter;
if (filteredIndices != null)
{
f.AssignmentVector = vmatFiltered.Vectors[ass.Vector.Index];
}
else
{
f.AssignmentVector = ass.Vector;
}
f.ClusterVector = centreVectors[ass.Cluster];
if (statistics.HasFlag(EClustererStatistics.SilhouetteWidth))
{
if (dmatFiltered == null)
{
dmatFiltered = DistanceMatrix.Create(core, vmatrix, metric, ProgressReporter.GetEmpty());
}
}
f.DistanceMatrix = dmatFiltered;
lock (needsCalculating)
{
needsCalculating.Add(f);
}
}
}
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();
}
}
void wizard_OkClicked(object sender, EventArgs e)
{
// Check
if (!this._wizard.RevalidateAll())
{
FrmMsgBox.ShowError(this, "Not all options have been selected.");
return;
}
int param1_numClusters = this._radStopN.Checked ? int.Parse(this._txtStopN.Text) : int.MinValue;
double param2_distanceLimit = this._radStopD.Checked ? double.Parse(this._txtStopD.Text) : double.MinValue;
Debug.Assert(this._ecbSeedPeak.HasSelection, "Expected a seed peak to be selected");
WeakReference <Peak> param3_seedPeak = new WeakReference <Peak>(this._ecbSeedPeak.SelectedItem);
GroupInfo param4_seedGroup = NamedItem <GroupInfo> .Extract(this._lstGroups.SelectedItem);
int param5_doKMeans = this._radFinishK.Checked ? 1 : 0;
IMatrixProvider source = this._ecbSource.SelectedItem;
object[] parameters = { param1_numClusters, param2_distanceLimit, param3_seedPeak, param4_seedGroup, param5_doKMeans };
string name = "DK";
// Create a constraint that only allows overlapping timepoints
HashSet <int> overlappingPoints = new HashSet <int>();
var fil = this._ecbFilter.SelectedItem ?? ObsFilter.Empty;
var passed = fil.Test(source.Provide.Columns.Select(z => z.Observation)).Passed;
HashSet <GroupInfo> groups = new HashSet <GroupInfo>(passed.Select(z => z.Group));
bool needsExFilter = false;
foreach (int ctp in this._core.Times)
{
bool trueInAny = false;
bool falseInAny = false;
foreach (GroupInfo g in groups)
{
if (passed.Any(z => z.Group == g && z.Time == ctp))
{
trueInAny = true;
}
else
{
falseInAny = true;
}
}
if (trueInAny && !falseInAny) // i.e. true in all TT
{
overlappingPoints.Add(ctp);
}
else if (trueInAny) // i.e. true in one but not all TF
{
needsExFilter = true;
}
//else if (falseInAny) // False in all (accptable) FT
// else // No groups FF
}
ObsFilter trueFilter;
if (needsExFilter)
{
List <ObsFilter.Condition> conditions = new List <ObsFilter.Condition>
{
new ObsFilter.ConditionFilter(Filter.ELogicOperator.And, false,
this._ecbFilter.SelectedItem, true),
new ObsFilter.ConditionTime(Filter.ELogicOperator.And, false,
Filter.EElementOperator.Is,
overlappingPoints)
};
trueFilter = new ObsFilter(null, null, conditions);
this._core.AddObsFilter(trueFilter);
}
else
{
trueFilter = this._ecbFilter.SelectedItem;
}
ArgsClusterer args = new ArgsClusterer(
Algo.ID_DKMEANSPPWIZ,
this._ecbSource.SelectedItem,
this._ecbPeakFilter.SelectedItem,
new ConfigurationMetric()
{
Args = new ArgsMetric(this._ecbDistance.SelectedItem.Id, this._ecbSource.SelectedItem, this._ecbDistance.SelectedItem.Parameters.StringToParams(this._core, this._txtDistanceParams.Text))
},
trueFilter,
this._chkClusterIndividually.Checked,
EClustererStatistics.None,
parameters,
"DK")
{
OverrideDisplayName = name,
Comment = "Generated using wizard"
};
ConfigurationClusterer config = new ConfigurationClusterer()
{
Args = args
};
FrmWait.Show(this, "Clustering", null, z => this._core.AddClusterer(config, z));
this.DialogResult = DialogResult.OK;
}
