private void redrawPipeline()
{
if (currentRunFile != "" && currentSource != null)
{
DataAccess dataAccess = new DataAccess(currentRunFile);
int width = Convert.ToInt32(dataAccess.GetParameter("Master_Width"));
int height = Convert.ToInt32(dataAccess.GetParameter("Master_Height"));
bool aspect = Convert.ToBoolean(dataAccess.GetParameter("Master_Aspect"));
int scalingMethod = Convert.ToInt32(dataAccess.GetParameter("Master_Resize"));
chkContastStretch.Checked = Convert.ToBoolean(dataAccess.GetParameter("Filter_Stretch"));
chkHistogram.Checked = Convert.ToBoolean(dataAccess.GetParameter("Filter_Histo"));
chkGaussian.Checked = Convert.ToBoolean(dataAccess.GetParameter("Filter_Gaussian"));
numBlurStrength.Value = Convert.ToInt32(dataAccess.GetParameter("Filter_BlurStr"));
chkContrast.Checked = Convert.ToBoolean(dataAccess.GetParameter("Filter_Contrast"));
numContrast.Value = Convert.ToDecimal(dataAccess.GetParameter("Filter_ContrastStr"));
chkGreyscale.Checked = Convert.ToBoolean(dataAccess.GetParameter("Filter_Greyscale"));
chkBradley.Checked = Convert.ToBoolean(dataAccess.GetParameter("Filter_Bradley"));
chkThreshold.Checked = Convert.ToBoolean(dataAccess.GetParameter("Filter_Threshold"));
numThreshold.Value = Convert.ToDecimal(dataAccess.GetParameter("Filter_ThresholdStr"));
Preprocessor preprocessor = new Preprocessor();
preprocessor.Bradley = chkBradley.Checked;
preprocessor.ContrastAdjustment = chkContrast.Checked;
preprocessor.ContrastStrength = numContrast.Value;
preprocessor.ContrastStretch = chkContastStretch.Checked;
preprocessor.FilterLevel = 1;
preprocessor.Gaussian = chkGaussian.Checked;
preprocessor.GaussianStrength = numBlurStrength.Value;
preprocessor.Greyscale = chkGreyscale.Checked;
preprocessor.Histogram = chkHistogram.Checked;
preprocessor.ImageSize = new Size(width, height);
preprocessor.KeepAspectRatio = aspect;
preprocessor.ScalingMethod = (ScalingMethods)scalingMethod;
preprocessor.Threshold = chkThreshold.Checked;
preprocessor.ThresholdStrength = numThreshold.Value;
imgTestImage.LoadImage(preprocessor.Process((Bitmap)currentSource.InternalImage));
}
}
public Optimiser(string filename)
{
Utils.Logger.Log("Loading stopwatch... ");
stopWatch = new Stopwatch();
ResultCounter = new Stopwatch();
this.filename = filename;
Utils.Logger.Log("Loading preprocessor parameters from " + filename);
dataAccess = new DataAccess(filename);
preprocessor = new Preprocessor();
preprocessor.ImageSize = new Size(Convert.ToInt32(dataAccess.GetParameter("Master_Width")), Convert.ToInt32(dataAccess.GetParameter("Master_Height")));
preprocessor.KeepAspectRatio = Convert.ToBoolean(dataAccess.GetParameter("Master_Aspect"));
preprocessor.ScalingMethod = (ScalingMethods)Convert.ToInt32(dataAccess.GetParameter("Master_Resize"));
preprocessor.ContrastStretch = Convert.ToBoolean(dataAccess.GetParameter("Filter_Stretch"));
preprocessor.Histogram = Convert.ToBoolean(dataAccess.GetParameter("Filter_Histo"));
preprocessor.Gaussian = Convert.ToBoolean(dataAccess.GetParameter("Filter_Gaussian"));
preprocessor.GaussianStrength = Convert.ToInt32(dataAccess.GetParameter("Filter_BlurStr"));
preprocessor.ContrastAdjustment = Convert.ToBoolean(dataAccess.GetParameter("Filter_Contrast"));
preprocessor.ContrastStrength = Convert.ToDecimal(dataAccess.GetParameter("Filter_ContrastStr"));
preprocessor.Greyscale = Convert.ToBoolean(dataAccess.GetParameter("Filter_Greyscale"));
preprocessor.Bradley = Convert.ToBoolean(dataAccess.GetParameter("Filter_Bradley"));
preprocessor.Threshold = Convert.ToBoolean(dataAccess.GetParameter("Filter_Threshold"));
preprocessor.ThresholdStrength = Convert.ToDecimal(dataAccess.GetParameter("Filter_ThresholdStr"));
/*
dataAccess.SetParameter("Opt_Bp_LearningType", cmbLearningRateType.SelectedItem.ToString());
dataAccess.SetParameter("Opt_Bp_InitialLearnRate", txtInitialRate.Text);
dataAccess.SetParameter("Opt_Bp_FinalLearnRate", txtFinalRate.Text);
dataAccess.SetParameter("Opt_Bp_JitterEpoch", txtJitterEpoch.Text);
dataAccess.SetParameter("Opt_Bp_JitterNoiseLimit", txtJitterNoiseLimit.Text);
dataAccess.SetParameter("Opt_Bp_MaxIterations", txtMaxIterations.Text);
dataAccess.SetParameter("Opt_Bp_MinError", txtMinimumError.Text);
*/
bool usePSO = false;
bool useBP = false;
try
{
useBP = Convert.ToBoolean(dataAccess.GetParameter("Opt_Bp_Enabled"));
}
catch (Exception)
{
Utils.Logger.Log("Warning unable to read BP params");
}
try
{
usePSO = Convert.ToBoolean(dataAccess.GetParameter("Opt_Pso_Enabled"));
}
catch (Exception)
{
Utils.Logger.Log("Warning unable to read PSO params");
}
if (usePSO && useBP)
{
throw new NotImplementedException("At this current time you cannot use both BP and PSO");
}
InputGroup[] inputGroups = dataAccess.GetInputGroups();
SourceItem[] sourceItems = dataAccess.GetSourceItems();
/*
Utils.Logger.Log("Preprocessing images...");
foreach (SourceItem item in sourceItems)
{
Utils.Logger.Log("Preprocessing item {0} ", item.Filename);
item.InternalImage = preprocessor.Process((Bitmap)item.InternalImage);
}
*/
int total = 0;
foreach (InputGroup inputGroup in inputGroups)
{
if (inputGroup.InputGroupType == InputGroupType.Grid)
{
total += (inputGroup.Segments) * (inputGroup.Segments);
}
else
{
total += inputGroup.Segments;
}
}
maxIterations = Convert.ToInt32(dataAccess.GetParameter("Opt_Global_MaxIterations"));
minError = Convert.ToDouble(dataAccess.GetParameter("Opt_Global_MinError"));
maxTime = Convert.ToInt32(dataAccess.GetParameter("Opt_Global_MaxTime"));
results = new float[Convert.ToInt32(dataAccess.GetParameter("Opt_Global_BufferSize"))];
if (useBP)
{
int learningRateFunction = Convert.ToInt32(dataAccess.GetParameter("Opt_Bp_LearningType"));
double initialLR = Convert.ToDouble(dataAccess.GetParameter("Opt_Bp_InitialLearnRate"));
double finalLR = Convert.ToDouble(dataAccess.GetParameter("Opt_Bp_FinalLearnRate"));
int jitterEpoch = Convert.ToInt32(dataAccess.GetParameter("Opt_Bp_JitterEpoch"));
double jitterNoiseLimit = Convert.ToDouble(dataAccess.GetParameter("Opt_Bp_JitterNoiseLimit"));
NeuronDotNet.Core.Backpropagation.LinearLayer inputLayer = new NeuronDotNet.Core.Backpropagation.LinearLayer(preprocessor.ImageSize.Width * preprocessor.ImageSize.Height);
NeuronDotNet.Core.Backpropagation.SigmoidLayer hiddenLayer = new NeuronDotNet.Core.Backpropagation.SigmoidLayer(total);
hiddenLayer.InputGroups = inputGroups.Length;
NeuronDotNet.Core.Backpropagation.SigmoidLayer outputLayer = new NeuronDotNet.Core.Backpropagation.SigmoidLayer(1);
hiddenLayer.Initializer = new NguyenWidrowFunction();
new BackpropagationConnector(
inputLayer,
hiddenLayer,
inputGroups,
preprocessor.ImageSize.Width,
preprocessor.ImageSize.Height
);
new BackpropagationConnector(hiddenLayer, outputLayer);
network = new BackpropagationNetwork(inputLayer, outputLayer);
switch (learningRateFunction)
{
case 0:
network.SetLearningRate(initialLR);
break;
case 1:
network.SetLearningRate(new NeuronDotNet.Core.LearningRateFunctions.ExponentialFunction(initialLR, finalLR));//exp
break;
case 2:
network.SetLearningRate(new NeuronDotNet.Core.LearningRateFunctions.HyperbolicFunction(initialLR, finalLR));//hyp
break;
case 3:
network.SetLearningRate(new NeuronDotNet.Core.LearningRateFunctions.LinearFunction(initialLR, finalLR));//lin
break;
default:
throw new ArgumentOutOfRangeException("The learning rate index is out of range.\n");
}
network.JitterEpoch = jitterEpoch;
network.JitterNoiseLimit = jitterNoiseLimit;
}
if (usePSO)
{
double minP = Convert.ToDouble(dataAccess.GetParameter("Opt_Pso_MinP"));
double maxP = Convert.ToDouble(dataAccess.GetParameter("Opt_Pso_MaxP"));
double minI = Convert.ToDouble(dataAccess.GetParameter("Opt_Pso_MinI"));
double maxI = Convert.ToDouble(dataAccess.GetParameter("Opt_Pso_MaxI"));
double quant = Convert.ToDouble(dataAccess.GetParameter("Opt_Pso_Quant"));
double vMax = Convert.ToDouble(dataAccess.GetParameter("Opt_Pso_vMax"));
int clamping = Convert.ToInt32(dataAccess.GetParameter("Opt_Pso_Clamping"));
int initLinks = Convert.ToInt32(dataAccess.GetParameter("Opt_Pso_InitLinks"));
int randomness = Convert.ToInt32(dataAccess.GetParameter("Opt_Pso_Randomness"));
int randOrder = Convert.ToInt32(dataAccess.GetParameter("Opt_Pso_ParticleOrder"));
int rotation = Convert.ToInt32(dataAccess.GetParameter("Opt_Pso_Rotation"));
int dimensions = Convert.ToInt32(dataAccess.GetParameter("Opt_Pso_Dimensions"));
int swarmSize = Convert.ToInt32(dataAccess.GetParameter("Opt_Pso_Particles"));
double k = Convert.ToDouble(dataAccess.GetParameter("Opt_Pso_k"));
double p = Convert.ToDouble(dataAccess.GetParameter("Opt_Pso_p"));
double w = Convert.ToDouble(dataAccess.GetParameter("Opt_Pso_w"));
double c = Convert.ToDouble(dataAccess.GetParameter("Opt_Pso_c"));
Parameters param = new Parameters();
param.vMax = vMax;
param.clamping = clamping;
// 0 => no clamping AND no evaluation. WARNING: the program
// may NEVER stop (in particular with option move 20 (jumps)) 1
// *1 => classical. Set to bounds, and velocity to zero
param.initLink = initLinks; // 0 => re-init links after each unsuccessful iteration
// 1 => re-init links after each successful iteration
param.rand = randomness; // 0 => Use KISS as random number generator.
// Any other value => use the system one
param.randOrder = randOrder; // 0 => at each iteration, particles are modified
// always according to the same order 0..S-1
//*1 => at each iteration, particles numbers are
// randomly permutated
param.rotation = rotation;
// WARNING. Experimental code, completely valid only for dimension 2
// 0 => sensitive to rotation of the system of coordinates
// 1 => non sensitive (except side effects),
// by using a rotated hypercube for the probability distribution
// WARNING. Quite time consuming!
param.stop = 0; // Stop criterion
// 0 => error < pb.epsilon
// 1 => eval >= pb.evalMax
// 2 => ||x-solution|| < pb.epsilon
// ===========================================================
// RUNs
// Initialize some objects
//pb = new Problem(function);
// You may "manipulate" S, p, w and c
// but here are the suggested values
param.S = swarmSize;
if (param.S > 910) param.S = 910;
param.K = (int)k;
param.p = p;
// (to simulate the global best PSO, set param.p=1)
//param.p=1;
param.w = w;
param.c = c;
NeuronDotNet.Core.PSO.LinearLayer inputLayer = new NeuronDotNet.Core.PSO.LinearLayer(preprocessor.ImageSize.Width * preprocessor.ImageSize.Height);
NeuronDotNet.Core.PSO.SigmoidLayer hiddenLayer = new NeuronDotNet.Core.PSO.SigmoidLayer(total);
hiddenLayer.InputGroups = inputGroups.Length;
NeuronDotNet.Core.PSO.SigmoidLayer outputLayer = new NeuronDotNet.Core.PSO.SigmoidLayer(1);
hiddenLayer.Initializer = new NguyenWidrowFunction();
new PSOConnector(
inputLayer,
hiddenLayer,
inputGroups,
preprocessor.ImageSize.Width,
preprocessor.ImageSize.Height
);
new PSOConnector(hiddenLayer, outputLayer);
PSONetwork n = new PSONetwork(inputLayer, outputLayer);
n.PsoParameters = param;
n.PsoProblem.MaxI = maxI;
n.PsoProblem.MinI = minI;
n.PsoProblem.MaxP = maxP;
n.PsoProblem.MinP = minP;
n.PsoProblem.Quantisation = quant;
network = n;
}
set = new TrainingSet(preprocessor.ImageSize.Width * preprocessor.ImageSize.Height, 1);
foreach (SourceItem item in sourceItems)
{
double[] weights = Utils.getImageWeights(item.InternalImage, inputGroups);
set.Add(new TrainingSample(weights, new double[] { (double)item.SampleType }));
}
network.EndEpochEvent += new TrainingEpochEventHandler(network_EndEpochEvent);
network.Initialize();
}
private void loadRuns(string filename)
{
Utils.Logger.Log("Getting runs...");
lstRuns.Items.Clear();
DataAccess dataAccess = new DataAccess(filename);
Run[] runs = dataAccess.GetRuns();
foreach (Run run in runs)
{
lstRuns.Items.Add(new ListViewItem(run.ToStringArray()));
}
lstInputGroups.Items.Clear();
InputGroup[] groups = dataAccess.GetInputGroups();
foreach (InputGroup group in groups)
{
lstInputGroups.Items.Add(group);
}
}
private double calculateFitness()
{
DataAccess dataAccess = new DataAccess(currentRunFile);
if (currentRunFile != "" && currentSource != null && lstRuns.SelectedItems.Count > 0)
{
int width = Convert.ToInt32(dataAccess.GetParameter("Master_Width"));
int height = Convert.ToInt32(dataAccess.GetParameter("Master_Height"));
bool aspect = Convert.ToBoolean(dataAccess.GetParameter("Master_Aspect"));
int scalingMethod = Convert.ToInt32(dataAccess.GetParameter("Master_Resize"));
chkContastStretch.Checked = Convert.ToBoolean(dataAccess.GetParameter("Filter_Stretch"));
chkHistogram.Checked = Convert.ToBoolean(dataAccess.GetParameter("Filter_Histo"));
chkGaussian.Checked = Convert.ToBoolean(dataAccess.GetParameter("Filter_Gaussian"));
numBlurStrength.Value = Convert.ToInt32(dataAccess.GetParameter("Filter_BlurStr"));
chkContrast.Checked = Convert.ToBoolean(dataAccess.GetParameter("Filter_Contrast"));
numContrast.Value = Convert.ToDecimal(dataAccess.GetParameter("Filter_ContrastStr"));
chkGreyscale.Checked = Convert.ToBoolean(dataAccess.GetParameter("Filter_Greyscale"));
chkBradley.Checked = Convert.ToBoolean(dataAccess.GetParameter("Filter_Bradley"));
chkThreshold.Checked = Convert.ToBoolean(dataAccess.GetParameter("Filter_Threshold"));
numThreshold.Value = Convert.ToDecimal(dataAccess.GetParameter("Filter_ThresholdStr"));
Preprocessor preprocessor = new Preprocessor();
preprocessor.Bradley = chkBradley.Checked;
preprocessor.ContrastAdjustment = chkContrast.Checked;
preprocessor.ContrastStrength = numContrast.Value;
preprocessor.ContrastStretch = chkContastStretch.Checked;
preprocessor.FilterLevel = 1;
preprocessor.Gaussian = chkGaussian.Checked;
preprocessor.GaussianStrength = numBlurStrength.Value;
preprocessor.Greyscale = chkGreyscale.Checked;
preprocessor.Histogram = chkHistogram.Checked;
preprocessor.ImageSize = new Size(width, height);
preprocessor.KeepAspectRatio = aspect;
preprocessor.ScalingMethod = (ScalingMethods)scalingMethod;
preprocessor.Threshold = chkThreshold.Checked;
preprocessor.ThresholdStrength = numThreshold.Value;
Network network = dataAccess.GetNetwork(int.Parse(lstRuns.SelectedItems[0].SubItems[5].Text));
currentSource.Preprocessor = preprocessor;
Bitmap b = (Bitmap)currentSource.InternalImage;
double[] result = network.Run(Utils.getImageWeights(b, (InputGroup[])lstInputGroups.Items.Cast<InputGroup>().ToArray<InputGroup>()));
b.Dispose();
lblFitness.Text = "Fitness: " + result[0].ToString();
return result[0];
}
return -1.0 ;
}
private void btnSaveRun_Click(object sender, EventArgs e)
{
using (SaveFileDialog dlgSave = new SaveFileDialog())
{
dlgSave.AddExtension = true;
dlgSave.DefaultExt = "erun";
dlgSave.Filter = "ENFORM run file(*.erun)|*.erun";
dlgSave.Title = "Save run file as...";
if (dlgSave.ShowDialog() == DialogResult.OK)
{
BackgroundWorker worker = new BackgroundWorker();
worker.WorkerReportsProgress = true;
worker.DoWork += new DoWorkEventHandler(worker_DoWork);
worker.ProgressChanged += new ProgressChangedEventHandler(worker_ProgressChanged);
worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(worker_RunWorkerCompleted);
this.Enabled = false;
dlgProgress = new frmProgressDialog();
dlgProgress.Show(this);
dlgProgress.Title = "Saving run file...";
Preprocessor preprocessor = new Preprocessor();
preprocessor.Bradley = chkBradley.Checked;
preprocessor.ContrastAdjustment = chkContrast.Checked;
preprocessor.ContrastStrength = numContrast.Value;
preprocessor.ContrastStretch = chkContastStretch.Checked;
preprocessor.FilterLevel = filterLevel;
preprocessor.Gaussian = chkGaussian.Checked;
preprocessor.GaussianStrength = numBlurStrength.Value;
preprocessor.Greyscale = chkGreyscale.Checked;
preprocessor.Histogram = chkHistogram.Checked;
preprocessor.ImageSize = new Size(Int32.Parse(txtWidth.Text), Int32.Parse(txtHeight.Text));
preprocessor.KeepAspectRatio = chkAspect.Checked;
preprocessor.ScalingMethod = (ScalingMethods)cmbScalingMethod.SelectedIndex;
preprocessor.Threshold = chkThreshold.Checked;
preprocessor.ThresholdStrength = numThreshold.Value;
Utils.Logger.Log("Caching all images to store in run file...");
if (chkEmbed.Checked)
{
//cacheAll();
}
DataAccess dataAccess = new DataAccess(dlgSave.FileName);
Utils.Logger.Log("Clearing database data...");
dataAccess.ClearFile();
Utils.Logger.Log("Adding input groups...");
for (int i = 0; i < lstInputGroups.Items.Count; i++)
{
dataAccess.AddInputGroup(i, (InputGroup)lstInputGroups.Items[i]);
}
worker.RunWorkerAsync(new object[] {dataAccess,preprocessor});
}
}
}
private void btnLoadRun_Click(object sender, EventArgs e)
{
using (OpenFileDialog dlgLoad = new OpenFileDialog())
{
dlgLoad.AddExtension = true;
dlgLoad.DefaultExt = "erun";
dlgLoad.Filter = "ENFORM run file(*.erun)|*.erun";
dlgLoad.Title = "Open run file...";
if (dlgLoad.ShowDialog() == DialogResult.OK)
{
DataAccess dataAccess = new DataAccess(dlgLoad.FileName);
SourceItem[] sources = dataAccess.GetSourceItems();
sourceItems.Clear();
lstInputs.Items.Clear();
foreach (SourceItem source in sources)
{
ListViewItem newItem = lstInputs.Items.Add(new ListViewItem(source.GetStringValues()));
sourceItems.Add(newItem.GetHashCode(), source);
}
InputGroup[] groups = dataAccess.GetInputGroups();
lstInputGroups.Items.Clear();
foreach (InputGroup group in groups)
{
lstInputGroups.Items.Add(group);
}
txtWidth.Text = dataAccess.GetParameter("Master_Width");
txtHeight.Text = dataAccess.GetParameter("Master_Height");
chkAspect.Checked = Convert.ToBoolean(dataAccess.GetParameter("Master_Aspect"));
cmbScalingMethod.SelectedIndex = Convert.ToInt32(dataAccess.GetParameter("Master_Resize"));
chkContastStretch.Checked = Convert.ToBoolean(dataAccess.GetParameter("Filter_Stretch"));
chkHistogram.Checked = Convert.ToBoolean(dataAccess.GetParameter("Filter_Histo"));
chkGaussian.Checked = Convert.ToBoolean(dataAccess.GetParameter("Filter_Gaussian"));
numBlurStrength.Value = Convert.ToInt32(dataAccess.GetParameter("Filter_BlurStr"));
chkContrast.Checked = Convert.ToBoolean(dataAccess.GetParameter("Filter_Contrast"));
numContrast.Value = Convert.ToDecimal(dataAccess.GetParameter("Filter_ContrastStr"));
chkGreyscale.Checked = Convert.ToBoolean(dataAccess.GetParameter("Filter_Greyscale"));
chkBradley.Checked = Convert.ToBoolean(dataAccess.GetParameter("Filter_Bradley"));
chkThreshold.Checked = Convert.ToBoolean(dataAccess.GetParameter("Filter_Threshold"));
numThreshold.Value = Convert.ToDecimal(dataAccess.GetParameter("Filter_ThresholdStr"));
try
{
txtMaxIterations.Text = dataAccess.GetParameter("Opt_Global_MaxIterations");
txtMinimumError.Text = dataAccess.GetParameter("Opt_Global_MinError");
txtMaxTime.Text = dataAccess.GetParameter("Opt_Global_MaxTime");
txtBufferSize.Text = dataAccess.GetParameter("Opt_Global_BufferSize");
}
catch (Exception)
{
Utils.Logger.Log("Warning: Error reading global parameters");
}
try
{
chkBackPropogation.Checked = Convert.ToBoolean(dataAccess.GetParameter("Opt_Bp_Enabled"));
cmbLearningRateType.SelectedIndex = Convert.ToInt32(dataAccess.GetParameter("Opt_Bp_LearningType"));
txtInitialRate.Text = dataAccess.GetParameter("Opt_Bp_InitialLearnRate");
txtFinalRate.Text = dataAccess.GetParameter("Opt_Bp_FinalLearnRate");
txtJitterEpoch.Text = dataAccess.GetParameter("Opt_Bp_JitterEpoch");
txtJitterNoiseLimit.Text = dataAccess.GetParameter("Opt_Bp_JitterNoiseLimit");
}
catch (Exception)
{
Utils.Logger.Log("Warning: Error reading backprop parameters");
}
try
{
chkPSO.Checked = Convert.ToBoolean(dataAccess.GetParameter("Opt_Pso_Enabled"));
txtMinP.Text = dataAccess.GetParameter("Opt_Pso_MinP");
txtMaxP.Text = dataAccess.GetParameter("Opt_Pso_MaxP");
txtMinI.Text = dataAccess.GetParameter("Opt_Pso_MinI");
txtMaxI.Text = dataAccess.GetParameter("Opt_Pso_MaxI");
txtQuant.Text = dataAccess.GetParameter("Opt_Pso_Quant");
txtVMax.Text = dataAccess.GetParameter("Opt_Pso_vMax");
cmbClamping.SelectedIndex = Convert.ToInt32(dataAccess.GetParameter("Opt_Pso_Clamping"));
cmbInitLinks.SelectedIndex = Convert.ToInt32(dataAccess.GetParameter("Opt_Pso_InitLinks"));
cmbPSORandom.SelectedIndex = Convert.ToInt32(dataAccess.GetParameter("Opt_Pso_Randomness"));
cmbRandOrder.SelectedIndex = Convert.ToInt32(dataAccess.GetParameter("Opt_Pso_ParticleOrder"));
cmbRotation.SelectedIndex = Convert.ToInt32(dataAccess.GetParameter("Opt_Pso_Rotation"));
txtDimensions.Text = dataAccess.GetParameter("Opt_Pso_Dimensions");
txtSwarmSize.Text = dataAccess.GetParameter("Opt_Pso_Particles");
txtK.Text = dataAccess.GetParameter("Opt_Pso_k");
txtP.Text = dataAccess.GetParameter("Opt_Pso_p");
txtW.Text = dataAccess.GetParameter("Opt_Pso_w");
txtC.Text = dataAccess.GetParameter("Opt_Pso_c");
chkAutoSwarmSize.Checked = Convert.ToBoolean(dataAccess.GetParameter("Opt_Pso_AutoParticles"));
chkAutoK.Checked = Convert.ToBoolean(dataAccess.GetParameter("Opt_Pso_AutoK"));
chkAutoP.Checked = Convert.ToBoolean(dataAccess.GetParameter("Opt_Pso_AutoP"));
chkAutoW.Checked = Convert.ToBoolean(dataAccess.GetParameter("Opt_Pso_AutoW"));
chkAutoC.Checked = Convert.ToBoolean(dataAccess.GetParameter("Opt_Pso_AutoC"));
}
catch (Exception)
{
Utils.Logger.Log("Warning: Error reading PSO parameters");
}
}
}
}
private float[] getAverageResults(string filename)
{
DataAccess dataAccess = new DataAccess(filename);
Run[] runs = dataAccess.GetRuns();
float[][] results = new float[runs.Length][];
for (int j = 0; j < runs.Length; j++)
{
results[j] = dataAccess.GetResults(runs[j]);
}
int maxResultLength = 0;
int mrlIndex = -1;
for (int j = 0; j < results.Length; j++)
{
if (results[j].Length > maxResultLength)
{
maxResultLength = results[j].Length;
mrlIndex = j;
}
}
for (int j = 0; j < maxResultLength; j++)
{
float total = 0.0f;
int z = 0;
for (int k = 0; k < results.Length; k++)
{
if (j < results[k].Length)
{
total += results[k][j];
z++;
}
}
total /= z;
if (float.IsNaN(total))
{
throw new Exception("");
}
results[mrlIndex][j] = total;
}
return results[0];
}