/// <summary>
/// Button: Load
/// </summary>
private void _btnLoad_Click_1(object sender, EventArgs e)
{
ClusterEvaluationPointer res = this.PickResults();
if (res == null)
{
return;
}
ClusterEvaluationResults set = FrmWait.Show(this, "Loading results", null, z => this.LoadResults(res.FileName, z));
if (res.Configuration == null)
{
// The results didn't have known config, they do now!
this._core.EvaluationResultFiles.Remove(res);
this._core.EvaluationResultFiles.Add(new ClusterEvaluationPointer(res.FileName, set.Configuration));
FrmMsgBox.ShowInfo(this, "Imported results", "The details on this result set have been imported into the current session. You will have to save the session to view these details in future.", FrmMsgBox.EDontShowAgainId.ImportResultsDetailNotice);
}
if (set != null)
{
this.SelectResults(res.FileName, set);
}
}
private void PopulateTreeView(ClusterEvaluationResults rs, List <ColumnWrapper> cols2)
{
IOrderedEnumerable <ColumnWrapper> order = cols2.OrderBy(z => z.Column.Id.Count(zz => zz == '\\'));
int lineImage = this._imageList.GetAssociatedImageIndex(this._lineImage, () => Resources.IconLine);
int statImage = this._imageList.GetAssociatedImageIndex(this._statImage, () => Resources.ListIconStatistics);
foreach (var v in order)
{
string[] elems = v.Column.Id.Split('\\');
TreeNodeCollection col = this._tvStatistics.Nodes;
TreeNode node = null;
foreach (string elem in elems)
{
node = col.Find(elem, false).FirstOrDefault();
if (node == null)
{
node = new TreeNode(elem);
node.ImageIndex = lineImage;
node.SelectedImageIndex = node.ImageIndex;
node.Name = elem;
col.Add(node);
}
col = node.Nodes;
}
node.ImageIndex = statImage;
node.SelectedImageIndex = node.ImageIndex;
node.Tag = v.Column;
}
}
private void SelectResults(string fileName, ClusterEvaluationResults config)
{
this._selectedResults = config;
this._lvhClusters.Clear();
this._chartParameters.Clear();
this._tvStatistics.Nodes.Clear();
this._lvhConfigs.Clear();
this._chcClusters.ClearPlot();
this._labelCluster.Text = "Cluster";
this._lblPlot.Text = "Plot";
if (config == null)
{
this.Text = "Evaluate Clustering";
this.ctlTitleBar1.SubText = string.Empty;
return;
}
this.ctlTitleBar1.SubText = config.ToString();
this.Text = "Evaluate Clustering - " + fileName;
this._lvhConfigs.DivertList <ClusterEvaluationParameterResult>(config.Results);
List <ColumnWrapper> cols2 = new List <ColumnWrapper>();
ClusterEvaluationParameterResult def = config.Results.FirstOrDefault();
if (def != null)
{
var cols = ColumnManager.GetColumns(this._core, def);
foreach (Column <ClusterEvaluationParameterResult> col in cols)
{
if (col.Provider != null)
{
cols2.Add(new ColumnWrapper(config, col));
}
}
}
this._lstSel.Items.Clear();
this._lstSel.Items.Add("(All test repetitions)");
for (int n = 0; n < config.Configuration.NumberOfRepeats; n++)
{
this._lstSel.Items.Add("Test " + (n + 1));
}
this._lvhStatistics.DivertList <ColumnWrapper>(cols2);
this.PopulateTreeView(config, cols2);
this._infoLabel.Text = "Loaded results";
}
private string BatchProcess(EUpdateResults options, IEnumerable <ClusterEvaluationPointer> tests, EClustererStatistics stats, ProgressReporter proggy)
{
StringBuilder sb = new StringBuilder();
foreach (ClusterEvaluationPointer res in tests)
{
sb.AppendLine("CONFIG: " + res.Configuration.ParameterConfigAsString);
sb.AppendLine("PARAMS: " + res.Configuration.ParameterValuesAsString);
sb.AppendLine("NAME: " + res.OverrideDisplayName);
sb.AppendLine("FILE: " + res.FileName);
if (!res.HasResults)
{
sb.AppendLine(" - No results.");
continue;
}
Stopwatch timer = Stopwatch.StartNew();
proggy.Enter("Loading results");
bool load = options.Has(EUpdateResults.Csv | EUpdateResults.Statistics | EUpdateResults.Resave);
ClusterEvaluationResults set = load ? this.LoadResults(res.FileName, proggy) : null;
proggy.Leave();
if (load && set == null)
{
sb.AppendLine(" - Load failed.");
continue;
}
sb.AppendLine(" - LOAD-TIME: " + timer.Elapsed);
sb.AppendLine();
if (options.Has(EUpdateResults.Csv))
{
timer.Restart();
proggy.Enter("Selecting results");
proggy.SetProgressMarquee();
this.Invoke((MethodInvoker)(() => this.SelectResults(res.FileName, set)));
proggy.Leave();
sb.AppendLine(" - DISPLAY-TIME: " + timer.Elapsed);
string csvFileName = Path.Combine(Path.GetDirectoryName(res.FileName), Path.GetFileNameWithoutExtension(res.FileName) + ".csv");
csvFileName = UiControls.GetNewFile(csvFileName, checkOriginal: true);
try
{
timer.Restart();
proggy.Enter("Exporting CSV");
proggy.SetProgressMarquee();
this.Invoke((MethodInvoker)(() =>
{
using (StreamWriter sw = new StreamWriter(csvFileName))
{
this._lvhStatistics.WriteItems(sw, true);
}
}));
proggy.Leave();
sb.AppendLine(" - EXPORT-TIME: " + timer.Elapsed);
sb.AppendLine(" - EXPORT: " + csvFileName);
}
catch (Exception ex)
{
sb.AppendLine(" - Export failed: " + ex.Message);
}
sb.AppendLine();
}
if (options.Has(EUpdateResults.Statistics))
{
foreach (ClusterEvaluationParameterResult rep in set.Results)
{
rep.RecalculateStatistics(this._core, stats, proggy);
}
}
if (options.Has(EUpdateResults.Information))
{
proggy.Enter("Exporting information");
string infoFileName = Path.Combine(Path.GetDirectoryName(res.FileName), Path.GetFileNameWithoutExtension(res.FileName) + ".txt");
infoFileName = UiControls.GetNewFile(infoFileName, checkOriginal: true);
StringBuilder info = new StringBuilder();
info.Append(res.DisplayName);
info.AppendLine(res.Configuration.ParameterConfigAsString);
info.AppendLine(res.Configuration.ParameterValuesAsString);
File.WriteAllText(infoFileName, info.ToString());
sb.AppendLine(" - INFORMATION: " + infoFileName);
sb.AppendLine();
}
if (options.Has(EUpdateResults.Resave))
{
string bakFileName = Path.Combine(Path.GetDirectoryName(res.FileName), Path.GetFileNameWithoutExtension(res.FileName) + ".old");
bakFileName = UiControls.GetNewFile(bakFileName, checkOriginal: true);
timer.Restart();
proggy.Enter("Backing up original");
proggy.SetProgressMarquee();
File.Copy(res.FileName, bakFileName, false);
proggy.Leave();
sb.AppendLine(" - BACKUP-TIME: " + timer.Elapsed);
sb.AppendLine(" - BACKUP: " + bakFileName);
timer.Restart();
proggy.Enter("Saving in latest format");
SaveResults(this._core, res.FileName, null, set, proggy);
proggy.Leave();
sb.AppendLine(" - SAVE-TIME: " + timer.Elapsed);
sb.AppendLine(" - SAVE: " + res.FileName);
sb.AppendLine();
}
}
return(sb.ToString());
}
public ColumnWrapper(ClusterEvaluationResults rs, Column <ClusterEvaluationParameterResult> col)
{
this._results = rs;
this.Column = col;
}
/// <summary>
/// Saves results to file
///
/// Returns pointer (unless originalPointer is NULL, in which case the action is assumed to be an export and is ignored).
/// </summary>
private static ClusterEvaluationPointer SaveResults(Core core, string fileName, ClusterEvaluationPointer originalPointer, ClusterEvaluationResults results, ProgressReporter proggy)
{
LookupByGuidSerialiser guidS = core.GetLookups();
proggy.Enter("Saving results");
XmlSettings.Save <ClusterEvaluationResults>(fileName, results, guidS, proggy);
if (core.SetLookups(guidS))
{
// UIDs have changed
SaveSession(core, proggy);
}
proggy.Leave();
if (originalPointer == null)
{
return(null);
}
return(new ClusterEvaluationPointer(fileName, originalPointer.Configuration));
}
/// <summary>
/// Actual test running
/// </summary>
private static ClusterEvaluationPointer RunTest(Core core, ClusterEvaluationPointer origPointer, ClusterEvaluationConfiguration test, ProgressReporter proggy, bool paranoid, int index, int of)
{
UiControls.Assert(core.FileNames.Session != null, "Didn't expect the session filename to be null for cluster evaluation.");
List <ClusterEvaluationParameterResult> results = new List <ClusterEvaluationParameterResult>();
// Iterate over parameters
for (int valueIndex = 0; valueIndex < test.ParameterValues.Length; valueIndex++)
{
object value = test.ParameterValues[valueIndex];
List <ResultClusterer> repetitions = new List <ResultClusterer>();
// Iterate over repetitions
for (int repetition = 0; repetition < test.NumberOfRepeats; repetition++)
{
proggy.Enter("Test " + index + "/" + of + ", parameter " + valueIndex + "/" + test.ParameterValues.Length + ", repetition " + repetition + "/" + test.NumberOfRepeats);
// Create config
string newName = AlgoParameterCollection.ParamToString(value) + " " + StringHelper.Circle(repetition + 1);
object[] copyOfParameters = test.ClustererConfiguration.Parameters.ToArray();
copyOfParameters[test.ParameterIndex] = value;
ArgsClusterer copyOfArgs = new ArgsClusterer(
test.ClustererConfiguration.Id,
test.ClustererConfiguration.SourceProvider,
test.ClustererConfiguration.PeakFilter,
test.ClustererConfiguration.Distance,
test.ClustererConfiguration.ObsFilter,
test.ClustererConfiguration.SplitGroups,
test.ClustererConfiguration.Statistics,
copyOfParameters,
test.ClustererConfiguration.OverrideShortName)
{
OverrideDisplayName = newName,
Comment = test.ClustererConfiguration.Comment
};
var copyOfConfig = new ConfigurationClusterer()
{
Args = copyOfArgs
};
// Try load previus result
ResultClusterer result = null;
if (paranoid)
{
result = TryLoadIntermediateResult(core, test.Guid, valueIndex, repetition, proggy);
}
if (result == null)
{
// DO CLUSTERING!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
proggy.Enter("Clustering");
result = copyOfConfig.Cluster(core, 0, proggy);
proggy.Leave();
if (paranoid)
{
SaveIntermediateResult(core, test.Guid, valueIndex, repetition, result, proggy);
}
}
// Add result
repetitions.Add(result);
string name = AlgoParameterCollection.ParamToString(value);
results.Add(new ClusterEvaluationParameterResult(name, test, valueIndex, repetitions));
proggy.Leave();
}
}
ClusterEvaluationResults final = new ClusterEvaluationResults(core, test, results);
string folder = UiControls.GetOrCreateFixedFolder(UiControls.EInitialFolder.Evaluations);
string sessionName = Path.GetFileNameWithoutExtension(core.FileNames.Session);
string fileName = core.Options.ClusteringEvaluationResultsFileName;
fileName = fileName.Replace("{SESSION}", sessionName);
fileName = fileName.Replace("{RESULTS}", folder + "\\");
fileName = UiControls.GetNewFile(fileName);
return(SaveResults(core, fileName, origPointer, final, proggy));
}
