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; } }