private void RaiseEvidenceEntered(VertexEvidence vertexEvidence)
{
if (this.EvidenceEntered != null)
{
this.EvidenceEntered(this, vertexEvidence);
}
}
private LineDataTable PopulateData(LineDataTable newTable, LineDataTable table)
{
if (newTable != null && table != null)
{
foreach (DataRow newrow in newTable.Rows)
{
foreach (DataRow oldrow in table.Rows)
{
if ((double)newrow["From"] >= (double)oldrow["From"] &&
(double)newrow["To"] <= (double)oldrow["To"])
{
var count = 2; // skipping "From" and "To" coloumns
while (count < newTable.Columns.Count)
{
var evidence = new VertexEvidence();
evidence.Value = (oldrow[count] as VertexEvidence).Value;
// newrow[count] = oldrow[count];
newrow[count] = evidence;
count++;
}
}
}
}
}
return(newTable);
}
private void RaiseEvidenceEntered(VertexEvidence vertexEvidence = null)
{
if (this.EvidenceEntered != null)
{
this.EvidenceEntered(this, vertexEvidence);
}
if (!this.IsAutoRunEnabled)
{
return;
}
if (this.Graph != null)
{
this.Graph.Belief = this.Network.Run(this.Graph.Evidence);
}
}
private void GraphControl_EvidenceEntered(object sender, VertexEvidence vertexEvidence)
{
if (this.selectedRow != null && this.SelectedColumnName != null && this.SelectedVertex != null)
{
var selectRow = this.PipeLineData.UserDataObj[this.SelectedVertex.Key].UserTable.FirstOrDefault(row => row.Equals(this.selectedRow));
if (selectRow != null)
{
selectRow[this.SelectedColumnName] = vertexEvidence;
}
}
if (vertexEvidence == null)
{
// this.LineDataChart.RemoveUserEvidence(this.GetChartCategory());
// this.LineDataControl.ClearSelectedCell();
}
}
public static SheetModel Read(Worksheet worksheet)
{
var sheetModel = new SheetModel();
var row = 1;
var col = 1;
var key = worksheet.ReadText(row, col);
var value = worksheet.Read(row, col + 1);
while (key != null)
{
sheetModel.SheetHeaders[key] = value;
row++;
key = worksheet.ReadText(row, col);
value = worksheet.Read(row, col + 1);
}
// Go to next row
row++;
// This row should contain the column headers.
var columnHeader = worksheet.ReadText(row, col);
while (columnHeader != null)
{
sheetModel.ColumnHeaders.Add(columnHeader);
col++;
columnHeader = worksheet.ReadText(row, col);
}
sheetModel.StartYear = Convert.ToInt32(sheetModel.SheetHeaders["Start Year"]);
sheetModel.EndYear = Convert.ToInt32(sheetModel.SheetHeaders["End Year"]);
var fileName = sheetModel.SheetHeaders["Network File"].ToString();
sheetModel.Network = Network.Read(fileName);
sheetModel.Graph = Graph.Read(sheetModel.Network);
// For the vertex blocks we work with find.
Range firstFind = null;
var currentFind = worksheet.Cells.Find("Belief");
while (currentFind != null)
{
if (firstFind == null)
{
firstFind = currentFind;
}
else if (currentFind.Address == firstFind.Address)
{
break;
}
row = currentFind.Row;
col = currentFind.Column;
// Get sectionId
var sectionId = worksheet.ReadText(row, 1);
if (!sheetModel.LineEvidence.ContainsKey(sectionId))
{
sheetModel.LineEvidence[sectionId] = new Dict <int, string, VertexEvidence>();
}
// Get vertexKey
var vertexKey = worksheet.ReadText(sheetModel.SheetHeaders.Count + 2, col);
var vertex = sheetModel.Graph.Vertices[vertexKey];
col++;
for (var year = sheetModel.StartYear; year <= sheetModel.EndYear; year++)
{
value = worksheet.Read(row, col);
if (value != null)
{
var evidence = vertex.States.ParseEvidenceString(value.ToString());
sheetModel.LineEvidence[sectionId][year][vertexKey] = evidence;
}
else
{
var vertexEvidence = new VertexEvidence
{
Value = new double[vertex.States.Count]
};
var isEvidenceNull = true;
foreach (var state in vertex.States)
{
var i = vertex.States.IndexOf(state);
var stateValue = worksheet.Read(row + i + 1, col);
if (stateValue == null)
{
vertexEvidence.Value[i] = 0;
}
else
{
isEvidenceNull = false;
vertexEvidence.Value[i] = Convert.ToDouble(stateValue);
}
}
if (!isEvidenceNull)
{
sheetModel.LineEvidence[sectionId][year][vertexKey] = vertexEvidence;
}
}
col++;
}
currentFind = worksheet.Cells.FindNext(currentFind);
}
return(sheetModel);
}
private void VertexControl_EvidenceEntered(object sender, VertexEvidence e)
{
this.RaiseEvidenceEntered(e);
}
public static Dict <string, EvidenceTable> Merge(Dict <string, NodeData> userDataObj, List <double> baseRowsList, Network network)
{
var unmergedEvidenceSet = new Dict <string, EvidenceTable>();
var mergedEvidenceSet = new Dict <string, EvidenceTable>();
var newList = new List <double>();
if (baseRowsList != null)
{
newList = baseRowsList.ToList();
}
foreach (var kvp in userDataObj)
{
foreach (var row in kvp.Value.UserTable)
{
var colNames = row.GetDynamicMemberNames().ToList();
foreach (var colName in colNames)
{
if (row[colName] == "")
{
row[colName] = new VertexEvidence {
Type = VertexEvidenceType.Null
};
}
}
}
}
// Remove Empty EvidenceTables
var deleteNodes = new List <string>();
foreach (var kvp in userDataObj)
{
if (!kvp.Value.UserTable.Any())
{
deleteNodes.Add(kvp.Key);
}
else
{
var isEmpty = true;
foreach (var row in kvp.Value.UserTable)
{
foreach (var colName in row.GetDynamicMemberNames().ToList())
{
if ((row[colName] as VertexEvidence).Type != VertexEvidenceType.Null)
{
isEmpty = false;
}
if ((row[colName] as VertexEvidence).Type == VertexEvidenceType.Invalid)
{
row[colName] = new VertexEvidence {
Type = VertexEvidenceType.Null
};
}
}
}
if (isEmpty)
{
deleteNodes.Add(kvp.Key);
}
}
}
foreach (var key in deleteNodes)
{
userDataObj.Remove(key);
}
foreach (var kvp in userDataObj)
{
unmergedEvidenceSet.Add(kvp.Key, kvp.Value.UserTable);
}
// Generate a list which holds the modified section ranges
foreach (var kvp in unmergedEvidenceSet)
{
var evidenceTable = kvp.Value;
foreach (var evidenceRow in evidenceTable)
{
newList.Add(evidenceRow.From);
newList.Add(evidenceRow.To);
}
}
newList.Sort(); // sorting the new list
foreach (var kvp in unmergedEvidenceSet)
{
var unmergeEvidenceTableKey = kvp.Key;
var unmergedEvidenceTable = kvp.Value;
if (unmergedEvidenceTable.Count == 0)
{
continue;
}
var mergedEvidenceTable = new EvidenceTable(unmergedEvidenceTable.DateTimes);
for (var i = 0; i < newList.Count - 1; i++)
{
var evidenceRow = new EvidenceRow {
From = newList[i], To = newList[i + 1]
};
// If this is a point feature and no table contains it, then don't add.
if (!unmergedEvidenceSet.Contains(evidenceRow) && newList[i] == newList[i + 1])
{
continue;
}
// multiple inputs for a single point feature are allowed
if (unmergedEvidenceSet.Contains(evidenceRow) && newList[i] == newList[i + 1])
{
mergedEvidenceTable.Add(evidenceRow);
}
else
{
mergedEvidenceTable.AddUnique(evidenceRow);
}
}
EvidenceRow uniqueRow = null;
var deleteRows = new ObservableCollection <EvidenceRow>();
foreach (var mergedEvidenceRow in mergedEvidenceTable)
{
if (uniqueRow == null)
{
uniqueRow = mergedEvidenceRow;
continue;
}
if (mergedEvidenceRow.From == uniqueRow.From && mergedEvidenceRow.To == uniqueRow.To)
{
deleteRows.Add(mergedEvidenceRow);
}
else
{
uniqueRow = mergedEvidenceRow;
}
}
mergedEvidenceTable.Remove(deleteRows);
foreach (var mergedEvidenceRow in mergedEvidenceTable)
{
var unmergedEvidenceRows = unmergedEvidenceTable.Where(row => row.Contains(mergedEvidenceRow)).ToList();
var columnNames = mergedEvidenceRow.GetDynamicMemberNames().ToList();
if (unmergedEvidenceRows.Count() > 1) // merged section has multiple input values
{
var avgEvidenceValues = GetEvidenceAverage(unmergedEvidenceRows, network.Vertices[unmergeEvidenceTableKey].States.Count());
foreach (var columnName in columnNames)
{
var evidenceString = avgEvidenceValues[columnName].ValueToDistribution();
mergedEvidenceRow[columnName] = network.Vertices[unmergeEvidenceTableKey].States.ParseEvidenceString(evidenceString);
}
}
else
{
foreach (var columnName in columnNames)
{
mergedEvidenceRow[columnName] = !unmergedEvidenceRows.Any()
? new VertexEvidence {
Type = VertexEvidenceType.Null
}
: unmergedEvidenceRows.FirstOrDefault()[columnName];
}
}
}
mergedEvidenceSet.Add(unmergeEvidenceTableKey, mergedEvidenceTable);
}
return(mergedEvidenceSet);
}
private void Plot(EvidenceRow dataRow, string columnName)
{
var fillBrush = new SolidColorBrush(Colors.Goldenrod);
var strokeBrush = new SolidColorBrush(Colors.Goldenrod);
var from = (double)dataRow["From"];
var to = (double)dataRow["To"];
var vertexEvidence = dataRow[columnName] as VertexEvidence;
if (vertexEvidence == null)
{
this.Chart.Annotations.Remove(annotation => ReferenceEquals(annotation.Tag, dataRow));
return;
}
if (vertexEvidence.Type == VertexEvidenceType.Invalid)
{
// MessageBox.Show("Invalid input entered");
dataRow[columnName] = new VertexEvidence {
Type = VertexEvidenceType.Null
};
return;
}
// Remove older annotations
this.Chart.Annotations.Remove(annotation => ReferenceEquals(annotation.Tag, dataRow));
this.Chart.AddNodeStateLines(this.SelectedVertex, this.PipeLineData.BaseTableMax, this.PipeLineData.BaseTableMin, this.VerticalAxis);
if (selectedTheme == DataTheme.User)
{
if (vertexEvidence.Type == VertexEvidenceType.Number)
{
if (from == to)
{
this.Chart.AddPointAnnotation(dataRow, columnName);
}
else
{
this.Chart.AddLineAnnotation(dataRow, columnName);
}
}
else if (vertexEvidence.Type == VertexEvidenceType.Range)
{
this.Chart.AddRangeAnnotation(dataRow, columnName);
}
else if (vertexEvidence.Type == VertexEvidenceType.State)
{
if (from == to)
{
this.Chart.AddPointAnnotation(dataRow, columnName);
}
else
{
this.Chart.AddLineAnnotation(dataRow, columnName);
}
}
else if (vertexEvidence.Type == VertexEvidenceType.Triangular)
{
this.Chart.AddTriangularDistributionAnnotation(this.SelectedVertex, dataRow, columnName);
}
else if (vertexEvidence.Type != VertexEvidenceType.Null)
{
this.Chart.AddInterpolatedDistributionAnnotation(this.SelectedVertex, dataRow, columnName);
}
}
else if (vertexEvidence.Type != VertexEvidenceType.Null)
{
this.Chart.AddInterpolatedDistributionAnnotation(this.SelectedVertex, dataRow, columnName);
}
}
