private void CreateNewBeliefDataSet(Dict <string, EvidenceTable> mergedDataSet)
{
if (this.BeliefsData.Count == 0 || this.BeliefsData[this.BeliefsData[0].Key].Count <
mergedDataSet.Values[0].Count)
{
var evidenceDateTime = mergedDataSet.Values[0].DateTimes;
var noOfEvidenceRows = mergedDataSet.Values[0].Count;
this.BeliefsData = new Dict <string, EvidenceTable>();
foreach (var vertex in this.Network.Vertices)
{
var beliefTable = new EvidenceTable(evidenceDateTime);
var i = 0;
while (i < noOfEvidenceRows)
{
var beliefRow = new EvidenceRow
{
From = mergedDataSet[0].Value[i].From,
To = mergedDataSet[0].Value[i].To
};
beliefTable.Add(beliefRow);
i++;
}
this.BeliefsData.Add(vertex.Key, beliefTable);
}
}
}
public PasteCommand(Vertex selVertex, List <GridViewCellClipboardEventArgs> pastedCells, List <Object> oldValues, int newPastedRowsCount, EvidenceTable table)
{
this.SelectedVertex = selVertex;
this.PastedCells = pastedCells;
this.PreviousValues = oldValues;
this.NewPastedRowsCount = newPastedRowsCount;
this.Table = table;
}
private Dict <string, EvidenceTable> CaptureInterpolatedData(Dict <string, EvidenceTable> mergedDataSet)
{
var interpolatedData = new Dict <string, EvidenceTable>();
//if (this.SelectedInterpolationData == null)
//{
// return interpolatedData;
//}
foreach (var kvp in this.PipeLineData.UserDataObj)
{
var interpolatedTable = new EvidenceTable(this.dates);
interpolatedData.Add(kvp.Key, interpolatedTable);
foreach (var column in kvp.Value.InterpolatedNodeData)
{
if (column.Value.Points == null)
{
continue;
}
this.SelectedInterpolationData = column.Value;
if (interpolatedTable.Count == 0)
{
foreach (var mergedEvidenceRow in mergedDataSet.Values[0])
{
var interpolatedRow = new EvidenceRow {
From = mergedEvidenceRow.From, To = mergedEvidenceRow.To
};
interpolatedTable.Add(interpolatedRow);
}
}
// interpolatedData.Add(kvp.Key, interpolatedTable);
foreach (var interpolatedRow in interpolatedTable)
{
var midRangeValue = (interpolatedRow.From + interpolatedRow.To) / 2;
var evidenceString = this.SelectedInterpolationData.GetEvidenceString(midRangeValue, this.VerticalAxis.Equals(LinearAxis)?VertexAxisType.Linear: VertexAxisType.Logarithmic);
interpolatedRow[column.Key] = this.Network.Vertices[kvp.Key].States.ParseEvidenceString(evidenceString);
}
}
Console.WriteLine();
}
return(interpolatedData);
}
public NodeData()
{
this.InterpolatedNodeData = new Dict <string, InterpolationData>();
this.UserTable = new EvidenceTable();
}
public AddRowCommand(EvidenceTable table)
{
this.Table = table;
}
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);
}
