public static double FindDistanceToSegmentRiver(DisplayNode point, DisplayNode dpnode, DisplayNode dpnode2) { float dx = dpnode2.x - dpnode.x; float dy = dpnode2.y - dpnode.y; if ((dx == 0) && (dy == 0)) { // It's a point not a line segment. dx = point.x - dpnode.x; dy = point.y - dpnode.y; return(Math.Sqrt(dx * dx + dy * dy)); } // Calculate the t that minimizes the distance. float t = ((point.x - dpnode.x) * dx + (point.y - dpnode.y) * dy) / (dx * dx + dy * dy); // See if this represents one of the segment's // end points or a point in the middle. if (t < 0) { dx = point.x - dpnode.x; dy = point.y - dpnode.y; } else if (t > 1) { dx = point.x - dpnode2.x; dy = point.y - dpnode2.y; } else { dx = point.x - (dpnode.x + t * dx); dy = point.y - (dpnode.y + t * dy); } return(Math.Sqrt(dx * dx + dy * dy)); }
/// <summary> /// Context Click selection. Here you'll need to register your own using a string identifier /// </summary> public void ContextCallback(object obj) { switch (obj.ToString()) { case "calcNode": CalcNode.Create(new Rect(mousePos.x, mousePos.y, 200, 100)); //CalcNode calcNode = CalcNode.Create (new Rect (mousePos.x, mousePos.y, 200, 100)); break; case "inputNode": InputNode.Create(new Rect(mousePos.x, mousePos.y, 100, 50)); //InputNode inputNode = InputNode.Create (new Rect (mousePos.x, mousePos.y, 100, 50)); break; case "displayNode": DisplayNode.Create(new Rect(mousePos.x, mousePos.y, 100, 50)); //DisplayNode displayNode = DisplayNode.Create (new Rect (mousePos.x, mousePos.y, 100, 50)); break; case "dialNode": DialNode.Create(new Rect(mousePos.x, mousePos.y, 200, 100)); //DialNode dialNode = DialNode.Create(new Rect(mousePos.x, mousePos.y, 200, 100)); break; case "deleteNode": Node node = NodeAtPosition(mousePos); if (node != null) { nodeCanvas.nodes.Remove(node); node.OnDelete(); } break; } }
public void DisplayPOINode(DisplayNode poiNode, Icon icon, string name) { if (PositionService.IsWithinBounds(poiNode.x, poiNode.y, mapData)) { Vector3 nodePosition = PositionService.GetUnityPosition(poiNode, heightAdjustment, mapData); GenerateNodeGameObject(nodePosition, icon, name); GenerateLabelLine(poiNode); } }
private void GeneratePoiNodes(OSMData osmData) { foreach (POINode poiNode in osmData.poiNodes) { DisplayNode displayNode = ChangeLatLonToDisplayNode(poiNode.lon, poiNode.lat, mapData); Icon icon = iconHandler.SelectIcon(poiNode.icon); poiDisplay.DisplayPOINode(displayNode, icon, poiNode.name); } }
public void GenerateNode(DisplayNode node) { if (!PositionService.IsWithinBounds(node.x, node.y, mapData)) { return; } Vector3 nodePosition = PositionService.GetUnityPosition(node, lineHeightAdjustment, mapData); this.nodePositions.Add(nodePosition); }
public override Node Create(Vector2 pos) { // This function has to be registered in Node_Editor.ContextCallback DisplayNode node = CreateInstance <DisplayNode> (); node.name = "Display Node"; node.rect = new Rect(pos.x, pos.y, 150, 50); NodeInput.Create(node, "Value", "Float"); return(node); }
public static DisplayNode Create(Rect NodeRect) { // This function has to be registered in Node_Editor.ContextCallback DisplayNode node = ScriptableObject.CreateInstance <DisplayNode> (); node.name = "Display Node"; node.rect = NodeRect; NodeInput.Create(node, "Value", typeof(float)); node.Init(); return(node); }
public static Vector3 GetUnityPosition(DisplayNode node, float heightAdjustment, MapData mapData) { float height = mapData.GetNormalized(node.x, node.y); float xFromCenter = node.x - mapData.GetWidth() / 2; float yFromCenter = (mapData.GetHeight() / 2) - node.y; float scale = 1 / ((float)Mathf.Max(mapData.GetWidth(), mapData.GetHeight()) - 1); Vector3 nodePosition = new Vector3((float)xFromCenter * scale, height + heightAdjustment, (float)yFromCenter * scale); return(nodePosition); }
public bool InRiver(List <DisplayNode> displayNodes, float x, float y) { for (int i = 0; i < displayNodes.Count - 1; i++) { DisplayNode point = new DisplayNode((int)x, (int)y); DisplayNode riverNode1 = displayNodes[i]; DisplayNode riverNode2 = displayNodes[i + 1]; if (SegmentUtil.FindDistanceToSegmentRiver(point, riverNode1, riverNode2) < riverWidthConstant) { return(true); } } return(false); }
private bool IsPointInPolygon(List <DisplayNode> areaBounds, DisplayNode point) { int i, j; bool c = false; for (i = 0, j = areaBounds.Count - 1; i < areaBounds.Count; j = i++) { if ((((areaBounds[i].x <= point.x) && (point.x < areaBounds[j].x)) || ((areaBounds[j].x <= point.x) && (point.x < areaBounds[i].x))) && (point.y < (areaBounds[j].y - areaBounds[i].y) * (point.x - areaBounds[i].x) / (areaBounds[j].x - areaBounds[i].x) + areaBounds[i].y)) { c = !c; } } return(c); }
// add display node // @params // Node newNode -> Node contains all data for the Node. This is a simple way to instantiate its display representation; // Node parentNode -> parent node is stored to draw parent/child relationships graphically. // int level -> Level indicates the depth of the Node. This will be stored to later represent the Y position of the Node. // int numberLevelNodes -> value indicates the number of nodes at the passed level value. This is used to calculate the X position of the node. // int levelPosition -> value indicates X position of the current node. Level may contain 0 - numberLevelNodes nodes. X position will depend on the value contained herein. // DisplayNode displayNode -> if parameter is null, instantiate new display node; else -> use this parameter as adding display node. public void AddDisplayNode(Node newNode, DisplayNode parentNode, int level, int numberLevelNodes, int levelPosition, DisplayNode newDisplayNode) { DisplayNode displayNode = null; if (newDisplayNode == null) { displayNode = new DisplayNode(); } else { displayNode = newDisplayNode; } // TODO: Display Node can contain node string displayNode.SetDisplayStr(newNode.getNodeStr()); displayNode.SetParent(parentNode); displayNode.SetLevel(level); // node partition width int nodePartitionWidth = width / numberLevelNodes; int displayNodeX = nodePartitionWidth * levelPosition; nodePartitionWidth /= 2; displayNodeX += nodePartitionWidth; displayNodeX -= nodeSize / 2; displayNode.SetX(displayNodeX); nodes.Add(displayNode); Console.WriteLine("Node: " + displayNode); Console.WriteLine("Add Display Node Parameters; Level: " + level + " NumberLevelNodes: " + numberLevelNodes + " LevelPosition: " + levelPosition); }
public void FindDistanceToSegmentRiverTest() { DisplayNode dpnode = new DisplayNode(4, 4); DisplayNode dpnode2 = new DisplayNode(4, 4); DisplayNode point = new DisplayNode(6, 4); Assert.AreEqual(SegmentUtil.FindDistanceToSegmentRiver(point, dpnode, dpnode2), 2); dpnode = new DisplayNode(4, 4); dpnode2 = new DisplayNode(6, 6); point = new DisplayNode(6, 6); Assert.AreEqual(SegmentUtil.FindDistanceToSegmentRiver(point, dpnode, dpnode2), (double)0.0); dpnode = new DisplayNode(12, 12); dpnode2 = new DisplayNode(18, 18); point = new DisplayNode(6, 16); Assert.AreEqual(SegmentUtil.FindDistanceToSegmentRiver(point, dpnode, dpnode2), 7.211102550927978); dpnode = new DisplayNode(24, 24); dpnode2 = new DisplayNode(18, 18); point = new DisplayNode(6, 16); Assert.AreEqual(SegmentUtil.FindDistanceToSegmentRiver(point, dpnode, dpnode2), 12.165525060596439); }
public void GenerateLabelLine(DisplayNode poiNode) { GameObject labelLine = new GameObject(); LineRenderer lineRenderer = labelLine.AddComponent <LineRenderer>(); lineRenderer.positionCount = 2; Vector3[] endpoints = new Vector3[] { PositionService.GetUnityPosition(poiNode, heightAdjustment, mapData), PositionService.GetUnityPosition(poiNode, 0, mapData) }; lineRenderer.SetPositions(endpoints); lineRenderer.widthMultiplier = this.lineWidthMultiplier; lineRenderer.useWorldSpace = false; labelLine.transform.SetParent(this.transform); Material[] materials = new Material[] { new Material(Shader.Find("Unlit/Color")) }; labelLine.GetComponent <Renderer>().sharedMaterials = materials; labelLine.GetComponent <Renderer>().sharedMaterial.color = ColorHandler.SelectColor("poiLine"); }
public void Setup() { m_ConverterPoint = new Point(11.0, 22.0); m_Converter = Substitute.For <IGeometryPointToWindowsPointConverter>(); m_Converter.Point.Returns(m_ConverterPoint); m_Point = new Point(1.0, 2.0); m_StrokeBrush = Brushes.Aqua; m_FillBrush = Brushes.Yellow; m_Sut = new DisplayNode(m_Converter, 1, m_Point.X, m_Point.Y, 3.0, 4.0, m_FillBrush, m_StrokeBrush, 5.0); }
public MainWindow() { InitializeComponent(); context = new NodeGraphContext(); nodeChest = new NodeChest(context); SimpleNode sm = new SimpleNode(); nodeChest.addNode(sm.Node); graph = new NodeGraph(context); graph.pipeStiffness = 0; container.Children.Add(graph); //chestContainer.Children.Add(nodeChest); nodeChest.ScrollViewer.VerticalScrollBarVisibility = ScrollBarVisibility.Hidden; ConstantNode node = new ConstantNode(); node.Node.position = new Point(50, 50); DisplayNode node2 = new DisplayNode(); node2.Node.position = new Point(500, 30); graph.addNode(node.Node); graph.addNode(node2.Node); new Connection(node.Node.getOutputs()[0], node2.Node.getInputs()[0]); }
public void Test40() { // Step 1: create an arbitrary acyclical pipeline with an input and a manipulation node MainViewModel mvm = MainViewModelTest.GetInstance(); VideoInputNode video = new VideoInputNode(); BlurNode blur = new BlurNode() { Type = BlurType.Gaussian, Radius = 3 }; DisplayNode display = new DisplayNode(); // We'll have to dump this node's output later, so we need a ViewModel NodeViewModel blurVM = new NodeViewModel(blur, mvm.PipelineViewModel); mvm.Model.Graph.AddNode(video); mvm.Model.Graph.AddNode(blur); mvm.Model.Graph.AddNode(display); mvm.Model.Graph.AddEdge(video.Outputs[0], blur.Inputs[0]); mvm.Model.Graph.AddEdge(blur.Outputs[0], display.Inputs[0]); // Assert that the graph is well-formed Assert.Contains(video, mvm.Model.Graph.Nodes); Assert.Contains(blur, mvm.Model.Graph.Nodes); Assert.Contains(display, mvm.Model.Graph.Nodes); Assert.Equal(blur.Inputs[0].Source, video.Outputs[0]); Assert.Equal(display.Inputs[0].Source, blur.Outputs[0]); // Step 2: change the video input data Assert.False(display.InputIsValid); video.FileName = new FilePath(@"..\..\..\..\resources\americanFootball_352x240_125.yuv"); Assert.True(display.InputIsValid); // Step 3: open the DisplayNode's output and play the video DisplayViewModel output = display.Window; Assert.Equal(display, output.NodeModel); Assert.False(mvm.Model.IsPlaying); mvm.ReplayStateViewModel.PlayPause(); Assert.True(mvm.Model.IsPlaying); // Step 4: Change a node's options while the video is playing blur.Radius = 0; Assert.True(mvm.Model.IsPlaying); Assert.True(display.InputIsValid); // Step 5: change replay speed while video is playing int oldSpeed = mvm.Model.Speed; mvm.ReplayStateViewModel.Slower(); Assert.True(oldSpeed > mvm.Model.Speed); // Step 6: pause the video mvm.ReplayStateViewModel.PlayPause(); Assert.False(mvm.Model.IsPlaying); // Step 7: resumes the video mvm.ReplayStateViewModel.PlayPause(); Assert.True(mvm.Model.IsPlaying); // Step 8: resets the video playing state mvm.ReplayStateViewModel.Stop(); Assert.Equal(0, mvm.Model.CurrentTick); Assert.False(mvm.Model.IsPlaying); // Step 9: save the video as yuv file blurVM.SaveNodeOutput(blur.Outputs[0]); // Since we can't create a FileChooser here, we'll have to invoke the SaveNodeOutputViewModel directly System.IO.MemoryStream stream = new System.IO.MemoryStream(); SaveNodeOutputViewModel saveVM = new SaveNodeOutputViewModel(blur.Outputs[0], stream, mvm.Model); Assert.Equal(mvm.Model.Graph.TickCount, saveVM.TickCount); // I'm sorry for this. I really am. I found no better way of testing this. System.Threading.Thread.Sleep(1000); try { Assert.NotEqual(0, stream.Capacity); } catch (ObjectDisposedException) { // This means the SaveNodeOutputViewModel is already done and has disposed of its stream // That's just another possibility that's just as valid, and signifies proper execution } }
public DisplayTree search(NodeTree tree, String targetString) { // memory to maintain unvisited children List <Node> queue = new List <Node>(); // iterate over all nodes (breadth first search) queue.Add(tree.GetTreeA()); int currentLevelCount = 1; int nextLevelCount = 0; int currentLevel = 1; Console.WriteLine("First Level: " + currentLevel); Node currentNode = null; // counter to begin iterating over newly added children to instantiate display nodes int displayIterBegin = 1; // counter to end iterating over newly added children to instantiate display nodes int displayIterEnd = 1; // test if display tree has been instantiated if (displayTree == null) { displayTree = new DisplayTree(width, height, nodeSize); } DisplayNode currentParentDisplayNode = new DisplayNode(); // add the root display node displayTree.AddDisplayNode(queue.ElementAt(0), null, currentLevel, 1, nextLevelCount, currentParentDisplayNode); List <DisplayNode> childDisplayNodes = new List <DisplayNode>(); List <DisplayNode> parentDisplayNodes = new List <DisplayNode>(); parentDisplayNodes.Add(currentParentDisplayNode); List <Node> childNodes = new List <Node>(); while (queue.Count > 0) { currentNode = queue.ElementAt(0); queue.RemoveAt(0); // get current parent display node currentParentDisplayNode = parentDisplayNodes.ElementAt(0); parentDisplayNodes.RemoveAt(0); Console.WriteLine("Current Node Str: " + currentNode.getNodeStr()); Node currentNodeChild = null; while ((currentNodeChild = currentNode.getNextChild()) != null) { queue.Add(currentNodeChild); nextLevelCount++; displayIterEnd++; DisplayNode displayNode = new DisplayNode(); displayNode.SetParent(currentParentDisplayNode); childDisplayNodes.Add(displayNode); childNodes.Add(currentNodeChild); } currentLevelCount--; if (queue.Count > 0) { if (currentLevelCount == 0) { parentDisplayNodes.Clear(); currentLevel++; for (int levelCounter = 0; levelCounter < childDisplayNodes.Count; levelCounter++) { // add the display node displayTree.AddDisplayNode(childNodes.ElementAt(levelCounter), childDisplayNodes.ElementAt(levelCounter).GetParent(), currentLevel, nextLevelCount, levelCounter, childDisplayNodes.ElementAt(levelCounter)); parentDisplayNodes.Add(childDisplayNodes.ElementAt(levelCounter)); } Console.WriteLine("Level has incremented! " + currentLevel); currentLevelCount = nextLevelCount; nextLevelCount = 0; childDisplayNodes.Clear(); childNodes.Clear(); } } } Console.WriteLine("Final Current Level: " + currentLevel); displayTree.CalculateDisplayTreeYValues(currentLevel); return(displayTree); }
public void SetParent(DisplayNode newParent) { parent = newParent; }
public void AddDisplayNode(OSMNode node) { DisplayNode displayNode = ChangeLatLonToDisplayNode(node.lon, node.lat, mapData); displayNodes.Add(displayNode); }
/// <summary> /// Get a list of display nodes in depth-first order. /// </summary> /// <returns></returns> internal IList <DisplayNode> GetDisplayNodes() { if (NumPoses == 0) { return(Array.Empty <DisplayNode>()); } var nodesOut = new List <DisplayNode>(NumPoses); // List of children for each node var tree = new Dictionary <int, List <int> >(); for (var i = 0; i < NumPoses; i++) { var parent = GetParentIndex(i); if (i == -1) { continue; } if (!tree.ContainsKey(parent)) { tree[parent] = new List <int>(); } tree[parent].Add(i); } // Store (index, depth) in the stack var stack = new Stack <(int, int)>(); stack.Push((0, 0)); while (stack.Count != 0) { var(current, depth) = stack.Pop(); var obj = GetObjectAt(current); var node = new DisplayNode { NodeObject = obj, Enabled = IsPoseEnabled(current), OriginalIndex = current, Depth = depth }; nodesOut.Add(node); // Add children if (tree.ContainsKey(current)) { // Push to the stack in reverse order var children = tree[current]; for (var childIdx = children.Count - 1; childIdx >= 0; childIdx--) { stack.Push((children[childIdx], depth + 1)); } } // Safety check // This shouldn't even happen, but in case we have a cycle in the graph // exit instead of looping forever and eating up all the memory. if (nodesOut.Count > NumPoses) { return(nodesOut); } } return(nodesOut); }
public DisplayNodeAndEdges(DisplayNode displayNode, IBidirectionalGraph <DisplayNode, DisplayEdge> owner) { DisplayNode = displayNode; _owner = owner; }
public DisplayViewModel(DisplayNode node) : base(node, null) { NodeModel = node; }
public DisplayViewModel(DisplayNode node) : base(node, null) { NodeModel = node; }