/// <summary> /// Intantiates a new object of this class. /// </summary> public GameBoard() { this.tileValueGrid = new int?[this.maxGameBoardSize + 1, this.maxGameBoardSize + 1]; this.tileGrid = new TriominoTile[this.maxGameBoardSize, this.maxGameBoardSize]; this.NumbTilesOnBoard = 0; this.tilesWithFreeFaces = new Dictionary <string, List <TileFace> >(); List <Vertex> vertices = new List <Vertex>(); List <HyperEdge> twoSidedEdges = new List <HyperEdge>(); for (int i = 0; i < 6; i++) { for (int j = i; j < 6; j++) { vertices.Add(new Vertex(i + "" + j)); if (i != j) { vertices.Add(new Vertex(j + "" + i)); } twoSidedEdges.Add(new HyperEdge(i + "" + j, j + "" + i)); } } tileGraph = new HyperGraph(vertices); foreach (HyperEdge twoSidedEdge in twoSidedEdges) { tileGraph.AddEdge(twoSidedEdge); } }
public void HyperGraph_GetAdjacentEdges_has_to_work() { HyperGraph hyperGraph = new HyperGraph(); Vertex v1 = hyperGraph.AddVertex("00"); Vertex v2 = hyperGraph.AddVertex("01"); Vertex v3 = hyperGraph.AddVertex("10"); HyperEdge h1 = hyperGraph.AddEdge("00", "00", "00"); HyperEdge h2 = hyperGraph.AddEdge("00", "01", "10"); HyperEdge h3 = hyperGraph.AddEdge("00", "00"); HyperEdge h4 = hyperGraph.AddEdge("01", "10"); List <HyperEdge> neighbors = hyperGraph.GetAdjacentEdges(v1).ToList(); Assert.AreEqual(3, neighbors.Count); Assert.IsTrue(neighbors.Contains(h1)); Assert.IsTrue(neighbors.Contains(h2)); Assert.IsTrue(neighbors.Contains(h3)); neighbors = hyperGraph.GetAdjacentEdges(v2).ToList(); Assert.AreEqual(2, neighbors.Count); Assert.IsTrue(neighbors.Contains(h2)); Assert.IsTrue(neighbors.Contains(h4)); neighbors = hyperGraph.GetAdjacentEdges(v2, 2).ToList(); Assert.AreEqual(1, neighbors.Count); Assert.IsTrue(neighbors.Contains(h4)); neighbors = hyperGraph.GetAdjacentEdges(v2, 3).ToList(); Assert.AreEqual(1, neighbors.Count); Assert.IsTrue(neighbors.Contains(h2)); }
public void GraphGenerator_Create_Triomino_Graph_has_to_work() { HyperGraph triominoGraph = GraphGenerator.CreateTriominoGraph(); Assert.AreEqual(56, triominoGraph.Edges.Where(e => e.IsThreeSidedEdge()).Count()); Assert.AreEqual(21, triominoGraph.Edges.Where(e => e.IsTwoSidedEdge()).Count()); }
public void GetAllCycles_must_work() { string path = Path.Combine(Directory.GetParent(Directory.GetCurrentDirectory()).Parent.Parent.FullName, "TestFiles", "tEdgeGraph.txt"); HyperGraph hyperGraph = GraphGenerator.LoadHyperGraphFromFile(path); List <List <Tuple <HyperEdge, string> > > cycles = hyperGraph.GetAllSimpleCycles2(); }
public CircularLayoutAlgorithm(HyperGraph graph, IDictionary <Vertex, Point> vertexPositions, IDictionary <Vertex, Size> vertexSizes) { Graph = graph; VertexPositions = vertexPositions; VertexSizes = vertexSizes; }
public void HyperGraph_AddVertex_has_to_work() { HyperGraph hyperGraph = new HyperGraph(); Vertex v1 = hyperGraph.AddVertex("00"); Assert.AreEqual(v1, hyperGraph.Vertices.First()); Assert.IsFalse(hyperGraph.AddVertex(new Vertex("00"))); Assert.AreEqual(v1, hyperGraph.AddVertex("00")); }
public void HyperGraph_must_work() { string path = Path.Combine(Directory.GetParent(Directory.GetCurrentDirectory()).Parent.Parent.FullName, "TestFiles", "tEdgePieces.txt"); //string path = Path.Combine(Directory.GetParent(Directory.GetCurrentDirectory()).Parent.FullName, "TestFiles", "tEdgePieces.txt"); HyperGraph hyperGraph = GraphGenerator.LoadHyperGraphFromFile(path); //Tuple<string, int>[] degrees = hyperGraph.GetVertexDegrees(); Tuple <string, int>[] degrees = hyperGraph.GetVertexEulerDegrees(); int greenEdgeDegree = 0; int redEdgeDegree = 0; int redEdgeCount = 0; int greenEdgeCount = 0; int evenEdgeDegree = 0; int evenEdgeCount = 0; int maxDegree = degrees.Select(d => d.Item2).Max(); Tuple <string, int>[] maxDegrees = degrees.Where(d => d.Item2 == 6).ToArray(); foreach (Tuple <string, int> tuple in degrees) { int i = Convert.ToInt32(tuple.Item1[0]); int j = Convert.ToInt32(tuple.Item1[1]); if (i < j) { greenEdgeDegree += tuple.Item2; greenEdgeCount++; } else if (i > j) { redEdgeDegree += tuple.Item2; redEdgeCount++; } else { evenEdgeDegree += tuple.Item2; evenEdgeCount++; } } Tuple <string, int>[] orderedDegrees = degrees.OrderBy(t => t.Item2).ThenBy(t => t.Item1).ToArray(); string outputPath = @"C:\Users\Moritz\Dropbox\Studium\Fulda\5_SS19\Project\Triominos\Graphsuite\GraphSuite\Files"; string outputFile = "tEdgePiecesEulerDegrees.txt"; if (File.Exists(Path.Combine(outputPath, outputFile))) { File.Delete(Path.Combine(outputPath, outputFile)); } File.WriteAllLines(Path.Combine(outputPath, outputFile), degrees.OrderBy(x => x.Item1).Select(d => d.Item1 + " => " + d.Item2)); //Tuple<int, Stack<Tuple<string, HyperEdge<string>>>>[] cycles = hyperGraph.GetAllSimpleCycles(); }
public HyperGraphViewModel(HyperGraph graph) { Graph = graph; InvalidateMeasureButtonCommand = ReactiveCommand.Create <PocHyperGraphLayout>(OnInvalidateMeasureButtonCommand); InvalidateArrangeButtonCommand = ReactiveCommand.Create <PocHyperGraphLayout>(OnInvalidateArrangeButtonCommand); ReLayoutCommand = ReactiveCommand.Create <PocHyperGraphLayout>(OnReLayoutCommand); SaveGraphImageCommand = ReactiveCommand.Create <PocHyperGraphLayout>(OnSaveGraphImageCommand); }
public static HyperGraph ReadGraph(string inFilename) { StreamReader srGraph = new StreamReader(inFilename); int modalityNum = Convert.ToInt32(srGraph.ReadLine()); int nodeNum = Convert.ToInt32(srGraph.ReadLine()); List <SingleNode>[] nodes = new List <SingleNode> [modalityNum]; for (int i = 0; i < modalityNum; i++) { nodes[i] = new List <SingleNode>(); } List <Edge> edges = new List <Edge>(); for (int i = 0; i < nodeNum; i++) { string[] items = srGraph.ReadLine().Split(new char[] { ':', ' ' }, StringSplitOptions.RemoveEmptyEntries); int modality = Convert.ToInt32(items[0]); int index = Convert.ToInt32(items[1]); int count = items.Count(); int day = Convert.ToInt32(items[count - 1]); int label = Convert.ToInt32(items[count - 2]); int gridIndex = Convert.ToInt32(items[count - 3]); List <double> data = new List <double>(); for (int j = 2; j < count - 3; j++) { data.Add(Convert.ToDouble(items[j])); } nodes[modality - 1].Add(new SingleNode(index, data, label, modality, gridIndex, day)); } int edgeNum = Convert.ToInt32(srGraph.ReadLine()); while (srGraph.Peek() > 0) { string[] items = srGraph.ReadLine().Split(new char[] { ' ' }); int startID = Convert.ToInt32(items[0]); int endID = Convert.ToInt32(items[1]); double weight = Convert.ToDouble(items[2]); int type = Convert.ToInt32(items[3]); edges.Add(new Edge(startID, endID, weight, type)); } srGraph.Close(); HyperGraph graph = new HyperGraph(nodes, edges); return(graph); }
public static async Task <HyperGraph> CollectionToHyperGraphTaskAsync( IMongoCollection <BsonDocument> bsonDocCollection) { var hyperGraph = new HyperGraph(bsonDocCollection.CollectionNamespace.CollectionName); await foreach (var keys in ParseCollectionAsync(bsonDocCollection.AsQueryable())) { var edge = new HyperEdge { Weight = 1 }; foreach (var key in keys) { var vertex = hyperGraph.Vertices.FirstOrDefault(v => v.Data?.Equals(key) ?? false); if (vertex is null) { vertex = new Vertex(key); hyperGraph.Vertices.Add(vertex); } vertex.HyperEdges.Add(edge); edge.Vertices.Add(vertex); } var existHyperEdge = hyperGraph.HyperEdges.FirstOrDefault(he => he.Vertices.SetEquals(edge.Vertices)); if (existHyperEdge is null) { hyperGraph.HyperEdges.Add(edge); } else { foreach (var vertex in edge.Vertices) { vertex.HyperEdges.RemoveWhere(e => e.Id == edge.Id); vertex.HyperEdges.Add(existHyperEdge); } existHyperEdge.Weight++; } } return(hyperGraph); }
public void HyperGraph_has_to_work() { string path = Path.Combine(Directory.GetParent(Directory.GetCurrentDirectory()).Parent.Parent.FullName, "TestFiles", "tEdgeGraph.txt"); //string path = Path.Combine(Directory.GetParent(Directory.GetCurrentDirectory()).Parent.FullName, "TestFiles", "tEdgePieces.txt"); HyperGraph hyperGraph = GraphGenerator.LoadHyperGraphFromFile(path); //Tuple<string, int>[] degrees = hyperGraph.GetVertexDegrees(); Tuple <string, int>[] degrees = hyperGraph.GetVertexEulerDegrees(); string outputPath = @"C:\Users\Moritz\source\repos\GraphSuite\Files"; string outputFile = "tEdgeEulerDegrees.txt"; if (File.Exists(Path.Combine(outputPath, outputFile))) { File.Delete(Path.Combine(outputPath, outputFile)); } File.WriteAllLines(Path.Combine(outputPath, outputFile), degrees.OrderBy(x => x.Item1).Select(d => d.Item1 + " => " + d.Item2)); //Tuple<int, Stack<Tuple<string, HyperEdge<string>>>>[] cycles = hyperGraph.GetAllSimpleCycles(); }
public void GetTileSideStructure() { string path = Path.Combine(Directory.GetParent(Directory.GetCurrentDirectory()).Parent.Parent.FullName, "TestFiles", "tEdgePieces.txt"); //string path = Path.Combine(Directory.GetParent(Directory.GetCurrentDirectory()).Parent.FullName, "TestFiles", "tEdgePieces.txt"); HyperGraph hyperGraph = GraphGenerator.LoadHyperGraphFromFile(path); Dictionary <string, int> tileSideStructure = new Dictionary <string, int>(); int structureCount = 0; foreach (HyperEdge edge in hyperGraph.Edges) { structureCount = edge.GreenSideCount() * 100 + edge.BlueSideCount() * 10 + edge.RedSideCount(); tileSideStructure.Add(edge.ToString(), structureCount); } //Dictionary<string, int> onlyblue = tileSideStructure.Where(kv => kv.Value % 10 == 0).ToDictionary(kv => kv.Key, kv => kv.Value); //Dictionary<string, int> onlyGreen = tileSideStructure.Where(kv => kv.Value % 100 == 0).ToDictionary(kv => kv.Key, kv => kv.Value); //Dictionary<string, int> containsBlueAndGreen = tileSideStructure.Where(kv => kv.Value > 100 && (kv.Value % 100) >= 10).ToDictionary(kv => kv.Key, kv => kv.Value); //Dictionary<string, int> rest = tileSideStructure.Where(kv => !onlyblue.Keys.Contains(kv.Key) && !containsBlueAndGreen.Keys.Contains(kv.Key)).ToDictionary(kv => kv.Key, kv => kv.Value); //Dictionary<string, int> redAndBlue = tileSideStructure.Where(kv => kv.Value % 2 == 1).ToDictionary(kv => kv.Key, kv => kv.Value); HyperEdge[] onlyBlue = hyperGraph.Edges.Where(e => e.BlueSideCount() == 3).ToArray(); HyperEdge[] onlyGreen = hyperGraph.Edges.Where(e => e.GreenSideCount() == 3).ToArray(); HyperEdge[] onlyRed = hyperGraph.Edges.Where(e => e.RedSideCount() == 3).ToArray(); HyperEdge[] twoBlueOneGreen = hyperGraph.Edges.Where(e => e.BlueSideCount() == 2 && e.GreenSideCount() == 1).ToArray(); HyperEdge[] twoBlueOneRed = hyperGraph.Edges.Where(e => e.BlueSideCount() == 2 && e.RedSideCount() == 1).ToArray(); HyperEdge[] twoGreenOneBlue = hyperGraph.Edges.Where(e => e.BlueSideCount() == 1 && e.GreenSideCount() == 2).ToArray(); HyperEdge[] twoGreenOneRed = hyperGraph.Edges.Where(e => e.RedSideCount() == 1 && e.GreenSideCount() == 2).ToArray(); HyperEdge[] greenRedBlue = hyperGraph.Edges.Where(e => e.BlueSideCount() == 1 && e.GreenSideCount() == 1 && e.RedSideCount() == 1).ToArray(); HyperEdge[] moreThanOneRed = hyperGraph.Edges.Where(e => e.RedSideCount() > 1).ToArray(); //30 = 6 //201 = 20 //111 = 30 }
public void HyperGraph_AddEdge_has_to_work() { HyperGraph hyperGraph = new HyperGraph(); Assert.ThrowsException <ArgumentException>(() => { hyperGraph.AddEdge("00", "00", "00"); }, "This graph does not conatin a vertex with value '00'."); Vertex v1 = hyperGraph.AddVertex("00"); HyperEdge h1 = hyperGraph.AddEdge("00", "00", "00"); Assert.AreEqual(3, h1.VertexCount()); Assert.IsTrue(h1.ContainsOnVertexBasis(v1)); HyperEdge h2 = new HyperEdge("00", "01", "10"); Assert.ThrowsException <ArgumentException>(() => { hyperGraph.AddEdge(new Vertex("00"), new Vertex("01"), new Vertex("10")); }, $"This graph does not conatin a vertex with value '01'"); Vertex v2 = hyperGraph.AddVertex("11"); Vertex v3 = hyperGraph.AddVertex("01"); Vertex v4 = hyperGraph.AddVertex("10"); Assert.ThrowsException <ArgumentException>(() => hyperGraph.AddEdge(v2, v2, v2), "Vertices must not be equal."); HyperEdge h3 = hyperGraph.AddEdge(v1, v3, v4); Assert.IsTrue(h3.ContainsOnVertexBasis(v1)); Assert.IsTrue(h3.ContainsOnVertexBasis(v3)); Assert.IsTrue(h3.ContainsOnVertexBasis(v4)); Assert.IsFalse(h3.ContainsOnEdgeBasis(v1)); Assert.IsFalse(h3.ContainsOnEdgeBasis(v3)); Assert.IsFalse(h3.ContainsOnEdgeBasis(v4)); HyperEdge h4 = new HyperEdge(new Vertex("00"), new Vertex("01"), new Vertex("10")); Assert.IsTrue(hyperGraph.HasEdge(h4)); Assert.ThrowsException <ArgumentException>(() => { hyperGraph.AddEdge(new Vertex("00"), new Vertex("01"), new Vertex("10")); }, $"This Graph has already an edge '-00-01-10->'."); Assert.ThrowsException <ArgumentException>(() => { hyperGraph.AddEdge("00", "01", "10"); }, $"This Graph has already an edge '-00-01-10->'."); }
public void AddToHyperGraph(ShaderPatcherLayer.NodeGraph nodeGraph, HyperGraph.IGraphModel graph) { // // Convert from the "ShaderPatcherLayer" representation back to // our graph control nodes. // // This is required for robust serialisation. We can't easily // serialise in and out the graph control objects directly, because // it risks problems if the rendering code or shader fragment objects // change. That is, it's not very version-robust. // // It's better to serialise a slightly higher level representation // that just contains the node names and connections. That way, we // can adapt to changes in the tool and data. // { // --------< Basic Nodes >-------- var newNodes = new Dictionary<int, Node>(); var nodeIdToControlNode = new Dictionary<UInt64, Node>(); foreach (var n in nodeGraph.Nodes) { if (!newNodes.ContainsKey(n.VisualNodeId)) { var visualNode = nodeGraph.VisualNodes[n.VisualNodeId]; // also look for preview settings... var previewSettings = nodeGraph.PreviewSettingsObjects.Where(x => x.VisualNodeId == n.VisualNodeId).FirstOrDefault(); Node newNode = null; if (n.NodeType == ShaderPatcherLayer.Node.Type.Procedure) { var fn = _shaderFragments.GetFunction(n.FragmentArchiveName); newNode = _nodeCreator.CreateNode(fn, n.FragmentArchiveName, previewSettings); } else { var ps = _shaderFragments.GetParameterStruct(n.FragmentArchiveName); newNode = _nodeCreator.CreateParameterNode(ps, n.FragmentArchiveName, AsSourceType(n.NodeType)); } if (newNode != null) { MatchVisualNode(newNode, visualNode); newNodes[n.VisualNodeId] = newNode; nodeIdToControlNode[n.NodeId] = newNode; } } } graph.AddNodes(newNodes.Values); // --------< Node Connections >-------- foreach (var c in nodeGraph.NodeConnections) { if (nodeIdToControlNode.ContainsKey(c.InputNodeID) && nodeIdToControlNode.ContainsKey(c.OutputNodeID)) { var inputItem = FindOrCreateNodeItem(nodeIdToControlNode[c.InputNodeID], (item) => (item.Output != null && item.Output.Enabled && item is ShaderFragmentNodeItem && ((ShaderFragmentNodeItem)item).Name.Equals(c.InputParameterName)), () => new ShaderFragmentNodeItem(c.InputParameterName, c.InputType, null, false, true)); var outputItem = FindOrCreateNodeItem(nodeIdToControlNode[c.OutputNodeID], (item) => (item.Input != null && item.Input.Enabled && item is ShaderFragmentNodeItem && ((ShaderFragmentNodeItem)item).Name.Equals(c.OutputParameterName)), () => new ShaderFragmentNodeItem(c.OutputParameterName, c.OutputType, null, true, false)); graph.Connect(inputItem.Output, outputItem.Input); } } // --------< Constant Connections >-------- foreach (var c in nodeGraph.ConstantConnections) { if (nodeIdToControlNode.ContainsKey(c.OutputNodeID)) { var node = nodeIdToControlNode[c.OutputNodeID]; var outputItem = FindOrCreateNodeItem(node, (item) => (item.Input != null && item.Input.Enabled && item is ShaderFragmentNodeItem && ((ShaderFragmentNodeItem)item).Name.Equals(c.OutputParameterName)), () => new ShaderFragmentNodeItem(c.OutputParameterName, "float", null, true, false)); var connection = new NodeConnection(); connection.To = outputItem.Input; connection.Name = c.Value; node.AddConnection(connection); } } // --------< Input Parameter Connections >-------- foreach (var c in nodeGraph.InputParameterConnections) { if (!nodeIdToControlNode.ContainsKey(c.OutputNodeID)) continue; var dstItem = FindOrCreateNodeItem( nodeIdToControlNode[c.OutputNodeID], (item) => (item.Input != null && item.Input.Enabled && item is ShaderFragmentNodeItem && ((ShaderFragmentNodeItem)item).Name.Equals(c.OutputParameterName)), () => new ShaderFragmentNodeItem(c.OutputParameterName, c.Type, null, true, false)); Node srcNode; if (!newNodes.ContainsKey(c.VisualNodeId)) { srcNode = _nodeCreator.CreateInterfaceNode("Inputs", InterfaceDirection.In); MatchVisualNode(srcNode, nodeGraph.VisualNodes[c.VisualNodeId]); newNodes[c.VisualNodeId] = srcNode; graph.AddNode(srcNode); } else srcNode = newNodes[c.VisualNodeId]; var srcItem = FindOrCreateNodeItem( srcNode, (item) => { var i = item as ShaderFragmentInterfaceParameterItem; if (i==null) return false; return i.Name.Equals(c.Name) && i.Type.Equals(c.Type) && i.Semantic.Equals(c.Semantic); }, () => new ShaderFragmentInterfaceParameterItem(c.Name, c.Type, InterfaceDirection.In) { Semantic = c.Semantic, Default = c.Default }); graph.Connect(srcItem.Output, dstItem.Input); } // --------< Output Parameter Connections >-------- foreach (var c in nodeGraph.OutputParameterConnections) { if (!nodeIdToControlNode.ContainsKey(c.InputNodeID)) continue; var srcItem = FindOrCreateNodeItem( nodeIdToControlNode[c.InputNodeID], (item) => (item.Output != null && item.Output.Enabled && item is ShaderFragmentNodeItem && ((ShaderFragmentNodeItem)item).Name.Equals(c.InputParameterName)), () => new ShaderFragmentNodeItem(c.InputParameterName, c.Type, null, false, true)); Node dstNode; if (!newNodes.ContainsKey(c.VisualNodeId)) { dstNode = _nodeCreator.CreateInterfaceNode("Outputs", InterfaceDirection.Out); MatchVisualNode(dstNode, nodeGraph.VisualNodes[c.VisualNodeId]); newNodes[c.VisualNodeId] = dstNode; graph.AddNode(dstNode); } else dstNode = newNodes[c.VisualNodeId]; var dstItem = FindOrCreateNodeItem( dstNode, (item) => { var i = item as ShaderFragmentInterfaceParameterItem; if (i == null) return false; return i.Name.Equals(c.Name) && i.Type.Equals(c.Type) && i.Semantic.Equals(c.Semantic); }, () => new ShaderFragmentInterfaceParameterItem(c.Name, c.Type, InterfaceDirection.Out) { Semantic = c.Semantic }); graph.Connect(srcItem.Output, dstItem.Input); } } }
// // Convert from the "ViewModel" to the "Model" // // We don't maintain the ShaderPatcherLayer.NodeGraph representation // permanently... But we need this for serialization and shader // generation operations // // So, let's just build it from the graph control object. // public ShaderPatcherLayer.NodeGraph ToShaderPatcherLayer(HyperGraph.IGraphModel graph) { ShaderPatcherLayer.NodeGraph nodeGraph = new ShaderPatcherLayer.NodeGraph(); Dictionary<Node, int> nodeToVisualNodeId = new Dictionary<Node, int>(); foreach (Node n in graph.Nodes) { var nTag = n.Tag as ShaderFragmentNodeTag; if (nTag == null) continue; // Create a "visual node" (unless it already exists) // -- this contains information that only affects the rendered // graphs, not the output shader int visualNodeId; if (nodeToVisualNodeId.ContainsKey(n)) { visualNodeId = nodeToVisualNodeId[n]; } else { visualNodeId = nodeGraph.VisualNodes.Count(); nodeToVisualNodeId.Add(n, visualNodeId); nodeGraph.VisualNodes.Add( new ShaderPatcherLayer.VisualNode() { Location = n.Location, State = (n.Collapsed) ? ShaderPatcherLayer.VisualNode.StateType.Collapsed : ShaderPatcherLayer.VisualNode.StateType.Normal }); } // Potentially build a "node" in the patcher layer. This is only required // if we're referencing some object in the shader fragments archive if (!string.IsNullOrEmpty(nTag.ArchiveName)) { ShaderPatcherLayer.Node resultNode = new ShaderPatcherLayer.Node() { FragmentArchiveName = nTag.ArchiveName, NodeId = nTag.Id, VisualNodeId = visualNodeId }; if (n.Tag is ShaderParameterNodeTag) { // This is a hack... But there should be a drop down list that // can tell us the type of this parameter struct box. foreach (var i in n.Items) { if (i is HyperGraph.Items.NodeDropDownItem) { var dropDown = (HyperGraph.Items.NodeDropDownItem)i; var stringForm = dropDown.Items[dropDown.SelectedIndex]; var parameterSource = ShaderFragmentNodeCreator.AsEnumValue<ShaderFragmentArchive.Parameter.SourceType>(stringForm, ShaderFragmentNodeCreator.ParamSourceTypeNames); resultNode.NodeType = AsNodeType(parameterSource); } } } else { resultNode.NodeType = ShaderPatcherLayer.Node.Type.Procedure; } nodeGraph.Nodes.Add(resultNode); } // Build connections... foreach (NodeConnection connection in n.Connections) { if (connection.To != null) { var dstNode = connection.To.Node.Tag as ShaderFragmentNodeTag; if (dstNode == null) continue; var dstItem = connection.To.Item as ShaderFragmentNodeItem; if (dstItem == null) continue; if (connection.From == null && connection.To.Node == n) { // this is a direct constant connection. It connects the value either to a constant value, or some named variable nodeGraph.ConstantConnections.Add( new ShaderPatcherLayer.ConstantConnection() { Value = connection.Name, OutputNodeID = dstNode.Id, OutputParameterName = dstItem.Name }); } else if (connection.To.Node == n && connection.To.Item is ShaderFragmentInterfaceParameterItem) { // this is an output parameter. This is the only case where we creating the connection // while processing the node on the "out" side var outputParam = (ShaderFragmentInterfaceParameterItem)connection.To.Item; var resultConnection = new ShaderPatcherLayer.OutputParameterConnection { VisualNodeId = visualNodeId, // (visual node for the output box) Type = outputParam.Type, Name = outputParam.Name, Semantic = outputParam.Semantic }; if (connection.From.Item is ShaderFragmentNodeItem) { var tag = connection.From.Item.Node.Tag as ShaderFragmentNodeTag; if (tag != null) resultConnection.InputNodeID = tag.Id; resultConnection.InputParameterName = ((ShaderFragmentNodeItem)connection.From.Item).Name; } nodeGraph.OutputParameterConnections.Add(resultConnection); } else if (connection.From.Node == n) { if (connection.From.Item is ShaderFragmentInterfaceParameterItem) { // it's an input parameter... we just need type, name, semantic var inputParam = (ShaderFragmentInterfaceParameterItem)connection.From.Item; nodeGraph.InputParameterConnections.Add( new ShaderPatcherLayer.InputParameterConnection { OutputNodeID = dstNode.Id, OutputParameterName = dstItem.Name, VisualNodeId = visualNodeId, Type = inputParam.Type, Name = inputParam.Name, Semantic = inputParam.Semantic, Default = inputParam.Default }); } else if (connection.To.Item is ShaderFragmentInterfaceParameterItem) { // it's an output parameter... // this will be handled when processing the node on the out side } else { // This is an output to the next node var resultConnection = new ShaderPatcherLayer.NodeConnection() { InputNodeID = nTag.Id, OutputNodeID = dstNode.Id, OutputParameterName = dstItem.Name, OutputType = TypeFromNodeItem(dstItem) }; if (connection.From.Item is ShaderFragmentNodeItem) { var sourceItem = (ShaderFragmentNodeItem)connection.From.Item; resultConnection.InputParameterName = sourceItem.Name; resultConnection.InputType = TypeFromNodeItem(sourceItem); } nodeGraph.NodeConnections.Add(resultConnection); } } } else if (connection.From != null && connection.From.Node == n) { // when connection.To is null, it could be an attached output connection var resultConnection = new ShaderPatcherLayer.OutputParameterConnection() { Name = connection.Name, InputNodeID = nTag.Id }; if (connection.From.Item is ShaderFragmentNodeItem) { var sourceItem = (ShaderFragmentNodeItem)connection.From.Item; resultConnection.InputParameterName = sourceItem.Name; resultConnection.Type = TypeFromNodeItem(sourceItem); } nodeGraph.OutputParameterConnections.Add(resultConnection); } } // build the preview settings objects foreach (var i in n.Items) { var preview = i as ShaderFragmentPreviewItem; if (preview == null) continue; var settings = preview.PreviewSettings; settings.VisualNodeId = visualNodeId; nodeGraph.PreviewSettingsObjects.Add(settings); } } return nodeGraph; }
void Model_NodeAdded(object sender, HyperGraph.AcceptNodeEventArgs e) { SetDirty(true); }
private void MatchVisualNode(HyperGraph.Node dst, ShaderPatcherLayer.VisualNode src) { dst.Location = src.Location; dst.Collapsed = src.State == ShaderPatcherLayer.VisualNode.StateType.Collapsed; }
private static void ParameterNodeTypeChanged(object sender, HyperGraph.Items.AcceptNodeSelectionChangedEventArgs args) { if (sender is HyperGraph.Items.NodeDropDownItem) { var item = (HyperGraph.Items.NodeDropDownItem)sender; var node = item.Node; var newType = AsSourceType(item.Items[args.Index]); // We might have to change the input/output settings on this node bool isOutput = newType == ShaderFragmentArchive.Parameter.SourceType.Output; var oldItems = new List<HyperGraph.NodeItem>(node.Items); foreach (var i in oldItems) { if (i is ShaderFragmentNodeItem) { // if this is a node item with exactly 1 input/output // and it is not in the correct direction, then we have to change it. // we can't change directly. We need to delete and recreate this node item. var fragItem = (ShaderFragmentNodeItem)i; if ( (fragItem.Output.Enabled ^ fragItem.Input.Enabled) == true && (fragItem.Output.Enabled) != (isOutput == false)) { var newItem = new ShaderFragmentNodeItem( fragItem.Name, fragItem.Type, fragItem.ArchiveName, isOutput ? true : false, isOutput ? false : true); node.RemoveItem(fragItem); node.AddItem(newItem); } } } } }
void Model_NodeRemoved(object sender, HyperGraph.NodeEventArgs e) { SetDirty(true); }
public static void UpdateGraphConnectionsForParameter( HyperGraph.GraphControl graphControl, String oldArchiveName, String newArchiveName) { // Look for connections in the graph using the "oldArchiveName" and // update them with parameter state information from "newArchiveName" foreach (var n in graphControl.Nodes) { foreach (var item in n.Items) { if (item is ShaderFragmentNodeItem) { var i = (ShaderFragmentNodeItem)item; if (i.ArchiveName != null && i.ArchiveName.Equals(oldArchiveName)) { i.ArchiveName = newArchiveName; // Name and Type are cached on the connector // so, we have to update them with the latest info... var param = ShaderFragmentArchive.Archive.GetParameter(newArchiveName); if (param!=null) { i.Name = param.Name; i.Type = param.Type; } else { i.Name = "<<unknown>>"; i.Type = "<<unknown>>"; } } } } } }
public void HyperGraph_IsPartOfHexagon_has_to_work() { List <Vertex> vertices = new List <Vertex>(); List <HyperEdge> twoSidedEdges = new List <HyperEdge>(); for (int i = 0; i < 6; i++) { for (int j = i; j < 6; j++) { vertices.Add(new Vertex(i + "" + j)); if (i != j) { vertices.Add(new Vertex(j + "" + i)); } twoSidedEdges.Add(new HyperEdge(i + "" + j, j + "" + i)); } } HyperGraph hyperGraph = new HyperGraph(vertices); foreach (HyperEdge twoSidedEdge in twoSidedEdges) { hyperGraph.AddEdge(twoSidedEdge); } HyperEdge edge0 = new HyperEdge("00", "00", "00", TileOrientation.Straight); HyperEdge edge1 = new HyperEdge("00", "02", "20", TileOrientation.Flipped); HyperEdge edge2 = new HyperEdge("02", "22", "20", TileOrientation.DoubleTiltLeft); HyperEdge edge3 = new HyperEdge("01", "12", "20", TileOrientation.Flipped); HyperEdge edge4 = new HyperEdge("01", "11", "10", TileOrientation.DoubleTiltRight); HyperEdge edge5 = new HyperEdge("00", "01", "10", TileOrientation.TiltRight); List <Hexagon> hexagons = new List <Hexagon>(); HyperEdge addedEdge0 = hyperGraph.AddEdge(edge0); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge0, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge1, edge0, out HyperEdge addedEdge1)); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge1, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge2, edge1, out HyperEdge addedEdge2)); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge2, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge3, edge2, out HyperEdge addedEdge3)); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge3, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge4, edge3, out HyperEdge addedEdge4)); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge4, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge5, edge4, out HyperEdge addedEdge5)); addedEdge5.AddDirectNeighbor(addedEdge0); Assert.IsTrue(hyperGraph.IsPartOfHexagon(edge5, out hexagons)); Assert.AreEqual(1, hexagons.Count); //----------------------------------------------------------------------------------- hyperGraph = new HyperGraph(vertices); foreach (HyperEdge twoSidedEdge in twoSidedEdges) { hyperGraph.AddEdge(twoSidedEdge); } addedEdge1 = hyperGraph.AddEdge(edge1); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge1, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge2, edge1, out addedEdge2)); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge2, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge3, edge2, out addedEdge3)); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge3, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge4, edge3, out addedEdge4)); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge4, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge5, edge4, out addedEdge5)); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge5, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge0, edge5, out addedEdge0)); addedEdge0.AddDirectNeighbor(addedEdge1); Assert.IsTrue(hyperGraph.IsPartOfHexagon(edge0, out hexagons)); Assert.AreEqual(1, hexagons.Count); //----------------------------------------------------------------------------------- hyperGraph = new HyperGraph(vertices); foreach (HyperEdge twoSidedEdge in twoSidedEdges) { hyperGraph.AddEdge(twoSidedEdge); } addedEdge2 = hyperGraph.AddEdge(edge2); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge2, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge3, edge2, out addedEdge3)); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge3, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge4, edge3, out addedEdge4)); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge4, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge5, edge4, out addedEdge5)); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge5, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge0, edge5, out addedEdge0)); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge0, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge1, edge0, out addedEdge1)); addedEdge1.AddDirectNeighbor(addedEdge2); Assert.IsTrue(hyperGraph.IsPartOfHexagon(edge1, out hexagons)); Assert.AreEqual(1, hexagons.Count); //----------------------------------------------------------------------------------- hyperGraph = new HyperGraph(vertices); foreach (HyperEdge twoSidedEdge in twoSidedEdges) { hyperGraph.AddEdge(twoSidedEdge); } addedEdge3 = hyperGraph.AddEdge(edge3); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge3, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge4, edge3, out addedEdge4)); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge4, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge5, edge4, out addedEdge5)); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge5, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge0, edge5, out addedEdge0)); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge0, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge1, edge0, out addedEdge1)); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge1, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge2, edge1, out addedEdge2)); addedEdge2.AddDirectNeighbor(addedEdge3); Assert.IsTrue(hyperGraph.IsPartOfHexagon(edge2, out hexagons)); Assert.AreEqual(1, hexagons.Count); //----------------------------------------------------------------------------------- hyperGraph = new HyperGraph(vertices); foreach (HyperEdge twoSidedEdge in twoSidedEdges) { hyperGraph.AddEdge(twoSidedEdge); } addedEdge4 = hyperGraph.AddEdge(edge4); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge4, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge5, edge4, out addedEdge5)); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge5, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge0, edge5, out addedEdge0)); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge0, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge1, edge0, out addedEdge1)); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge1, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge2, edge1, out addedEdge2)); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge2, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge3, edge2, out addedEdge3)); addedEdge3.AddDirectNeighbor(addedEdge4); Assert.IsTrue(hyperGraph.IsPartOfHexagon(edge3, out hexagons)); Assert.AreEqual(1, hexagons.Count); //----------------------------------------------------------------------------------- hyperGraph = new HyperGraph(vertices); foreach (HyperEdge twoSidedEdge in twoSidedEdges) { hyperGraph.AddEdge(twoSidedEdge); } addedEdge5 = hyperGraph.AddEdge(edge5); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge5, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge0, edge5, out addedEdge0)); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge0, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge1, edge0, out addedEdge1)); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge1, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge2, edge1, out addedEdge2)); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge2, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge3, edge2, out addedEdge3)); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge3, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge4, edge3, out addedEdge4)); addedEdge4.AddDirectNeighbor(addedEdge5); Assert.IsTrue(hyperGraph.IsPartOfHexagon(edge4, out hexagons)); Assert.AreEqual(1, hexagons.Count); //---------------------------------------------------------------------------------- HyperEdge edge6 = new HyperEdge("02", "24", "40", TileOrientation.DoubleTiltLeft); HyperEdge edge7 = new HyperEdge("04", "45", "50", TileOrientation.TiltLeft); HyperEdge edge8 = new HyperEdge("05", "55", "50", TileOrientation.Straight); HyperEdge edge9 = new HyperEdge("00", "05", "50", TileOrientation.TiltLeft); hyperGraph = new HyperGraph(vertices); foreach (HyperEdge twoSidedEdge in twoSidedEdges) { hyperGraph.AddEdge(twoSidedEdge); } addedEdge1 = hyperGraph.AddEdge(edge1); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge1, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge2, edge1, out addedEdge2)); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge2, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge3, edge2, out addedEdge3)); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge3, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge4, edge3, out addedEdge4)); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge4, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge5, edge4, out addedEdge5)); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge5, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge6, edge1, out HyperEdge addedEdge6)); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge6, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge7, edge6, out HyperEdge addedEdge7)); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge7, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge8, edge7, out HyperEdge addedEdge8)); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge8, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge9, edge8, out HyperEdge addedEdge9)); Assert.IsFalse(hyperGraph.IsPartOfHexagon(edge9, out hexagons)); Assert.AreEqual(0, hexagons.Count); Assert.IsTrue(hyperGraph.AddEdgeWithDirectNeighbor(edge0, edge5, out addedEdge0)); addedEdge0.AddDirectNeighbor(addedEdge1); addedEdge0.AddDirectNeighbor(addedEdge9); Assert.IsTrue(hyperGraph.IsPartOfHexagon(edge0, out hexagons)); Assert.AreEqual(2, hexagons.Count); }
private void OnConnectorDoubleClick(object sender, HyperGraph.GraphControl.NodeConnectorEventArgs e) { var interfItem = e.Connector.Item as ShaderFragmentInterfaceParameterItem; if (interfItem != null) { EditInterfaceParameter(interfItem); return; } // For input connectors, we can try to add a constant connection if (e.Connector == e.Connector.Item.Input) { EditSimpleConnection(e.Connector); } }
// // Convert from the "ViewModel" to the "Model" // // We don't maintain the ShaderPatcherLayer.NodeGraph representation // permanently... But we need this for serialization and shader // generation operations // // So, let's just build it from the graph control object. // public static ShaderPatcherLayer.NodeGraph ToShaderPatcherLayer(HyperGraph.GraphControl graphControl) { ShaderPatcherLayer.NodeGraph nodeGraph = new ShaderPatcherLayer.NodeGraph(); Dictionary<Node, int> nodeToVisualNodeId = new Dictionary<Node, int>(); foreach (Node n in graphControl.Nodes) { if (n.Tag is ShaderFragmentNodeTag) { ShaderFragmentNodeTag nTag = (ShaderFragmentNodeTag)n.Tag; ShaderPatcherLayer.Node resultNode = new ShaderPatcherLayer.Node(); resultNode.FragmentArchiveName = nTag.ArchiveName; resultNode.NodeId = nTag.Id; if (n.Tag is ShaderParameterNodeTag) { // This is a hack... But there should be a drop down list that // can tell us the type of this parameter struct box. foreach (var i in n.Items) { if (i is HyperGraph.Items.NodeDropDownItem) { var dropDown = (HyperGraph.Items.NodeDropDownItem)i; var stringForm = dropDown.Items[dropDown.SelectedIndex]; var parameterSource = ShaderFragmentNodeCreator.AsSourceType(stringForm); resultNode.NodeType = AsNodeType(parameterSource); } } } else { resultNode.NodeType = ShaderPatcherLayer.Node.Type.Procedure; } { if (nodeToVisualNodeId.ContainsKey(n)) { resultNode.VisualNodeId = nodeToVisualNodeId[n]; } else { resultNode.VisualNodeId = nodeGraph.VisualNodes.Count(); nodeToVisualNodeId.Add(n, resultNode.VisualNodeId); var visualNode = new ShaderPatcherLayer.VisualNode(); visualNode.Location = n.Location; if (n.Collapsed) { visualNode.State = ShaderPatcherLayer.VisualNode.StateType.Collapsed; } else { visualNode.State = ShaderPatcherLayer.VisualNode.StateType.Normal; } nodeGraph.VisualNodes.Add(visualNode); } } nodeGraph.Nodes.Add(resultNode); foreach (NodeConnection connection in n.Connections) { if (connection.From == null) { // this is a direct constant connection. It connects the value either to a constant value, or some named variable if (connection.To != null) { Node destination = connection.To.Node; if (destination.Tag is ShaderFragmentNodeTag) { ShaderFragmentNodeTag dTag = (ShaderFragmentNodeTag)destination.Tag; ShaderPatcherLayer.NodeConstantConnection resultConnection = new ShaderPatcherLayer.NodeConstantConnection(); resultConnection.Value = connection.Name; resultConnection.OutputNodeID = dTag.Id; if (connection.To.Item is ShaderFragmentNodeItem) { ShaderFragmentNodeItem destinationItem = (ShaderFragmentNodeItem)connection.To.Item; resultConnection.OutputParameterName = destinationItem.Name; } nodeGraph.NodeConstantConnections.Add(resultConnection); } } } else if (connection.From.Node == n) { // This is an output to the next node Node destination = connection.To.Node; if (destination.Tag is ShaderFragmentNodeTag) { ShaderFragmentNodeTag dTag = (ShaderFragmentNodeTag)destination.Tag; ShaderPatcherLayer.NodeConnection resultConnection = new ShaderPatcherLayer.NodeConnection(); resultConnection.InputNodeID = nTag.Id; resultConnection.OutputNodeID = dTag.Id; if (connection.To.Item is ShaderFragmentNodeItem) { ShaderFragmentNodeItem destinationItem = (ShaderFragmentNodeItem)connection.To.Item; resultConnection.OutputParameterName = destinationItem.Name; resultConnection.OutputType = TypeFromNodeItem(destinationItem); } if (connection.From.Item is ShaderFragmentNodeItem) { ShaderFragmentNodeItem sourceItem = (ShaderFragmentNodeItem)connection.From.Item; resultConnection.InputParameterName = sourceItem.Name; resultConnection.InputType = TypeFromNodeItem(sourceItem); } nodeGraph.NodeConnections.Add(resultConnection); } } } } } return nodeGraph; }
public ShaderFragmentPreviewItem(HyperGraph.GraphControl graphControl, ShaderDiagram.Document doc) { _graphControl = graphControl; _document = doc; _builder = null; }
public static Node CreateNode(ShaderFragmentArchive.Function fn, String archiveName, HyperGraph.GraphControl graphControl, ShaderDiagram.Document doc) { var node = new Node(fn.Name); node.Tag = new ShaderProcedureNodeTag(archiveName); node.AddItem(new ShaderFragmentPreviewItem(graphControl, doc)); foreach (var param in fn.InputParameters) { node.AddItem(new ShaderFragmentNodeItem(param.Name, param.Type, archiveName + ":" + param.Name, true, false)); } foreach (var output in fn.Outputs) { node.AddItem(new ShaderFragmentNodeItem(output.Name, output.Type, archiveName + ":" + output.Name, false, true)); } return node; }
public static void EditParameter(HyperGraph.GraphControl graphControl, String archiveName) { //var parameter = ShaderFragmentArchive.Archive.GetParameter(archiveName); //if (parameter != null) //{ // var dialog = new ParameterDialog(); // dialog.PullFrom(parameter); // var result = dialog.ShowDialog(); // if (result == System.Windows.Forms.DialogResult.OK) // { // var newParam = dialog.Result; // // // // // Have to also update the "Name" and "Type" // // fields of any ShaderFragmentNodeItems that are // // using this parameter // // (also changing the source could change input -> output...) // // // // newParam.Name = IdentifierSafeName(newParam.Name); // if (newParam.ArchiveName.Length != 0 // && newParam.ArchiveName.Substring(0, 12).Equals("LocalArchive")) // { // newParam.ArchiveName = "LocalArchive[" + newParam.Name + "]"; // } // // var oldArchiveName = parameter.ArchiveName; // parameter.DeepCopyFrom(newParam); // ShaderFragmentArchive.Archive.RenameParameter(parameter, oldArchiveName); // // ShaderFragmentNodeUtil.UpdateGraphConnectionsForParameter( // graphControl, oldArchiveName, parameter.ArchiveName); // } //} }
void OnConnectorDoubleClick(object sender, HyperGraph.GraphControl.NodeConnectorEventArgs e) { var dialog = new HyperGraph.TextEditForm(); dialog.InputText = "1.0f"; // look for an existing simple connection attached to this connector foreach(var i in e.Node.Connections) { if (i.To == e.Connector && i.From == null) dialog.InputText = i.Name; } var result = dialog.ShowDialog(); if (result == DialogResult.OK) { bool foundExisting = false; foreach (var i in e.Node.Connections) if (i.To == e.Connector && i.From == null) { i.Name = dialog.InputText; foundExisting = true; } if (!foundExisting) { var connection = new NodeConnection(); connection.To = e.Connector; connection.Name = dialog.InputText; e.Node.AddConnection(connection); } ShaderFragmentNodeUtil.InvalidateAttachedConstants(graphControl); } }
public static void AddToHyperGraph(ShaderPatcherLayer.NodeGraph nodeGraph, HyperGraph.GraphControl graphControl, ShaderDiagram.Document doc) { // // Convert from the "ShaderPatcherLayer" representation back to // our graph control nodes. // // This is required for robust serialisation. We can't easily // serialise in and out the graph control objects directly, because // it risks problems if the rendering code or shader fragment objects // change. That is, it's not very version-robust. // // It's better to serialise a slightly higher level representation // that just contains the node names and connections. That way, we // can adapt to changes in the tool and data. // { // --------< Basic Nodes >-------- var newNodes = new Dictionary<int, Node>(); var nodeIdToControlNode = new Dictionary<UInt64, Node>(); foreach (var n in nodeGraph.Nodes) { if (!newNodes.ContainsKey(n.VisualNodeId)) { if (n.NodeType == ShaderPatcherLayer.Node.Type.Procedure) { var fn = ShaderFragmentArchive.Archive.GetFunction(n.FragmentArchiveName); if (fn != null) { var visualNode = nodeGraph.VisualNodes[n.VisualNodeId]; var newNode = ShaderFragmentNodeCreator.CreateNode(fn, n.FragmentArchiveName, graphControl, doc); newNode.Location = visualNode.Location; newNode.Collapsed = visualNode.State == ShaderPatcherLayer.VisualNode.StateType.Collapsed; newNodes[n.VisualNodeId] = newNode; nodeIdToControlNode[n.NodeId] = newNode; } } else { var ps = ShaderFragmentArchive.Archive.GetParameterStruct(n.FragmentArchiveName); if (ps != null) { var visualNode = nodeGraph.VisualNodes[n.VisualNodeId]; var newNode = ShaderFragmentNodeCreator.CreateParameterNode(ps, n.FragmentArchiveName, AsSourceType(n.NodeType)); newNode.Location = visualNode.Location; newNode.Collapsed = visualNode.State == ShaderPatcherLayer.VisualNode.StateType.Collapsed; newNodes[n.VisualNodeId] = newNode; nodeIdToControlNode[n.NodeId] = newNode; } } } } graphControl.AddNodes(newNodes.Values); // --------< Node Connections >-------- foreach (var c in nodeGraph.NodeConnections) { if (nodeIdToControlNode.ContainsKey(c.InputNodeID) && nodeIdToControlNode.ContainsKey(c.OutputNodeID)) { var inputItem = FindOrCreateNodeItem(nodeIdToControlNode[c.InputNodeID], (item) => (item.Output != null && item.Output.Enabled && item is ShaderFragmentNodeItem && ((ShaderFragmentNodeItem)item).Name.Equals(c.InputParameterName)), () => new ShaderFragmentNodeItem("return", c.InputType, null, false, true)); var outputItem = FindOrCreateNodeItem(nodeIdToControlNode[c.OutputNodeID], (item) => (item.Input != null && item.Input.Enabled && item is ShaderFragmentNodeItem && ((ShaderFragmentNodeItem)item).Name.Equals(c.OutputParameterName)), () => new ShaderFragmentNodeItem(c.OutputParameterName, c.OutputType, null, true, false)); graphControl.Connect(inputItem.Output, outputItem.Input); } } // --------< Node Constant Connections >-------- foreach (var c in nodeGraph.NodeConstantConnections) { if (nodeIdToControlNode.ContainsKey(c.OutputNodeID)) { var node = nodeIdToControlNode[c.OutputNodeID]; var outputItem = FindOrCreateNodeItem(node, (item) => (item.Input != null && item.Input.Enabled && item is ShaderFragmentNodeItem && ((ShaderFragmentNodeItem)item).Name.Equals(c.OutputParameterName)), () => new ShaderFragmentNodeItem(c.OutputParameterName, "float", null, true, false)); var connection = new NodeConnection(); connection.To = outputItem.Input; connection.Name = c.Value; node.AddConnection(connection); } } } }
public static Task SerializeAsync(this HyperGraph graph, Stream stream) => JsonSerializer.SerializeAsync(stream, graph);
//public static Node GetParameterNode(HyperGraph.GraphControl graphControl, UInt64 id) //{ // foreach (Node n in graphControl.Nodes) // { // if (n.Tag is ShaderParameterNodeTag // && ((ShaderParameterNodeTag)n.Tag).Id == (UInt64)id) // { // return n; // } // } // return null; //} public static void InvalidateShaderStructure(HyperGraph.GraphControl graphControl) { foreach (Node n in graphControl.Nodes) { foreach (NodeItem i in n.Items) { if (i is ShaderFragmentPreviewItem) { ((ShaderFragmentPreviewItem)i).InvalidateShaderStructure(); } } } }
public static byte[] Serialize(this HyperGraph graph) => JsonSerializer.Serialize(graph);
public static bool FillInMaterialParameters(ShaderDiagram.Document document, HyperGraph.GraphControl graphControl) { // // Look for new or removed material parameters // and update the material parameters dictionary // Dictionary<String, String> newMaterialParameters = new Dictionary<String, String>(); foreach (Node n in graphControl.Nodes) { if (n.Tag is ShaderParameterNodeTag && n.Items.Count() > 0) { // look for a drop down list element -- this will tell us the type ShaderFragmentArchive.Parameter.SourceType type = ShaderFragmentArchive.Parameter.SourceType.System; foreach (var i in n.Items) { if (i is HyperGraph.Items.NodeDropDownItem) { var dropDown = (HyperGraph.Items.NodeDropDownItem)i; var stringForm = dropDown.Items[dropDown.SelectedIndex]; type = ShaderFragmentNodeCreator.AsSourceType(stringForm); break; } } if (type == ShaderFragmentArchive.Parameter.SourceType.Material) { foreach (var i in n.Items) { if (i is ShaderFragmentNodeItem) { ShaderFragmentNodeItem item = (ShaderFragmentNodeItem)i; if (item.Output != null) { if (!newMaterialParameters.ContainsKey(item.ArchiveName)) { var param = ShaderFragmentArchive.Archive.GetParameter(item.ArchiveName); if (param != null) { newMaterialParameters.Add(item.ArchiveName, param.Type); } else { newMaterialParameters.Add(item.ArchiveName, "<<unknown>>"); } } } } } } } } bool didSomething = false; List<String> entriesToRemove = new List<String>(); foreach (String s in document.PreviewMaterialState.Keys) { if (!newMaterialParameters.ContainsKey(s)) { entriesToRemove.Add(s); } } foreach (String s in entriesToRemove) { document.PreviewMaterialState.Remove(s); // does this invalidate the iteration? didSomething = true; } foreach (KeyValuePair<String,String> s in newMaterialParameters) { if (!document.PreviewMaterialState.ContainsKey(s.Key)) { var parameter = ShaderFragmentArchive.Archive.GetParameter(s.Key); System.Object def = null; if (parameter != null && parameter.Default != null && parameter.Default.Length > 0) { def = ShaderPatcherLayer.TypeRules.CreateFromString(parameter.Default, parameter.Type); } var parameterName = s.Key; if (parameter!=null) parameterName = parameter.Name; if (def != null) { document.PreviewMaterialState.Add(parameterName, def); } else { document.PreviewMaterialState.Add(parameterName, ShaderPatcherLayer.TypeRules.CreateDefaultObject(s.Value)); } didSomething = true; } } return didSomething; }
public void GetTileProbabilities() { string path = Path.Combine(Directory.GetParent(Directory.GetCurrentDirectory()).Parent.Parent.FullName, "TestFiles", "tEdgePieces.txt"); //string path = Path.Combine(Directory.GetParent(Directory.GetCurrentDirectory()).Parent.FullName, "TestFiles", "tEdgePieces.txt"); HyperGraph hyperGraph = GraphGenerator.LoadHyperGraphFromFile(path); //Tuple<string, int>[] degrees = hyperGraph.GetVertexDegrees(); Tuple <string, int>[] degrees = hyperGraph.GetVertexEulerDegrees(); Dictionary <HyperEdge, float> probabilities = new Dictionary <HyperEdge, float>(); int blueBlueBlueValues, greenGreenRedValues, greenBlueRedValues; blueBlueBlueValues = greenGreenRedValues = greenBlueRedValues = 0; foreach (HyperEdge edge in hyperGraph.Edges) { int tileSideWs = 0; foreach (Vertex vertex in edge.Vertices) { string reverse = vertex.Value.ReverseString(); int sideWS = degrees.Where(t => t.Item1.Equals(reverse)).Single().Item2; if (edge.Vertices.Select(v => v.Value).Contains(reverse)) { sideWS--; } tileSideWs += sideWS; } string[] vertexCounterParts = edge.Vertices.Select(v => v.Value.ReverseString()).ToArray(); List <HyperEdge> duplicate = hyperGraph.Edges.Where(e => !e.Equals(edge) && e.Vertices.Select(v => v.Value).Intersect(vertexCounterParts).Count() == 2).ToList(); // The number for tileSideWs has to be corrected about the number of those tiles, // which hold more than one 'counterparts' (max counterparts on one tile is 2) // of the actual tile sides. tileSideWs = tileSideWs - duplicate.Count; //float ws = (float)tileSideWs/168.0f; float ws = (float)tileSideWs / 56.0f; probabilities.Add(edge, ws); switch (edge.Vertices.Select(v => v.Value.GetVertexColor()).Distinct().Count()) { case 1: blueBlueBlueValues += edge.Vertices.Select(v => Int32.Parse(v.Value[0].ToString())).Sum(); break; case 2: greenGreenRedValues += edge.Vertices.Select(v => Int32.Parse(v.Value[0].ToString())).Sum(); break; case 3: greenBlueRedValues += edge.Vertices.Select(v => Int32.Parse(v.Value[0].ToString())).Sum(); break; default: throw new InvalidOperationException($"Cannot determine SideType for Tile: {edge.Vertices.Select(v => v.Value[0].ToString()).Aggregate((a, b) => a + " - " + b)}"); } //45 / 6 => 7.5 //150 / 20 => 7.5 //225 / 30 => 7.5 } string outputPath = @"C:\Users\Moritz\Dropbox\Studium\Fulda\5_SS19\Project\Triominos\Graphsuite\GraphSuite\Files"; string outputFile = "tileProbabilitiesAndValues.txt"; if (File.Exists(Path.Combine(outputPath, outputFile))) { File.Delete(Path.Combine(outputPath, outputFile)); } File.WriteAllLines( Path.Combine(outputPath, outputFile), probabilities.OrderBy(kv => kv.Key.GreenSideCount()).Select( kv => kv.Key.Vertices.Select(v => v.Value[0].ToString()).Aggregate((a, b) => a + "-" + b) + " | " + kv.Key.Vertices.Select(v => Int32.Parse(v.Value[0].ToString())).Sum() + " | " + kv.Key.Vertices.Select(v => v.Value.GetVertexColor().ToString()).Aggregate((a, b) => a + "-" + b) + " | " + kv.Value)); }
void Model_ConnectionRemoved(object sender, HyperGraph.NodeConnectionEventArgs e) { SetDirty(true); }
void Model_ConnectionAdded(object sender, HyperGraph.AcceptNodeConnectionEventArgs e) { SetDirty(true); }
public static Node GetShaderFragmentNode(HyperGraph.GraphControl graphControl, UInt64 id) { foreach (Node n in graphControl.Nodes) { if (n.Tag is ShaderFragmentNodeTag && ((ShaderFragmentNodeTag)n.Tag).Id == (UInt64)id) { return n; } } return null; }
public static HyperGraph GenerateTest1() { var graph = new HyperGraph("Testing"); var v1 = new Vertex("1"); var v2 = new Vertex("22"); var v3 = new Vertex("333"); var v4 = new Vertex("4444"); var v5 = new Vertex("55555"); var v6 = new Vertex("666666"); var v7 = new Vertex("7777777"); var v8 = new Vertex("88888888"); var v9 = new Vertex("999999999"); var v10 = new Vertex("1010101010"); var e1 = new HyperEdge { Vertices = { v1, v2, v3 }, Weight = 400 }; var e2 = new HyperEdge { Vertices = { v2, v3, v4 }, Weight = 500 }; var e3 = new HyperEdge { Vertices = { v3, v4, v5 }, Weight = 600 }; var e4 = new HyperEdge { Vertices = { v4, v5, v6 }, Weight = 700 }; var e5 = new HyperEdge { Vertices = { v5, v6, v7 }, Weight = 800 }; var e6 = new HyperEdge { Vertices = { v6, v7, v8 }, Weight = 900 }; var e7 = new HyperEdge { Vertices = { v7, v8, v9 }, Weight = 1000 }; var e8 = new HyperEdge { Vertices = { v8, v9, v10 }, Weight = 50000 }; var e9 = new HyperEdge { Vertices = { v9, v10, v1 }, Weight = 25000 }; var e10 = new HyperEdge { Vertices = { v10, v1, v2 }, Weight = 1000000 }; v1.HyperEdges.Add(e1); v1.HyperEdges.Add(e2); v1.HyperEdges.Add(e3); v2.HyperEdges.Add(e2); v2.HyperEdges.Add(e3); v2.HyperEdges.Add(e4); v3.HyperEdges.Add(e3); v3.HyperEdges.Add(e4); v3.HyperEdges.Add(e5); v4.HyperEdges.Add(e4); v4.HyperEdges.Add(e5); v4.HyperEdges.Add(e6); v5.HyperEdges.Add(e5); v5.HyperEdges.Add(e6); v5.HyperEdges.Add(e7); v6.HyperEdges.Add(e6); v6.HyperEdges.Add(e7); v6.HyperEdges.Add(e8); v7.HyperEdges.Add(e7); v7.HyperEdges.Add(e8); v7.HyperEdges.Add(e9); v8.HyperEdges.Add(e8); v8.HyperEdges.Add(e9); v8.HyperEdges.Add(e10); v9.HyperEdges.Add(e9); v9.HyperEdges.Add(e10); v9.HyperEdges.Add(e1); v10.HyperEdges.Add(e10); v10.HyperEdges.Add(e1); v10.HyperEdges.Add(e2); graph.Vertices.AddRange(new[] { v1, v2, v3, v4, v5, v6, v7, v8, v9, v10 }); graph.HyperEdges.AddRange(new[] { // new HyperEdge {Vertices = {v1, v2, v3, v4, v5, v6, v7, v8, v9, v10}, Weight = 500}, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, }); return(graph); }
private BoundsSpecified GetNodeBounds(HyperGraph.Node element, out Rectangle bounds) { bounds = GetClientSpaceBounds(element); //transform to world coordinates // (note -- these transforms could be avoided by calculating the bounds in canvas space directly, without using the PickingAdapter) var transformAdapter = _control.As<ITransformAdapter>(); bounds = GdiUtil.InverseTransform(transformAdapter.Transform, bounds); return BoundsSpecified.All; }