public HierarchicModel(Dictionary<GenerationParam, object> genParam,
AnalyseOptions options, Dictionary<AnalyzeOptionParam, Object> analizeOptionsValues)
: base(genParam, options, analizeOptionsValues)
{
log.Info("Creating Block-Hierarchic model object with generation parameters.");
InitModel();
}
public ValueTable(StAnalyzeResult stAnalyzeResult)
{
this.valueTableCaller = ValueTableCaller.StatisticAnalyzer;
this.currentResult = stAnalyzeResult;
this.currentOption = this.currentResult.result.Keys.First<AnalyseOptions>();
InitializeComponent();
}
public ParisiHierarchicModel(Dictionary<GenerationParam, object> genParam,
AnalyseOptions options, Dictionary<AnalyzeOptionParam, Object> analizeOptionsValues)
: base(genParam, options, analizeOptionsValues)
{
log.Info("Creating Block-Hierarchic Parisi model object from matrix.");
InitModel();
}
protected override bool ContainsOption(AnalyseOptions option)
{
switch (option)
{
case AnalyseOptions.ClusteringCoefficient:
return assemblyToAnalyze[0].Results[0].Coefficient.Keys.Count != 0;
case AnalyseOptions.DegreeDistribution:
return assemblyToAnalyze[0].Results[0].VertexDegree.Keys.Count != 0;
case AnalyseOptions.ConnSubGraph:
return assemblyToAnalyze[0].Results[0].Subgraphs.Keys.Count != 0;
case AnalyseOptions.MinPathDist:
return assemblyToAnalyze[0].Results[0].DistanceBetweenVertices.Count != 0;
case AnalyseOptions.EigenValue:
return assemblyToAnalyze[0].Results[0].EigenVector.Count != 0;
case AnalyseOptions.DistEigenPath:
return assemblyToAnalyze[0].Results[0].DistancesBetweenEigenValues.Count != 0;
case AnalyseOptions.Cycles:
return assemblyToAnalyze[0].Results[0].Cycles.Count != 0;
case AnalyseOptions.TriangleCountByVertex:
return assemblyToAnalyze[0].Results[0].TriangleCount.Count != 0;
case AnalyseOptions.TriangleTrajectory:
return assemblyToAnalyze[0].Results[0].TriangleTrajectory.Count != 0;
default:
return assemblyToAnalyze[0].Results[0].Result.Keys.Contains(option);
}
}
public ValueTable(AnalyseOptions option, Graphic caller)
{
this.parent = caller;
this.currentOption = option;
this.valueTableCaller = ValueTableCaller.Graphic;
InitializeComponent();
}
// Конструктор, в который входные параметры переходят от конструкторов дочерных классов.
// Передаются параметры генерации (подразумевается динамическая генерация).
public AbstractGraphModel(Dictionary<GenerationParam, object> genParam,
AnalyseOptions options,
Dictionary<AnalyzeOptionParam, Object> analyzeOptionsValues)
{
GenerationParamValues = genParam;
AnalyzeOptions = options;
AnalyzeOptionsValues = analyzeOptionsValues;
CurrentStatus = new GraphProgressStatus();
CurrentStatus.GraphProgress = GraphProgress.Initializing;
}
public CameraCalibrationViewModel(IEventAggregator eventAggregator)
{
_eventAggregator = eventAggregator;
AnalyseOpt = AnalyseOptions.Get();
OpenImageCommand = new DelegateCommand(OpenImageHandler);
AnalyseImageCommand = new DelegateCommand(AnalyseImageHandler);
AddCrossCommand = new DelegateCommand(AddCrossHandler);
CrossPosX = 0;
CrossPosY = 0;
ExportRawCorners = false;
}
public AnalyseMiddleware(RequestDelegate next, IHostingEnvironment hostingEnv, IOptions <AnalyseOptions> options)
{
if (next == null)
{
throw new ArgumentNullException("next");
}
if (hostingEnv == null)
{
throw new ArgumentNullException("hostingEnv");
}
if (options == null)
{
throw new ArgumentNullException("options");
}
this._next = next;
this._options = options.Value;
this._environment = hostingEnv;
}
protected abstract bool ContainsOption(AnalyseOptions option);
protected override SortedDictionary<double, double> FillLocalResult(AnalyseOptions option)
{
SortedDictionary<double, double> r = new SortedDictionary<double, double>();
SortedDictionary<int, int> tempDictionary;
for (int i = 0; i < assemblyToAnalyze.Count(); ++i)
{
int size, instanceCount = assemblyToAnalyze[i].Results.Count();
for (int j = 0; j < instanceCount; ++j)
{
size = assemblyToAnalyze[i].Results[j].Size;
switch (option)
{
case AnalyseOptions.DegreeDistribution:
{
tempDictionary = assemblyToAnalyze[i].Results[j].VertexDegree;
break;
}
case AnalyseOptions.ConnSubGraph:
{
tempDictionary = assemblyToAnalyze[i].Results[j].Subgraphs;
break;
}
case AnalyseOptions.MinPathDist:
{
tempDictionary = assemblyToAnalyze[i].Results[j].DistanceBetweenVertices;
break;
}
case AnalyseOptions.TriangleCountByVertex:
{
tempDictionary = new SortedDictionary<int, int>(); //assemblyToAnalyze[i].Results[j].TriangleCount;
break;
}
default:
{
throw (new SystemException("Unknown analyze option."));
}
}
SortedDictionary<int, int>.KeyCollection keyColl = tempDictionary.Keys;
int div = (option == AnalyseOptions.MinPathDist) ? (size * (size - 1) / 2) : size;
foreach (int key in keyColl)
{
if (r.Keys.Contains(key))
r[key] += (double)tempDictionary[key] / div;
else
r.Add(key, (double)tempDictionary[key] / div);
}
}
}
return r;
}
private void optionCmbBox_SelectedIndexChanged(object sender, EventArgs e)
{
AnalyseOptions option;
this.optionNames.TryGetValue(optionCmbBox.Text, out option);
this.currentOption = option;
SetColumnNames();
SetValues();
}
protected abstract SortedDictionary<double, double> FillLocalResult(AnalyseOptions option);
private void ShowInfo(AnalyseOptions option)
{
int index = 0;
for (int i = this.resultsList.Count - 1; i >= 0; --i)
{
if (resultsList[i].result.ContainsKey(option))
{
index = i;
break;
}
}
this.ModelNameTxt.Text = this.resultsList[index].modelName;
this.NetworkSizeTxt.Text = this.resultsList[index].networkSize.ToString();
this.realCoutTxt.Text = this.resultsList[index].realizationsCount.ToString();
if (this.resultsList[0].type == StAnalyzeType.Global)
{
double tmp;
this.resultsList[index].resultAvgValues.TryGetValue(option, out tmp);
this.AverageTxt.Text = tmp.ToString();
}
if (this.resultsList[0].type == StAnalyzeType.Local)
{
this.ApproximationTxt.Text = this.resultsList[0].approximationType.ToString();
StAnalyzeOptions stAnalyzeOptions;
this.resultsList[index].options.TryGetValue(option, out stAnalyzeOptions);
this.PropertyTxt.Text = stAnalyzeOptions.optionValue.ToString();
}
double temp;
this.resultsList[index].resultMathWaitings.TryGetValue(option, out temp);
this.MathWaitingTxt.Text = temp.ToString();
this.resultsList[index].resultDispersions.TryGetValue(option, out temp);
this.DispertionTxt.Text = temp.ToString();
}
private void generationCmbBox_SelectedIndexChanged(object sender, EventArgs e)
{
if (this.valueTableCaller == ValueTableCaller.Graphic)
{
this.currentResult = this.parent.resultsList[this.generationCmbBox.SelectedIndex];
if (this.isFirst == false)
{
this.currentOption = this.currentResult.result.Keys.First<AnalyseOptions>();
}
isFirst = false;
}
AddOptions();
}
//Draws Graph on each tab
private void HandleZedGraph(AnalyseOptions option)
{
ZedGraphControl zedGraph;
this.graphs.TryGetValue(option, out zedGraph);
if (zedGraph.GraphPane.CurveList.Count == 0)
{
SetNames(zedGraph.GraphPane, option);
}
PointPairList points = new PointPairList();
SortedDictionary<double, double> pointsDictionary;
double x, y;
this.resultsList[this.resultsList.Count - 1].result.TryGetValue(option, out pointsDictionary);
foreach (KeyValuePair<double, double> point in pointsDictionary)
{
x = point.Key;
y = point.Value;
if (this.resultsList[0].type == StAnalyzeType.Local &&
this.resultsList[0].approximationType != ApproximationTypes.None)
{
HandleApproximation(this.resultsList[0].approximationType, ref x, ref y);
}
points.Add(x, y);
}
zedGraph.GraphPane.Legend.FontSpec.Size = 8;
LineItem l = zedGraph.GraphPane.AddCurve(resultsList[resultsList.Count -1].parameterLine,
points, currentColor, SymbolType.Circle);
l.Line.IsVisible = this.currentPointView;
zedGraph.AxisChange();
zedGraph.Invalidate();
zedGraph.Refresh();
}
private void FillGlobalResult(AnalyseOptions option)
{
SortedDictionary<double, double> rValues = new SortedDictionary<double, double>();
for (int i = 0; i < assemblyToAnalyze.Count; ++i)
{
int instanceCount = assemblyToAnalyze[i].Results.Count;
for (int j = 0; j < instanceCount; ++j)
{
double index = (rValues.Count != 0) ? rValues.Last().Key : 0;
rValues.Add(index + 1, assemblyToAnalyze[i].Results[j].Result[option]);
}
}
result.result.Add(option, GetAverageValuesByDelta(rValues));
result.resultValues.Add(option, rValues);
}
private void LocalAnalyzeByOption(AnalyseOptions option)
{
if (ContainsOption(option))
{
SortedDictionary<double, double> tempResult;
switch (option)
{
case AnalyseOptions.ClusteringCoefficient:
{
tempResult = FillLocalResultCC();
break;
}
case AnalyseOptions.EigenValue:
{
tempResult = FillLocalResultEigen();
break;
}
case AnalyseOptions.DistEigenPath:
{
tempResult = FillLocalResultEigenDistance();
break;
}
case AnalyseOptions.Cycles:
{
tempResult = new SortedDictionary<double, double>(); //FillLocalResultCycles();
break;
}
case AnalyseOptions.TriangleTrajectory:
{
tempResult = FillLocalResultTrajectory();
break;
}
default:
{
tempResult = FillLocalResult(option);
break;
}
}
result.result.Add(option, GetLocalResult(option, tempResult));
}
}
// Передача выбранных свойств анализа для job-а в сессии с данным именем.
public static void SetSelectedOptions(string jobName, AnalyseOptions opt)
{
log.Info("Setting selected analyze options for a job in the session.");
session[jobName].SelectedOptions = opt;
}
public AvailableAnalyzeOptions(AnalyseOptions options)
{
Options = options;
}
/*private SortedDictionary<double, double> FillLocalResultCycles()
{
SortedDictionary<double, double> r = new SortedDictionary<double, double>();
for (int i = 0; i < assemblyToAnalyze.Count(); ++i)
{
int size = assemblyToAnalyze[i].Size;
int instanceCount = assemblyToAnalyze[i].Results.Count();
for (int j = 0; j < instanceCount; ++j)
{
SortedDictionary<int, long> tempDictionary = assemblyToAnalyze[i].Results[j].Cycles;
SortedDictionary<int, long>.KeyCollection keyColl = tempDictionary.Keys;
foreach (int key in keyColl)
{
if (r.Keys.Contains(key))
r[key] += (double)tempDictionary[key] / size;
else
r.Add(key, (double)tempDictionary[key] / size);
}
}
}
return r;
}*/
private SortedDictionary<double, double> GetLocalResult(AnalyseOptions option,
SortedDictionary<double, double> t)
{
SortedDictionary<double, double> r = new SortedDictionary<double, double>();
SortedDictionary<double, double>.KeyCollection keys = t.Keys;
foreach (double key in keys)
{
r.Add(key, t[key] / GetRealizationsCount());
}
FillMathWaitingsAndDispersions(r, option);
int thickening = 0;
if (analyzeOptions[option].useDelta)
thickening = (int)analyzeOptions[option].optionValue;
else
thickening = (int)Math.Ceiling(((analyzeOptions[option].optionValue * r.Count()) / 100));
return UseThickening(r, thickening);
}
private void FillMathWaitingsAndDispersions(SortedDictionary<double, double> r, AnalyseOptions option)
{
SortedDictionary<double, double>.KeyCollection keys = r.Keys;
switch (option)
{
case AnalyseOptions.TriangleTrajectory:
{
double avg = 0, sigma = 0;
foreach (double key in keys)
{
avg += r[key];
}
avg /= keys.Count();
foreach (double key in keys)
{
sigma += Math.Pow((avg - r[key]), 2);
}
sigma /= keys.Count();
sigma = Math.Sqrt(sigma);
result.resultMathWaitings.Add(option, avg);
result.resultDispersions.Add(option, sigma);
break;
}
case AnalyseOptions.EigenValue:
case AnalyseOptions.Cycles:
case AnalyseOptions.TriangleCountByVertex:
{
break;
}
default:
{
double mathWaiting = 0, mathWaitingSquare = 0;
foreach (double key in keys)
{
mathWaiting += key * r[key];
mathWaitingSquare += Math.Pow(key, 2) * r[key];
}
result.resultMathWaitings.Add(option, mathWaiting);
result.resultDispersions.Add(option, (mathWaitingSquare - Math.Pow(mathWaiting, 2)));
break;
}
}
}
protected override SortedDictionary<double, double> FillLocalResult(AnalyseOptions option)
{
SortedDictionary<double, double> r = new SortedDictionary<double, double>();
SortedDictionary<double, double> tempDictionary;
for (int i = 0; i < assemblyToAnalyze.Count(); ++i)
{
int instanceCount = assemblyToAnalyze[i].Results.Count();
switch (option)
{
case AnalyseOptions.DegreeDistribution:
{
tempDictionary = assemblyToAnalyze[i].VertexDegreeLocal;
break;
}
case AnalyseOptions.ConnSubGraph:
{
tempDictionary = assemblyToAnalyze[i].SubgraphsLocal;
break;
}
case AnalyseOptions.MinPathDist:
{
tempDictionary = assemblyToAnalyze[i].DistanceBetweenVerticesLocal;
break;
}
case AnalyseOptions.TriangleCountByVertex:
{
tempDictionary = new SortedDictionary<double, double>();
break;
}
default:
{
throw (new SystemException("Unknown analyze option."));
}
}
SortedDictionary<double, double>.KeyCollection keyColl = tempDictionary.Keys;
foreach (int key in keyColl)
{
if (r.Keys.Contains(key))
r[key] += tempDictionary[key] * instanceCount;
else
r.Add(key, tempDictionary[key] * instanceCount);
}
}
return r;
}
private void SetNames(GraphPane pane, AnalyseOptions option)
{
pane.Title.Text = option.ToString();
AnalyzeOptionInfo info = (AnalyzeOptionInfo)(option.GetType().GetField(option.ToString()).
GetCustomAttributes(typeof(AnalyzeOptionInfo), false)[0]);
if (this.resultsList[0].type == StAnalyzeType.Global)
{
pane.XAxis.Title.Text = info.GXAxis;
pane.YAxis.Title.Text = info.GYAxis;
}
else if (this.resultsList[0].type == StAnalyzeType.Local)
{
string x = info.LXAxis, y = info.LYAxis;
if (this.resultsList[0].approximationType != ApproximationTypes.None)
{
GetApproximationAxisNames(this.resultsList[0].approximationType, ref x, ref y);
}
pane.XAxis.Title.Text = x;
pane.YAxis.Title.Text = y;
}
}
private void GlobalAnalyzeByOption(AnalyseOptions option)
{
if (ContainsOption(option))
{
switch (option)
{
case AnalyseOptions.ClusteringCoefficient:
{
FillGlobalResultCC();
break;
}
case AnalyseOptions.DegreeDistribution:
{
FillGlobalResultDD();
break;
}
default:
{
FillGlobalResult(option);
break;
}
}
result.resultAvgValues.Add(option, GetGlobalAverage(result.result[option]));
}
}
private void ExtendedAnalyzeByOption(AnalyseOptions option, UInt32 stepsToRemove)
{
if (ContainsOption(option))
{
switch (option)
{
case AnalyseOptions.TriangleTrajectory:
{
FillExtendedResultTrajectory(stepsToRemove);
break;
}
default:
break;
}
}
}
