private void CreateConfiguration(
eye_tracking_mouse.Options.CalibrationMode mode,
List <UtilityAndModePair> linear_search_reasults,
List <UtilityAndModePair> extremum_search_results)
{
string new_config = Utils.GenerateNewConfigurationName("gen") + "_" +
Helpers.GetCombinedUtility(Helpers.TestCalibrationMode(CurrentDataSet, mode));
Utils.CreateConfiguration(new_config);
(new eye_tracking_mouse.Options
{
calibration_mode = mode
}).SaveToFile(System.IO.Path.Combine(Utils.GetConfigurationDir(new_config), "options.json"));
for (int i = 0; i < 2; i++)
{
File.WriteAllText(
System.IO.Path.Combine(
Utils.GetConfigurationDir(new_config),
i == 0 ? "linear_results.json" : "linear_results_sorted.json"),
JsonConvert.SerializeObject(linear_search_reasults, Formatting.Indented));
linear_search_reasults.Sort((x, y) => { return((int)((x.utility - y.utility) * 1000)); });
}
if (extremum_search_results == null)
{
return;
}
File.WriteAllText(
System.IO.Path.Combine(
Utils.GetConfigurationDir(new_config),
"extremum_search_results.json"),
JsonConvert.SerializeObject(extremum_search_results, Formatting.Indented));
}
float ComputeModeUtility(
eye_tracking_mouse.Options.CalibrationMode mode,
Dictionary <long, float> new_test_results,
TestResultsInfo info)
{
long key = iterator.GetUniqueKey(mode);
if (previous_test_results.ContainsKey(key))
{
info.cached_results_reused++;
return(previous_test_results[key]);
}
if (new_test_results.ContainsKey(key))
{
info.cached_results_reused++;
return(new_test_results[key]);
}
info.modes_tested++;
float utility = Helpers.GetCombinedUtility(Helpers.TestCalibrationMode(data_set, mode));
new_test_results.Add(key, utility);
return(utility);
}
public bool Increment(
eye_tracking_mouse.Options.CalibrationMode calibration_mode,
int steps_number)
{
int value = GetFieldValue(calibration_mode);
if (value == -1)
{
return(false);
}
int i = 0;
for (; i < Range.Length; i++)
{
if (Range[i] >= value)
{
break;
}
}
i += steps_number;
if (i < 0 || i >= Range.Length)
{
return(false);
}
SetFieldValue(calibration_mode, Range[i]);
return(true);
}
public long GetUniqueKey(eye_tracking_mouse.Options.CalibrationMode mode)
{
long retval = 0;
long current_step = 1;
foreach (var field in Fields)
{
int field_value = field.GetFieldValue(mode);
int i = 0;
for (; i < field.Range.Length; i++)
{
if (field.Range[i] == field_value)
{
break;
}
}
if (i == field.Range.Length)
{
MessageBox.Show("tried getting unique key for invalid mode");
Application.Current.Shutdown();
}
retval += current_step * i;
current_step *= field.Range.Length;
}
Debug.Assert(retval < NumberOfDifferentModes);
return(retval);
}
public void ForModeAndItsVariations(
eye_tracking_mouse.Options.CalibrationMode starting_mode,
Action <eye_tracking_mouse.Options.CalibrationMode, string> callback)
{
callback(starting_mode, "mid");
for (int i = 0; i < 2; i++)
{
eye_tracking_mouse.Options.CalibrationMode mode = starting_mode.Clone();
for (int field_number = 0; field_number < Fields.Count; field_number++)
{
if (i == 0)
{
Fields[field_number].SetFieldValue(mode, Fields[field_number].Range.Last());
}
else
{
var range = Fields[field_number].Range;
Fields[field_number].SetFieldValue(mode, (range[0] == 0 && range.Length > 1) ? range[1] : range[0]);
}
}
callback(mode, i == 0 ? "max" : "min");
}
}
public UtilityAndModePair(
float utility,
eye_tracking_mouse.Options.CalibrationMode mode)
{
this.utility = utility;
this.mode = mode;
}
public static eye_tracking_mouse.ICalibrationManager SetupCalibrationManager(eye_tracking_mouse.Options.CalibrationMode calibration_mode)
{
eye_tracking_mouse.FilesSavingQueue.DisabledForTesting = true;
var calibration_manager = eye_tracking_mouse.CalibrationManager.BuildCalibrationManagerForTesting(calibration_mode);
calibration_manager.Reset();
return(calibration_manager);
}
public ConfigurationTestVisualisationWindow(string configuration, List <DataPoint> data_points)
{
InitializeComponent();
this.data_points = data_points;
calibration_mode = Helpers.GetCalibrationMode(configuration);
calibration_manager = Helpers.SetupCalibrationManager(calibration_mode);
this.configuration = configuration ?? "User Data";
this.Closing += ConfigurationTestVisualisationWindow_Closing;
this.KeyDown += ConfigurationTestVisualisationWindow_KeyDown;
OnCurrentPointChanged();
}
public ExtremumSearcher(
eye_tracking_mouse.Options.CalibrationMode starting_mode,
List <DataPoint> data_points,
Action <TestResultsInfo> test_results_info_callback,
CancellationToken cancellation_token)
{
this.data_points = data_points;
this.cancellation_token = cancellation_token;
this.test_results_info_callback = test_results_info_callback;
extremums_queue.Add(new UtilityAndModePair(0, starting_mode));
}
public AlgorithmVersionControlModel(Action redraw_callback,
eye_tracking_mouse.Options.CalibrationMode mode)
{
calibration_mode = mode;
for (int i = 0; i < algorithms.Length; i++)
{
if (algorithms[i] == mode.algorithm)
{
selected_algorithm = i;
}
}
redraw = redraw_callback;
}
public ExtremumSearcher(
eye_tracking_mouse.Options.CalibrationMode starting_mode,
DataSet data_set,
Action <TestResultsInfo> test_results_info_callback,
CancellationToken cancellation_token)
{
this.data_set = data_set;
this.cancellation_token = cancellation_token;
this.test_results_info_callback = test_results_info_callback;
iterator = new CalibrationModeIterator(starting_mode);
handled_extremums.Add(iterator.GetUniqueKey(starting_mode));
extremums_queue.Add(new UtilityAndModePair(0, starting_mode));
}
public CalibrationModeIterator(eye_tracking_mouse.Options.CalibrationMode mode)
{
CalibrationMode = mode;
var fields = new OptionsField[]
{
OptionsField.BuildHardcoded(field_name: "zone_size", new List <int> {
10, 15, 25, 50, 75, 100, 150, 200, 250, 350, 500, 800
}),
OptionsField.BuildExponential(field_name: "max_zones_count", 8, 2048, 2, false),
OptionsField.BuildHardcoded(field_name: "considered_zones_count", new List <int> {
3, 4, 5, 6, 8, 10, 14, 20, 30
}),
OptionsField.BuildHardcoded(field_name: "considered_zones_count_v1", new List <int> {
3, 4, 5, 6, 8, 10, 14, 20, 30
}),
OptionsField.BuildHardcoded(field_name: "shade_thickness_in_pixels", new List <int> {
5, 10, 25, 50
}),
OptionsField.BuildLinear(field_name: "size_of_opaque_sector_in_percents", max: 70, min: 30, step: 10),
OptionsField.BuildHardcoded(field_name: "correction_fade_out_distance", new List <int> {
50, 75, 100, 150, 200, 250, 350, 500, 800
}),
OptionsField.BuildExponential(field_name: "coordinate 2", 50, 30000, 1.6f, true),
OptionsField.BuildExponential(field_name: "coordinate 3", 50, 30000, 1.6f, true),
OptionsField.BuildExponential(field_name: "coordinate 4", 50, 30000, 1.6f, true),
OptionsField.BuildExponential(field_name: "coordinate 5", 50, 30000, 1.6f, true),
OptionsField.BuildExponential(field_name: "coordinate 6", 50, 30000, 1.6f, true),
OptionsField.BuildExponential(field_name: "coordinate 7", 50, 30000, 1.6f, true),
OptionsField.BuildExponential(field_name: "coordinate 8", 50, 30000, 1.6f, true),
OptionsField.BuildExponential(field_name: "coordinate 9", 50, 30000, 1.6f, true),
//OptionsField.BuildHardcoded(field_name : "coordinate 2", new List<int> {50, 100, 250, 400, 600, 800, 1000, 1300, 1700, 2500, 5000, 7500, 10000, 12000 }),
//OptionsField.BuildHardcoded(field_name : "coordinate 3", new List<int> {50, 100, 250, 400, 600, 800, 1000, 1300, 1700, 2500, 5000, 7500, 10000, 12000 }),
//OptionsField.BuildHardcoded(field_name : "coordinate 4", new List<int> {50, 100, 250, 400, 600, 800, 1000, 1300, 1700, 2500, 5000, 7500, 10000, 12000 }),
//OptionsField.BuildHardcoded(field_name : "coordinate 5", new List<int> {50, 100, 250, 400, 600, 800, 1000, 1300, 1700, 2500, 5000, 7500, 10000, 12000 }),
//OptionsField.BuildHardcoded(field_name : "coordinate 6", new List<int> {50, 100, 250, 400, 600, 800, 1000, 1300, 1700, 2500, 5000, 7500, 10000, 12000 }),
//OptionsField.BuildHardcoded(field_name : "coordinate 7", new List<int> {50, 100, 250, 400, 600, 800, 1000, 1300, 1700, 2500, 5000, 7500, 10000, 12000 }),
//OptionsField.BuildHardcoded(field_name : "coordinate 8", new List<int> {50, 100, 250, 400, 600, 800, 1000, 1300, 1700, 2500, 5000, 7500, 10000, 12000 }),
//OptionsField.BuildHardcoded(field_name : "coordinate 9", new List<int> {50, 100, 250, 400, 600, 800, 1000, 1300, 1700, 2500, 5000, 7500, 10000, 12000 }),
};
foreach (var field in fields)
{
if (field.GetFieldValue(CalibrationMode) != -1)
{
Fields.Add(field);
}
}
}
List <UtilityAndModePair> FindNeighbourExtremums(
eye_tracking_mouse.Options.CalibrationMode starting_mode,
Dictionary <long, float> new_test_results)
{
List <UtilityAndModePair> retval = new List <UtilityAndModePair>();
for (int i = 0; i < iterator.Fields.Count - 2; i++)
{
var selected_fields = new List <CalibrationModeIterator.OptionsField> {
iterator.Fields[i],
iterator.Fields[i + 1],
iterator.Fields[i + 2],
};
retval.InsertRange(retval.Count, FindNeighbourExtremums(starting_mode, selected_fields, new_test_results));
}
return(retval);
}
public int GetFieldValue(
eye_tracking_mouse.Options.CalibrationMode calibration_mode)
{
if (field_name.StartsWith("coordinate"))
{
int coordinate_index = int.Parse(field_name.Split(' ')[1]);
if (coordinate_index >= calibration_mode.additional_dimensions_configuration.CoordinatesCount)
{
return(-1);
}
return(calibration_mode.additional_dimensions_configuration.CoordinatesScalesInPercents[coordinate_index]);
}
else
{
var field = calibration_mode.GetType().GetField(field_name);
return((int)field.GetValue(calibration_mode));
}
}
private void TryAddToLinearResults(float utility, eye_tracking_mouse.Options.CalibrationMode mode)
{
if (utility <= 0)
{
return;
}
foreach (var good_mode in results.linear_search_results)
{
if (good_mode.mode.Equals(mode))
{
good_mode.mode.tag_for_testing += "+" + mode.tag_for_testing;
return;
}
}
results.linear_search_results.Add(new UtilityAndModePair(utility, mode));
}
private void MaxOutEachDimension(
eye_tracking_mouse.Options.CalibrationMode mode,
DataSet data_set, string tag)
{
eye_tracking_mouse.Options.CalibrationMode local_best_calibration_mode = mode;
float local_best_utility = 0;
CalibrationModeIterator iterator = new CalibrationModeIterator(mode);
while (true)
{
float old_best_utility = local_best_utility;
foreach (var field in iterator.Fields)
{
var range = field.Range;
List <eye_tracking_mouse.Options.CalibrationMode> modes_to_test = new List <eye_tracking_mouse.Options.CalibrationMode>();
for (int i = 0; i < range.Length; i++)
{
eye_tracking_mouse.Options.CalibrationMode calibration_mode = local_best_calibration_mode.Clone();
field.SetFieldValue(calibration_mode, range[i]);
modes_to_test.Add(calibration_mode);
}
RunTests(data_set, modes_to_test, ref local_best_calibration_mode, ref local_best_utility);
}
number_of_local_iterations++;
Dispatcher.BeginInvoke((Action)(() =>
{
Text_LastIterationUtilityDelta.Text = "Last Iteration Utility Delta: " + (local_best_utility - old_best_utility);
}));
if (local_best_utility == old_best_utility)
{
break;
}
}
local_best_calibration_mode.tag_for_testing = tag + "_max_out";
TryAddToLinearResults(local_best_utility, local_best_calibration_mode);
}
public void SetFieldValue(
eye_tracking_mouse.Options.CalibrationMode calibration_mode, int value)
{
if (field_name.StartsWith("coordinate"))
{
int coordinate_index = int.Parse(field_name.Split(' ')[1]);
if (coordinate_index >= calibration_mode.additional_dimensions_configuration.CoordinatesCount)
{
return;
}
int[] coordinates_scales = calibration_mode.additional_dimensions_configuration.CoordinatesScalesInPercents;
coordinates_scales[coordinate_index] = value;
calibration_mode.additional_dimensions_configuration.CoordinatesScalesInPercents = coordinates_scales;
}
else
{
var field = calibration_mode.GetType().GetField(field_name);
field.SetValue(calibration_mode, value);
}
}
public void ForEachMinMaxPermutation(
eye_tracking_mouse.Options.CalibrationMode starting_mode,
Action <eye_tracking_mouse.Options.CalibrationMode> callback)
{
callback(starting_mode);
long iterator = 1;
foreach (var field in Fields)
{
// two additional permutations
iterator *= 2;
}
List <long> permutations = new List <long>();
while (iterator > 0)
{
permutations.Add(iterator--);
}
permutations.Shuffle(new Random((int)(DateTime.Now.ToBinary() % int.MaxValue)));
foreach (var permutation in permutations)
{
eye_tracking_mouse.Options.CalibrationMode mode = starting_mode.Clone();
for (int field_number = 0; field_number < Fields.Count; field_number++)
{
if ((permutation & (1 << field_number)) == 0)
{
Fields[field_number].SetFieldValue(mode, Fields[field_number].Range.Last());
}
else
{
Fields[field_number].SetFieldValue(mode, Fields[field_number].Range.First());
}
}
callback(mode);
}
}
static void ForEachFieldValue(
int field_index,
List <CalibrationModeIterator.OptionsField> fields,
eye_tracking_mouse.Options.CalibrationMode mode,
Action <eye_tracking_mouse.Options.CalibrationMode> action)
{
var field = fields[field_index];
field.SetFieldValue(mode, field.Min);
while (field.Increment(mode, 1))
{
if (field_index < fields.Count - 1)
{
ForEachFieldValue(field_index + 1, fields, mode, action);
}
else
{
action(mode);
}
}
}
private void RunTests(
DataSet data_set,
List <eye_tracking_mouse.Options.CalibrationMode> modes,
ref eye_tracking_mouse.Options.CalibrationMode local_best_mode,
ref float local_best_utility)
{
number_of_tests += modes.Count;
Dispatcher.BeginInvoke((Action)(() =>
{
Text_ProgressInfo.Text =
"Total Runned Tests: " + number_of_tests +
". Local Iterations: " + number_of_local_iterations +
". Global Iterations " + number_of_global_iterations +
". MinMax Permutations " + remaining_min_max_permutations + "/" + total_min_max_permutations;
}));
cancellation.Token.ThrowIfCancellationRequested();
List <Task <Helpers.TestResult[]> > tasks = new List <Task <Helpers.TestResult[]> >();
foreach (var mode in modes)
{
cancellation.Token.ThrowIfCancellationRequested();
tasks.Add(Task.Factory.StartNew <Helpers.TestResult[]>(() =>
{
return(Helpers.TestCalibrationMode(data_set, mode));
}));
}
eye_tracking_mouse.Options.CalibrationMode best_mode = null;
float best_utility = 0;
for (int i = 0; i < tasks.Count; i++)
{
float task_utility = Helpers.GetCombinedUtility(tasks[i].Result);
if (best_mode == null || task_utility > best_utility)
{
best_utility = task_utility;
best_mode = modes[i];
}
}
Dispatcher.BeginInvoke((Action)(() =>
{
Text_LastTestResult.Text = "Last test results " + best_utility + " \n" + JsonConvert.SerializeObject(best_mode, Formatting.Indented);
}));
Debug.Assert(results.best_calibration_mode.utility >= local_best_utility);
if (best_utility > results.best_calibration_mode.utility)
{
results.best_calibration_mode = new UtilityAndModePair(best_utility, best_mode);
Dispatcher.BeginInvoke((Action)(() =>
{
Text_GlobalBestModeInfo.Text = "Global Best Calibration Mode " + best_utility;
}));
}
if (best_utility > local_best_utility)
{
local_best_utility = best_utility;
local_best_mode = best_mode;
Dispatcher.BeginInvoke((Action)(() =>
{
Text_LocalBestModeInfo.Text = "Local Best Calibration Mode " + best_utility;
}));
}
}
public static void UniqueKeysAreUnique(eye_tracking_mouse.Options.CalibrationMode mode)
{
var unique_keys = new HashSet <long>();
var iterator = new CalibrationModeIterator(mode);
foreach (var field in iterator.Fields)
{
field.SetFieldValue(mode, field.Min);
}
for (int i = 0; i < 10; i++)
{
foreach (var field in iterator.Fields)
{
if (field.Increment(mode, 1))
{
long key = iterator.GetUniqueKey(mode);
Assert(!unique_keys.Contains(key));
unique_keys.Add(key);
}
}
}
unique_keys.Clear();
foreach (var field in iterator.Fields)
{
field.SetFieldValue(mode, field.Min);
}
long tests_to_run = 1000000;
try
{
ForEachFieldValue(0, iterator.Fields, mode, (x) => {
if (--tests_to_run < 0)
{
throw new NotImplementedException("Удалые пляски на костылях.");
}
else
{
long key = iterator.GetUniqueKey(x);
Assert(!unique_keys.Contains(key));
unique_keys.Add(key);
}
});
} catch (NotImplementedException)
{
Assert(tests_to_run < 0);
}
foreach (var field in iterator.Fields)
{
field.SetFieldValue(mode, field.Min);
}
tests_to_run = 1000001;
try
{
ForEachFieldValue(0, iterator.Fields, mode, (x) => {
if (--tests_to_run < 0)
{
throw new NotImplementedException("Удалые пляски на костылях.");
}
else if (tests_to_run == 0)
{
long key = iterator.GetUniqueKey(x);
Assert(!unique_keys.Contains(key));
}
else
{
long key = iterator.GetUniqueKey(x);
Assert(unique_keys.Contains(key));
}
});
}
catch (NotImplementedException)
{
Assert(tests_to_run < 0);
}
}
private void IncrementalImprove(
eye_tracking_mouse.Options.CalibrationMode mode,
DataSet data_set,
string tag)
{
eye_tracking_mouse.Options.CalibrationMode local_best_calibration_mode = mode;
float local_best_utility = 0;
RunTests(
data_set,
new List <eye_tracking_mouse.Options.CalibrationMode> {
local_best_calibration_mode
},
ref local_best_calibration_mode,
ref local_best_utility);
CalibrationModeIterator iterator = new CalibrationModeIterator(mode);
int steps_number = 0;
while (true)
{
float old_best_utility = local_best_utility;
List <eye_tracking_mouse.Options.CalibrationMode> modes_to_test = new List <eye_tracking_mouse.Options.CalibrationMode>();
for (int i = 0; i < iterator.Fields.Count; i++)
{
var field = iterator.Fields[i];
eye_tracking_mouse.Options.CalibrationMode calibration_mode = local_best_calibration_mode.Clone();
if (field.Increment(calibration_mode, steps_number))
{
modes_to_test.Add(calibration_mode);
}
calibration_mode = local_best_calibration_mode.Clone();
if (field.Increment(calibration_mode, -steps_number))
{
modes_to_test.Add(calibration_mode);
}
}
if (modes_to_test.Count == 0)
{
break;
}
RunTests(data_set, modes_to_test, ref local_best_calibration_mode, ref local_best_utility);
if (local_best_utility == old_best_utility)
{
steps_number++;
}
else
{
steps_number = 0;
}
number_of_local_iterations++;
Dispatcher.BeginInvoke((Action)(() =>
{
Text_LastIterationUtilityDelta.Text = "Last Iteration Utility Delta: " + (local_best_utility - old_best_utility);
}));
}
local_best_calibration_mode.tag_for_testing = tag + "_incremental";
TryAddToLinearResults(local_best_utility, local_best_calibration_mode);
}
public static Helpers.TestResult[] TestCalibrationMode(DataSet data_set, eye_tracking_mouse.Options.CalibrationMode calibration_mode)
{
return(TestCalibrationManager(SetupCalibrationManager(calibration_mode),
data_set, calibration_mode.additional_dimensions_configuration));
}
public static string GetUniqueKey(this eye_tracking_mouse.Options.CalibrationMode mode)
{
return(JsonConvert.SerializeObject(mode, Formatting.None));
}
private static bool IsModeCorrect(eye_tracking_mouse.Options.CalibrationMode mode)
{
return
(mode.size_of_opaque_sector_in_percents + mode.size_of_transparent_sector_in_percents < 91);
}
public static Helpers.TestResult TestCalibrationMode(List <DataPoint> data_points, eye_tracking_mouse.Options.CalibrationMode calibration_mode)
{
if (!IsModeCorrect(calibration_mode))
{
return(new Helpers.TestResult());
}
return(TestCalibrationManager(SetupCalibrationManager(calibration_mode),
data_points, calibration_mode.additional_dimensions_configuration));
}
List <UtilityAndModePair> FindNeighbourExtremums(
eye_tracking_mouse.Options.CalibrationMode starting_mode,
List <CalibrationModeIterator.OptionsField> options_to_iterate)
{
TestResultsInfo test_results_info = new TestResultsInfo {
cached_results_reused = 0, modes_tested = 0
};
int i_max = options_to_iterate[0].Range.Length;
int j_max = options_to_iterate[1].Range.Length;
int k_max = options_to_iterate[2].Range.Length;
Debug.Assert(options_to_iterate.Count == 3);
var test_results = new UtilityAndModePair[i_max, j_max, k_max];
for (int i = 0; i < i_max; i++)
{
for (int j = 0; j < j_max; j++)
{
for (int k = 0; k < k_max; k++)
{
var mode = starting_mode.Clone();
options_to_iterate[0].SetFieldValue(mode, options_to_iterate[0].Range[i]);
options_to_iterate[1].SetFieldValue(mode, options_to_iterate[1].Range[j]);
options_to_iterate[2].SetFieldValue(mode, options_to_iterate[2].Range[k]);
cancellation_token.ThrowIfCancellationRequested();
test_results[i, j, k] =
new UtilityAndModePair(
Helpers.TestCalibrationMode(data_points, mode).UtilityFunction,
mode);
test_results_info.modes_tested++;
}
}
}
test_results_info_callback(test_results_info);
HashSet <int> non_extremum_indexes = new HashSet <int>();
List <UtilityAndModePair> extremums = new List <UtilityAndModePair>();
for (int i = 0; i < i_max; i++)
{
for (int j = 0; j < j_max; j++)
{
for (int k = 0; k < k_max; k++)
{
bool is_extremum = true;
if (non_extremum_indexes.Contains(ConvertIndexesToSingleInt(i, j, k, i_max, j_max)))
{
is_extremum = false;
}
// n means neighbor
for (int n_i = Math.Max(0, i - 1); n_i <= i + 1 && n_i < i_max; n_i++)
{
for (int n_j = Math.Max(0, j - 1); n_j <= j + 1 && n_j < j_max; n_j++)
{
for (int n_k = Math.Max(0, k - 1); n_k <= k + 1 && n_k < k_max; n_k++)
{
if (i == n_i && j == n_j && k == n_k)
{
continue;
}
if (test_results[i, j, k].utility < test_results[n_i, n_j, n_k].utility)
{
is_extremum = false;
}
else if (test_results[i, j, k].utility == test_results[n_i, n_j, n_k].utility)
{
non_extremum_indexes.Add(ConvertIndexesToSingleInt(
n_i,
n_j,
n_k,
i_max,
j_max));
}
}
}
}
if (is_extremum)
{
extremums.Add(test_results[i, j, k]);
}
}
}
}
return(extremums);
}