private DotForm EventTreeToDotForm(EventTree eventTree, string expertName, HydraulicCondition[] hydraulicConditions)
{
var nodes = new List <DotNode>();
foreach (var treeEvent in eventTree.MainTreeEvent.GetAllEventsRecursive())
{
nodes.Add(new DotNode
{
NodeName = treeEvent.Name,
Estimates = treeEvent.ClassesProbabilitySpecification.Where(e => e.Expert.Name == expertName).Select(s => new DotEstimate
{
WaterLevel = s.HydraulicCondition.WaterLevel,
Frequency = s.HydraulicCondition.Probability,
BestEstimate = (int)s.AverageEstimation,
LowerEstimate = (int)s.MinEstimation,
UpperEstimate = (int)s.MaxEstimation,
}).ToArray()
});
}
return(new DotForm
{
EventTreeName = eventTree.Name,
ExpertName = expertName,
GetFileStream = () => EventTreeToImageStream(eventTree),
Date = DateTime.Today,
Nodes = nodes.ToArray()
});
}
internal static EventTreeEntity Create(this EventTree model, PersistenceRegistry registry)
{
if (registry == null)
{
throw new ArgumentNullException(nameof(registry));
}
if (registry.Contains(model))
{
return(registry.Get(model));
}
var entity = new EventTreeEntity
{
Name = model.Name.DeepClone(),
Details = model.Details.DeepClone(),
Summary = model.Summary.DeepClone(),
Color = model.Color.ToHexString(),
TreeEventEntity = model.MainTreeEvent?.Create(registry),
NeedsSpecification = Convert.ToByte(model.NeedsSpecification)
};
registry.Register(model, entity);
return(entity);
}
public TreeEvent RemoveTreeEvent(EventTree eventTree, TreeEvent selectedTreeEventToRemove)
{
if (Equals(eventTree.MainTreeEvent, selectedTreeEventToRemove))
{
eventTree.MainTreeEvent = null;
eventTree.OnPropertyChanged(nameof(eventTree.MainTreeEvent));
return(null);
}
var parent = eventTree.MainTreeEvent.FindTreeEvent(treeEvent => treeEvent.FailingEvent == selectedTreeEventToRemove ||
treeEvent.PassingEvent == selectedTreeEventToRemove);
if (parent == null)
{
throw new ArgumentNullException();
}
if (parent.FailingEvent == selectedTreeEventToRemove)
{
parent.FailingEvent = null;
parent.OnPropertyChanged(nameof(parent.FailingEvent));
}
else
{
parent.PassingEvent = null;
parent.OnPropertyChanged(nameof(parent.PassingEvent));
}
return(parent);
}
private static EventTree CreateEventTree(string treeName, int numberTreeEvents)
{
var mainTreeEvent = new TreeEvent
{
Name = "First element"
};
var tree = new EventTree
{
Name = treeName,
MainTreeEvent = mainTreeEvent
};
var currentTreeEvent = mainTreeEvent;
for (int i = 0; i < numberTreeEvents - 1; i++)
{
var falseEvent = new TreeEvent
{
Name = string.Format("Event no. {0}", i + 1)
};
currentTreeEvent.FailingEvent = falseEvent;
currentTreeEvent = falseEvent;
}
return(tree);
}
internal static EventTree Read(this EventTreeEntity entity, ReadConversionCollector collector)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
if (collector == null)
{
throw new ArgumentNullException(nameof(collector));
}
if (collector.Contains(entity))
{
return(collector.Get(entity));
}
var eventTree = new EventTree
{
Name = entity.Name,
Details = entity.Details,
Summary = entity.Summary,
MainTreeEvent = entity.TreeEventEntity?.Read(collector),
Color = entity.Color.ToColor(),
NeedsSpecification = entity.NeedsSpecification == 1
};
collector.Collect(entity, eventTree);
return(eventTree);
}
public EventControl(EventTree pETree, GameObject pMessageCanvas, Pause pPausedControl, Text pMessageText, Text pDescriptionText, Functions pF, Player pP)
{
arrayEve = new List <Eve>();
eRoot = pETree;
messageCanvas = pMessageCanvas;
pausedControl = pPausedControl;
messageText = pMessageText;
descriptionText = pDescriptionText;
f = pF;
p = pP;
FileOpen(PATH, arrayEve);
Debug.Log("Test randomize");
/*for (int j = 0; j < 10; j++) {
* Debug.Log("Iteration:" + j);
* double r = rnd.NextDouble();
* for (int i = 0; i < arrayEve.Count; i++) {
* Eve tempEv = arrayEve[i];
* if (tempEv.getCondition().getCond()) {
* if (tempEv.getCondition().getProperty() > r) {
* Debug.Log("Random:" + r + " Name: " + tempEv.getSheath().getName() + " Property: " + tempEv.getCondition().getProperty());
* }
* }
* }
* }*/
}
public EventTreeViewModel()
{
var project = new Project();
projectManipulationService = new ProjectManipulationService(project);
EventTree = project.EventTrees.First();
EventTree.PropertyChanged += EventTreePropertyChanged;
}
// Use this for initialization
void Start()
{
eTree = new EventTree(null, "Story just begining");
ev = new EventControl(eTree, messageCanvas, pausedControl, messageText, descriptionText, f, p);
for (int i = 0; i < 5; i++)
{
coroutine = Gen(seconds, i);
StartCoroutine(coroutine);
}
}
public void StartEvent(int i)
{
Eve tempEv = arrayEve[i];
messageCanvas.SetActive(true);
messageCanvas.transform.Find("MessageEvent").GetComponent <Text>().text = tempEv.getSheath().getName();
messageCanvas.transform.Find("DescriptionEvent").GetComponent <Text>().text = tempEv.getSheath().getDescriprion();
pausedControl.paused = true;
p.evente();
Debug.Log("WEOWEOWEOWEOWEOWEOWEOWOEOWE");
run(i);
EventTree et = new EventTree(eRoot, tempEv.getSheath().getName());
eRoot.addChild(et);
}
public TreeEvent AddTreeEvent(EventTree eventTree, TreeEvent selectedTreeEventToAddTo, TreeEventType type)
{
var newTreeEvent = new TreeEvent
{
Name = "Nieuwe gebeurtenis"
};
foreach (var expert in project.Experts)
{
foreach (var hydraulicCondition in project.HydraulicConditions)
{
newTreeEvent.ClassesProbabilitySpecification.Add(new ExpertClassEstimation
{
Expert = expert,
HydraulicCondition = hydraulicCondition,
AverageEstimation = ProbabilityClass.None,
MinEstimation = ProbabilityClass.None,
MaxEstimation = ProbabilityClass.None
});
}
}
if (eventTree.MainTreeEvent == null)
{
eventTree.MainTreeEvent = newTreeEvent;
eventTree.OnPropertyChanged(nameof(eventTree.MainTreeEvent));
return(newTreeEvent);
}
switch (type)
{
case TreeEventType.Failing:
selectedTreeEventToAddTo.FailingEvent = newTreeEvent;
selectedTreeEventToAddTo.OnPropertyChanged(nameof(selectedTreeEventToAddTo.FailingEvent));
break;
case TreeEventType.Passing:
selectedTreeEventToAddTo.PassingEvent = newTreeEvent;
selectedTreeEventToAddTo.OnPropertyChanged(nameof(selectedTreeEventToAddTo.PassingEvent));
break;
}
return(newTreeEvent);
}
public void StartGenerate(int i)
{
double r = rnd.NextDouble();
Eve tempEv = arrayEve[i];
if (tempEv.getCondition().getCond())
{
if (tempEv.getCondition().getProperty() > r)
{
Debug.Log("Random:" + r + " Name: " + tempEv.getSheath().getName() + " Property: " + tempEv.getCondition().getProperty());
//GameObject newMC = (GameObject)GameObject.Instantiate(messageCanvas);
messageCanvas.SetActive(true);
messageCanvas.transform.Find("MessageEvent").GetComponent <Text>().text = tempEv.getSheath().getName();
messageCanvas.transform.Find("DescriptionEvent").GetComponent <Text>().text = tempEv.getSheath().getDescriprion();
pausedControl.paused = true;
p.evente();
Debug.Log("WEOWEOWEOWEOWEOWEOWEOWOEOWE");
run(i);
EventTree et = new EventTree(eRoot, tempEv.getSheath().getName());
eRoot.addChild(et);
}
}
}
private void OnUpdated(object sender, EventArgs eventArgs)
{
List <EventTree> trees = new List <EventTree>();
foreach (ClientThreadInfo threadInfo in _threads)
{
byte[] data = _callstacks.GetUnitedCallstack(threadInfo.Uid);
EventTree eventTree = new EventTree(threadInfo.Uid, data);
trees.Add(eventTree);
}
//_dispatcher.BeginInvoke((ThreadStart) (() =>
//{
_eventTree.Clear();
foreach (EventTree tree in trees)
{
_eventTree.Add(tree);
}
if (_menuAdapter.IsViewModelInitialized)
{
_dispatcher.BeginInvoke((ThreadStart)(() => _menuAdapter.ViewModel.Reload()));
}
//}));
}
public override void Load()
{
lock (loading)
{
if (!IsLoaded)
{
entries = ReadEventList(reader, DescriptionBoard);
root = new EventTree(this, Entries);
board = new Board<EventBoardItem, EventDescription, EventNode>(root);
reader = null;
IsLoaded = true;
}
}
}
private FileStream EventTreeToImageStream(EventTree eventTree)
{
return(null);
}
public EventTree(EventTree pParent, String pNameEvent)
{
parent = pParent;
nameEvent = pNameEvent;
}
internal bool Contains(EventTree model)
{
return(ContainsValue(eventTrees, model));
}
internal void Register(EventTree model, EventTreeEntity entity)
{
Register(eventTrees, model, entity);
}
public EventTreeEntity Get(EventTree model)
{
return(Get(eventTrees, model));
}
public EventTreeExportViewModel(EventTree eventTree)
{
this.eventTree = eventTree;
IsChecked = eventTree.NeedsSpecification;
}
public EventsThreadRow(FrameGroup group, ThreadDescription desc, ThreadData data)
{
Description = desc;
EventData = data;
Group = group;
MaxDepth = 1;
List <EventNode> rootCategories = new List <EventNode>();
List <EventNode> nodesToProcess = new List <EventNode>();
foreach (EventFrame frame in data.Events)
{
// Fill holes in timeline from regular events (not categories)
// ------------------------------------------------------------------------------------------------------
const double thresholdMs = 0.1;
EventTree categoriesTree = frame.CategoriesTree;
rootCategories.Clear();
foreach (EventNode node in frame.CategoriesTree.Children)
{
rootCategories.Add(node);
}
if (rootCategories.Count != 0)
{
nodesToProcess.Clear();
foreach (EventNode node in frame.Root.Children)
{
nodesToProcess.Add(node);
}
while (nodesToProcess.Count > 0)
{
EventNode node = nodesToProcess[0];
nodesToProcess.RemoveAt(0);
bool nodeIntersectWithCategories = false;
foreach (EventNode categoryNode in rootCategories)
{
// drop nodes less than thresholdMs ms
if (node.Entry.Duration < thresholdMs)
{
nodeIntersectWithCategories = true;
break;
}
// node is entirely inside the categoryNode
if (node.Entry.Start >= categoryNode.Entry.Start && node.Entry.Finish <= categoryNode.Entry.Finish)
{
nodeIntersectWithCategories = true;
break;
}
// node is partially inside the categoryNode
if (node.Entry.Intersect(categoryNode.Entry))
{
foreach (EventNode tmp in node.Children)
{
nodesToProcess.Add(tmp);
}
nodeIntersectWithCategories = true;
break;
}
}
if (nodeIntersectWithCategories == false && node.Entry.Duration >= thresholdMs)
{
// node is not intersect with any categoryNode (add to category tree)
EventNode fakeCategoryNode = new EventNode(frame.CategoriesTree, node.Entry);
node.Entry.SetOverrideColor(GenerateColorFromString(node.Entry.Description.FullName));
rootCategories.Add(fakeCategoryNode);
frame.CategoriesTree.Children.Add(fakeCategoryNode);
}
}
}
// ------------------------------------------------------------------------------------------------------
MaxDepth = Math.Max(frame.CategoriesTree.Depth, MaxDepth);
}
}
public void addChild(EventTree child)
{
childs.Add(child);
}
public EventTreeViewModel([NotNull] EventTree eventTree, ProjectManipulationService projectManipulationService)
{
EventTree = eventTree;
this.projectManipulationService = projectManipulationService;
eventTree.PropertyChanged += EventTreePropertyChanged;
}
internal void Collect(EventTreeEntity entity, EventTree model)
{
Collect(eventTrees, entity, model);
}
public override void BuildMesh(DirectX.DirectXCanvas canvas, ThreadScroll scroll)
{
SetBusy(true);
UpdateDepth();
// Build Mesh
DirectX.ComplexDynamicMesh builder = new ComplexDynamicMesh(canvas, DIPSplitCount);
DirectX.ComplexDynamicMesh syncBuilder = new ComplexDynamicMesh(canvas, DIPSplitCount);
DirectX.ComplexDynamicMesh syncWorkBuilder = new ComplexDynamicMesh(canvas, DIPSplitCount);
if (EventData.Sync != null && EventData.Sync != null)
{
SyncReason stallReason = SyncReason.SyncReasonCount;
long stallFrom = 0;
int frameSyncIndex = 0;
for (int i = 0; i < EventData.Sync.Count; i++)
{
SyncInterval sync = EventData.Sync[i];
Interval workInterval = scroll.TimeToUnit(sync);
//draw work
int coreColorIndex = (int)sync.Core;
coreColorIndex = coreColorIndex % WorkColors.Length;
Color WorkColor = WorkColors[coreColorIndex];
syncWorkBuilder.AddRect(new Rect(workInterval.Left, 0, workInterval.Right - workInterval.Left, SyncLineHeight / Height), WorkColor);
if (i == 0)
{
stallReason = sync.Reason;
stallFrom = sync.Finish;
continue;
}
long workStart = sync.Start;
long workFinish = sync.Finish;
while (frameSyncIndex < EventData.Events.Count && EventData.Events[frameSyncIndex].Finish < stallFrom)
{
++frameSyncIndex;
}
//Ignoring all the waiting outside marked work to simplify the view
if (frameSyncIndex < EventData.Events.Count && EventData.Events[frameSyncIndex].Start <= workStart)
{
Durable syncDurable = new Durable(stallFrom, workStart);
Interval syncInterval = scroll.TimeToUnit(syncDurable);
double syncWidth = syncInterval.Right - syncInterval.Left;
if (syncWidth > 0)
{
// draw sleep
Color waitColor = IsUserInitiatedSync(stallReason) ? SynchronizationColorUser : SynchronizationColor;
syncBuilder.AddRect(new Rect(syncInterval.Left, 0, syncWidth, SyncLineHeight / Height), waitColor);
}
}
stallFrom = workFinish;
stallReason = sync.Reason;
}
}
foreach (EventFrame frame in EventData.Events)
{
Durable interval = Group.Board.TimeSlice;
EventTree tree = GetTree(frame);
foreach (EventNode node in tree.Children)
{
BuildMeshNode(builder, scroll, node, 0);
}
}
Blocks = builder.Freeze(canvas.RenderDevice);
SyncMesh = syncBuilder.Freeze(canvas.RenderDevice);
SyncWorkMesh = syncWorkBuilder.Freeze(canvas.RenderDevice);
CallstackMeshPolys = canvas.CreateMesh();
CallstackMeshPolys.Projection = Mesh.ProjectionType.Pixel;
CallstackMeshLines = canvas.CreateMesh();
CallstackMeshLines.Geometry = Mesh.GeometryType.Lines;
CallstackMeshLines.Projection = Mesh.ProjectionType.Pixel;
SetBusy(false);
}
protected void ReadInternal(BinaryReader reader)
{
Header = FrameHeader.Read(reader);
Categories = ReadEventList(reader, DescriptionBoard);
CategoriesTree = new EventTree(this, Categories);
Synchronization = ReadEventTimeList(reader);
Synchronization.Sort();
Synchronization = LinearizeEventList(Synchronization);
SynchronizationDuration = 0.0;
foreach (EventData interval in Synchronization)
{
SynchronizationDuration += interval.Duration;
}
}
