Beispiel #1
0
        public void Traversal_should_travel_loops_once1()
        {
            using (var storage = new GraphStorage())
            {
                long id1, id2;
                using (var tx = storage.WriteTransaction())
                {
                    id1 = storage.AddVertex(tx, new byte[] { 1, 2, 3 });
                    id2 = storage.AddVertex(tx, new byte[] { 3, 2, 1 });
                    storage.AddEdge(tx, id1, id2);
                    storage.AddEdge(tx, id2, id1);
                    tx.Commit();
                }

                using (var tx = storage.ReadTransaction())
                {
                    var results = storage.Traverse()
                                  .Execute(id1);

                    results.Should()
                    .HaveCount(2)
                    .And
                    .ContainInOrder(id1, id2);

                    results = storage.Traverse()
                              .Execute(id2);

                    results.Should()
                    .HaveCount(2)
                    .And
                    .ContainInOrder(id2, id1);
                }
            }
        }
Beispiel #2
0
    /// <summary> Save the current app state as a project </summary>
    public static void Save()
    {
        Project prj = new Project();

        prj.data          = DataStorage.Create();
        prj.graphSettings = GraphStorage.Create();

        string path = StandaloneFileBrowser.SaveFilePanel("Save your project", "", "", FileExtension);

        if (path == "")
        {
            return;
        }

        string jsonString = JsonUtility.ToJson(prj);

        try
        {
            File.WriteAllText(path, jsonString);
        }
        catch (Exception e)
        {
            string msg = "Error saving project to file " + path + "\n\n" + e.Message;
            UIManager.I.ShowMessageDialog(msg);
            return;
        }
        UIManager.I.ShowMessageDialog("Project Saved");
    }
Beispiel #3
0
        public unsafe void Simple_edge_read_write_without_data_should_work()
        {
            using (var storage = new GraphStorage())
            {
                long vertexId1, vertexId2, edgeId;
                using (var tx = storage.WriteTransaction())
                {
                    vertexId1 = storage.AddVertex(tx, new byte[] { 1, 2, 3 });
                    vertexId2 = storage.AddVertex(tx, new byte[] { 3, 2, 1 });

                    edgeId = storage.AddEdge(tx, vertexId1, vertexId2);

                    tx.Commit();
                }

                using (var tx = storage.ReadTransaction())
                {
                    Assert.Empty(storage.ReadEdgeData(tx, edgeId));

                    int size;
                    var data = storage.ReadEdgeData(tx, edgeId, out size);
                    Assert.Equal(0, size);

                    //will return valid ptr, but the size of data chunk is zero
                    Assert.False(null == data);
                }
            }
        }
Beispiel #4
0
        public void Simple_edge_delete_should_work()
        {
            using (var storage = new GraphStorage())
            {
                long vertexId1, vertexId2, edgeId;
                using (var tx = storage.WriteTransaction())
                {
                    vertexId1 = storage.AddVertex(tx, new byte[] { 1, 2, 3 });
                    vertexId2 = storage.AddVertex(tx, new byte[] { 3, 2, 1 });

                    edgeId = storage.AddEdge(tx, vertexId1, vertexId2, new byte[] { 5, 6, 7, 8 });

                    tx.Commit();
                }

                using (var tx = storage.ReadTransaction())
                {
                    var data = storage.ReadEdgeData(tx, edgeId);
                    Assert.NotNull(data);
                }

                using (var tx = storage.WriteTransaction())
                {
                    storage.RemoveEdge(tx, edgeId);
                    tx.Commit();
                }

                using (var tx = storage.ReadTransaction())
                {
                    var data = storage.ReadEdgeData(tx, edgeId);
                    Assert.Null(data);
                }
            }
        }
Beispiel #5
0
        public void Traversal_with_DFS_should_handle_loops_properly1()
        {
            using (var storage = new GraphStorage())
            {
                long id1, id2, id3;
                using (var tx = storage.WriteTransaction())
                {
                    id1 = storage.AddVertex(tx, new byte[] { 1, 2, 3 });
                    id2 = storage.AddVertex(tx, new byte[] { 3, 2, 1 });
                    id3 = storage.AddVertex(tx, new byte[] { 1, 1, 1 });
                    storage.AddEdge(tx, id1, id2);
                    storage.AddEdge(tx, id2, id3);
                    storage.AddEdge(tx, id3, id1);
                    tx.Commit();
                }

                using (var tx = storage.ReadTransaction())
                {
                    var results = storage.Traverse()
                                  .WithStrategy(Traversal.Strategy.Dfs)
                                  .Execute(id1);

                    results.Should()
                    .HaveCount(3)
                    .And
                    .Contain(new[] { id1, id2, id3 });
                }
            }
        }
Beispiel #6
0
        public void Traversal_without_limits_should_traverse_all_edges1()
        {
            using (var storage = new GraphStorage())
            {
                long id1, id2;
                using (var tx = storage.WriteTransaction())
                {
                    id1 = storage.AddVertex(tx, new byte[] { 1, 2, 3 });
                    id2 = storage.AddVertex(tx, new byte[] { 3, 2, 1 });
                    storage.AddEdge(tx, id1, id2);
                    tx.Commit();
                }

                using (var tx = storage.ReadTransaction())
                {
                    var results = storage.Traverse()
                                  .Execute(id1);

                    results.Should()
                    .HaveCount(2)
                    .And
                    .Contain(id1).And.Contain(id2);

                    results = storage.Traverse()
                              .Execute(id2);

                    results.Should()
                    .HaveCount(1)
                    .And
                    .OnlyContain(r => r == id2);
                }
            }
        }
        public async Task BFS_FindOne_with_disconnected_root_should_return_null()
        {
            var graph = new GraphStorage("TestGraph", Env);
            Node node2;
            using (var tx = graph.NewTransaction(TransactionFlags.ReadWrite))
            {
                var node1 = graph.Commands.CreateNode(tx, JsonFromValue("test1"));
                node2 = graph.Commands.CreateNode(tx, JsonFromValue("test2"));
                var node3 = graph.Commands.CreateNode(tx, JsonFromValue("test3"));

                graph.Commands.CreateEdgeBetween(tx, node3, node1);
                graph.Commands.CreateEdgeBetween(tx, node3, node2);

                //note: root node is selected by using a first node that was added
                //since Voron.Graph is a directed graph - no node leads from the root node means nothing
                //can be found

                tx.Commit();
            }

            using (var tx = graph.NewTransaction(TransactionFlags.Read))
            {
                var bfs = new BreadthFirstSearch(graph, CancelTokenSource.Token);
                var node = await bfs.FindOne(tx, data => ValueFromJson<string>(data).Equals("test2"));

                node.Should().BeNull();
            }
        }
        public async Task BFS_FindOne_with_connected_root_should_return_correct_results()
        {
            var graph = new GraphStorage("TestGraph", Env);
            Node node2;
            using (var tx = graph.NewTransaction(TransactionFlags.ReadWrite))
            {
                var node1 = graph.Commands.CreateNode(tx, JsonFromValue("test1"));
                node2 = graph.Commands.CreateNode(tx, JsonFromValue("test2"));
                var node3 = graph.Commands.CreateNode(tx, JsonFromValue("test3"));

                graph.Commands.CreateEdgeBetween(tx, node3, node1);
                graph.Commands.CreateEdgeBetween(tx, node3, node2);

                graph.Commands.CreateEdgeBetween(tx, node2, node2);
                graph.Commands.CreateEdgeBetween(tx, node1, node3);

                tx.Commit();
            }

            using (var tx = graph.NewTransaction(TransactionFlags.Read))
            {
                var bfs = new BreadthFirstSearch(graph, CancelTokenSource.Token);
                var node = await bfs.FindOne(tx, data => ValueFromJson<string>(data).Equals("test2"));

                node.Should().NotBeNull();
                node.Key.Should().Be(node2.Key);
            }
        }
        public void Simple_shortest_path_with_equal_weights_and_alternative_path ()
        {
            var graph = new GraphStorage("TestGraph", Env);

            Node node1, node2, node3,node4,node5;
            using (var tx = graph.NewTransaction(TransactionFlags.ReadWrite))
            {
                node1 = graph.Commands.CreateNode(tx, JsonFromValue(1));
                node2 = graph.Commands.CreateNode(tx, JsonFromValue(1));
                node3 = graph.Commands.CreateNode(tx, JsonFromValue(1));
                node4 = graph.Commands.CreateNode(tx, JsonFromValue(1));
                node5 = graph.Commands.CreateNode(tx, JsonFromValue(1));

                node1.ConnectWith(tx, node2, graph);
                node1.ConnectWith(tx, node3, graph);
                node2.ConnectWith(tx, node4, graph);
                node4.ConnectWith(tx, node5, graph);
                node5.ConnectWith(tx, node3, graph);

                tx.Commit();
            }

            using (var tx = graph.NewTransaction(TransactionFlags.Read))
            {
                var shortestPathsData = GetAlgorithm(tx, graph, node1).Execute();

                var shortestNodePath = shortestPathsData.GetShortestPathToNode(node3).ToList();
                shortestNodePath.Should().ContainInOrder(node1.Key, node3.Key);
            }
        }
Beispiel #10
0
        public void Put_edge_between_nodes_in_different_session_should_work()
        {
            var graph = new GraphStorage("TestGraph", Env);
            Node node1, node2, node3;
            using (var tx = graph.NewTransaction(TransactionFlags.ReadWrite))
            {
                node1 = graph.Commands.CreateNode(tx, JsonFromValue("test1"));
                node2 = graph.Commands.CreateNode(tx, JsonFromValue("test2"));
                node3 = graph.Commands.CreateNode(tx, JsonFromValue("test3"));
                tx.Commit();
            }

            using (var tx = graph.NewTransaction(TransactionFlags.ReadWrite))
            {
                graph.Commands.CreateEdgeBetween(tx, node2, node3);
                graph.Commands.CreateEdgeBetween(tx, node2, node1);

                //looping edge also ok!
                //adding multiple loops will overwrite each other
                //TODO: add support for multiple edges that have the same keyFrom and keyTo
                graph.Commands.CreateEdgeBetween(tx, node2, node2);

                tx.Commit();
            }

            using (var tx = graph.NewTransaction(TransactionFlags.Read))
            {
                var adjacentNodes = graph.Queries.GetAdjacentOf(tx, node2);
                adjacentNodes.Select(x => x.Key).Should().Contain(new []{ node1.Key, node2.Key, node3.Key});
            }
        }
Beispiel #11
0
 internal AStarShortestPath(GraphStorage parent,
                            Func <long, long, TableValueReader, double> g,
                            Func <long, TableValueReader, double> h)
 {
     _parent = parent;
     _g      = g;
     _h      = h;
 }
Beispiel #12
0
        public unsafe void GetAdjacent_should_work()
        {
            using (var storage = new GraphStorage())
            {
                long vertexId1, vertexId2, vertexId3, vertexId4, vertexId5;
                using (var tx = storage.WriteTransaction())
                {
                    vertexId1 = storage.AddVertex(tx, new byte[] { 1, 2, 3 });
                    vertexId2 = storage.AddVertex(tx, new byte[] { 3, 2, 1 });
                    vertexId3 = storage.AddVertex(tx, new byte[] { 4, 5, 6 });
                    vertexId4 = storage.AddVertex(tx, new byte[] { 7 });
                    vertexId5 = storage.AddVertex(tx, new byte[] { 8 });

                    storage.AddEdge(tx, vertexId1, vertexId2);
                    storage.AddEdge(tx, vertexId1, vertexId3);
                    storage.AddEdge(tx, vertexId1, vertexId5);

                    storage.AddEdge(tx, vertexId4, vertexId2);
                    storage.AddEdge(tx, vertexId4, vertexId4);
                    storage.AddEdge(tx, vertexId4, vertexId1);

                    storage.AddEdge(tx, vertexId2, vertexId3);
                    tx.Commit();
                }

                using (var tx = storage.ReadTransaction())
                {
                    var adjacentVertices = storage.GetAdjacent(tx, vertexId1).ToList();
                    adjacentVertices.Should()
                    .HaveCount(3)
                    .And.Contain(new[]
                    {
                        vertexId2,
                        vertexId3,
                        vertexId5
                    });

                    adjacentVertices = storage.GetAdjacent(tx, vertexId2).ToList();
                    adjacentVertices.Should()
                    .HaveCount(1)
                    .And.Contain(new[]
                    {
                        vertexId3
                    });

                    adjacentVertices = storage.GetAdjacent(tx, vertexId4).ToList();
                    adjacentVertices.Should()
                    .HaveCount(3)
                    .And.Contain(new[]
                    {
                        vertexId1,
                        vertexId2,
                        vertexId4
                    });
                }
            }
        }
    void Update()
    {
        if (Input.GetKeyDown("space"))
        {
            Debug.Log("pressed space");
            GraphStorage storage = gameObject.AddComponent(typeof(GraphStorage)) as GraphStorage;

            int startTime = Environment.TickCount;
            mapgrid = storage.Load();
            int endTime = Environment.TickCount;
            Debug.Log(string.Format("Time to load: {0}", endTime - startTime));

            Debug.Log(mapgrid);

            startTime      = Environment.TickCount;
            Cell[,,] graph = mapgrid.createGraph();
            endTime        = Environment.TickCount;
            Debug.Log(string.Format("Time to create grid: {0}", endTime - startTime));

            Astar astar = new Astar(mapgrid);

            float[] floatorigin = new float[] { origin[0], origin[1], origin[2] };
            float[] floattarget = new float[] { target[0], target[1], target[2] };

            startTime = Environment.TickCount;
            var answer = astar.search(floatorigin, floattarget);
            endTime = Environment.TickCount;
            Debug.Log(string.Format("Time to search: {0}", endTime - startTime));

            List <Vector3> vectorPath;

            if (answer == null)
            {
                Debug.Log("ASTAR: No valid path");
                vectorPath = null;
            }
            else
            {
                startTime  = Environment.TickCount;
                vectorPath = astar.PathToVectors();
                endTime    = Environment.TickCount;
                Debug.Log(string.Format("Time to convert to vector: {0}", endTime - startTime));
            }

            foreach (Vector3 vec in vectorPath)
            {
                // Debug.Log(vec.ToString());
                GameObject cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
                cube.transform.localScale = new Vector3(.5f, .5f, .5f);
                cube.transform.position   = vec;
                cube.GetComponent <Renderer>().material.color = Color.green;
            }

            Debug.Log(string.Format("StraightLineRatio: {0}", astar.StraightLineRatio()));
        }
    }
Beispiel #14
0
        public void Traversal_with_min_depth_should_traverse_relevant_edges1_with_DFS()
        {
            using (var storage = new GraphStorage())
            {
                long id1, id2, id3, id4, id5;
                using (var tx = storage.WriteTransaction())
                {
                    id1 = storage.AddVertex(tx, new byte[] { 1, 2, 3 });
                    id2 = storage.AddVertex(tx, new byte[] { 3, 2, 1 });
                    id3 = storage.AddVertex(tx, new byte[] { 3, 2, 1 });
                    id4 = storage.AddVertex(tx, new byte[] { 3, 2, 1 });
                    id5 = storage.AddVertex(tx, new byte[] { 3, 2, 1 });
                    storage.AddEdge(tx, id1, id2);
                    storage.AddEdge(tx, id2, id3);
                    storage.AddEdge(tx, id2, id4);
                    storage.AddEdge(tx, id4, id5);
                    tx.Commit();
                }

                using (var tx = storage.ReadTransaction())
                {
                    var results = storage.Traverse()
                                  .WithStrategy(Traversal.Strategy.Dfs)
                                  .WithMinDepth(1)
                                  .Execute(id1);

                    results.Should()
                    .HaveCount(4)
                    .And
                    .Contain(new[] { id2, id3, id4, id5 });

                    results = storage.Traverse()
                              .WithStrategy(Traversal.Strategy.Dfs)
                              .WithMinDepth(2)
                              .Execute(id1);

                    results.Should()
                    .HaveCount(3)
                    .And
                    .Contain(new[] { id3, id4, id5 });

                    results = storage.Traverse()
                              //zero-based depth,
                              //4 levels in total
                              .WithStrategy(Traversal.Strategy.Dfs)
                              .WithMinDepth(3)
                              .Execute(id1);

                    results.Should()
                    .HaveCount(1)
                    .And
                    .Contain(id5);
                }
            }
        }
 public DijkstraMultiDestinationShortestPath(Transaction tx, GraphStorage graphStorage, Node root, CancellationToken cancelToken)
 {
     _rootNode = root;
     _shortestPathVisitor = new DijkstraMultiDestinationShortestPathVisitor(root, 
         (nodeFrom, nodeTo) => 0, 
         (traversalInfo, adjacentNode) => adjacentNode.EdgeTo.Weight + traversalInfo.TotalEdgeWeightUpToNow);
     _bfs = new TraversalAlgorithm(tx, graphStorage, root, TraversalType.BFS, cancelToken)
     {
         Visitor = _shortestPathVisitor
     };
 }
    // Start is called before the first frame update
    void Start()
    {
        numSamples = numBoxes * numBoxes * numBoxes;
        sample     = 0;
        int percent = numSamples / 100;

        Debug.Log(percent);
        int startTime = Environment.TickCount;
        // bool[,,] collisionMask = new bool[(int)numBoxes, (int)numBoxes, (int)numBoxes];

        MapGrid grid = new MapGrid();

        float[] startpos = new float[] { startPosition[0], startPosition[1], startPosition[2] };
        int[]   initsize = new int[] { (int)numBoxes, (int)numBoxes, (int)numBoxes, };
        grid.initialize(startpos, initsize, boxSize);
        for (int x = 0; x < numBoxes; x++)
        {
            for (int y = 0; y < numBoxes; y++)
            {
                for (int z = 0; z < numBoxes; z++)
                {
                    Collider[] hitColliders = Physics.OverlapBox(new Vector3(x * boxSize + startPosition[0], y * boxSize + startPosition[1], z * boxSize + startPosition[2]), new Vector3(objectRadius, objectRadius, objectRadius), Quaternion.identity, m_LayerMask);

                    if (hitColliders.Length > 0)
                    {
                        GameObject cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
                        cube.transform.localScale = new Vector3(boxSize, boxSize, boxSize);
                        cube.transform.position   = new Vector3(x * boxSize + startPosition[0], y * boxSize + startPosition[1], z * boxSize + startPosition[2]);
                        cube.GetComponent <Renderer>().material.color = Color.red;

                        grid.setMaskItem(x, y, z, false);
                    }
                    else
                    {
                        grid.setMaskItem(x, y, z, true);
                    }

                    sample++;
                }
            }
        }

        int endTime = Environment.TickCount;

        Debug.Log(endTime - startTime);


        GraphStorage storage = gameObject.AddComponent(typeof(GraphStorage)) as GraphStorage;

        storage.Save(grid);
        Debug.Log(Application.persistentDataPath);
    }
Beispiel #17
0
        public void Traversal_without_edges_should_return_first_vertex()
        {
            using (var storage = new GraphStorage())
            {
                long id1, id2;
                using (var tx = storage.WriteTransaction())
                {
                    id1 = storage.AddVertex(tx, new byte[] { 1, 2, 3 });
                    id2 = storage.AddVertex(tx, new byte[] { 3, 2, 1 });
                    tx.Commit();
                }

                //test both dfs and bfs
                using (var tx = storage.ReadTransaction())
                {
                    var results = storage.Traverse()
                                  .WithStrategy(Traversal.Strategy.Bfs)
                                  .Execute(id1);

                    results.Should()
                    .HaveCount(1)
                    .And
                    .OnlyContain(r => r == id1);

                    results = storage.Traverse()
                              .Execute(id2);

                    results.Should()
                    .HaveCount(1)
                    .And
                    .OnlyContain(r => r == id2);

                    results = storage.Traverse()
                              .WithStrategy(Traversal.Strategy.Dfs)
                              .Execute(id1);

                    results.Should()
                    .HaveCount(1)
                    .And
                    .OnlyContain(r => r == id1);

                    results = storage.Traverse()
                              .Execute(id2);

                    results.Should()
                    .HaveCount(1)
                    .And
                    .OnlyContain(r => r == id2);
                }
            }
        }
 protected BaseSingleDestinationShortestPath(Transaction tx,
     GraphStorage graphStorage,
     Node root,
     Node targetNode,
     SingleDestinationShortestPathVisitor shortestPathVisitor,
     TraversalAlgorithm traversal,
     CancellationToken cancelToken)
 {
     _rootNode = root;
     _targetNode = targetNode;
     _shortestPathVisitor = shortestPathVisitor;
     _traversal = traversal;
     _traversal.Visitor = shortestPathVisitor;
 }
 public EdmondsKarpMaximumFlow(Transaction tx, 
     GraphStorage graphStorage, 
     Node sourceNode, 
     Node targetNode,
     Func<Edge, long> capacity,
     CancellationToken? cancelToken = null)
     : base(capacity)
 {
     _sourceNode = sourceNode;
     _targetNode = targetNode;
     _storage = graphStorage;
     _cancelToken = cancelToken;
     _flow = new Dictionary<Tuple<long, long>, long>();
     _tx = tx;
 }
Beispiel #20
0
        public void Traversal_with_DFS_and_with_vertex_visitor_should_visit_vertices_once()
        {
            using (var storage = new GraphStorage())
            {
                long id1, id2, id3, id4;
                using (var tx = storage.WriteTransaction())
                {
                    id1 = storage.AddVertex(tx, new byte[] { 1, 2, 3 });
                    id2 = storage.AddVertex(tx, new byte[] { 3, 2, 1 });
                    id3 = storage.AddVertex(tx, new byte[] { 1, 1, 1 });
                    id4 = storage.AddVertex(tx, new byte[] { 1, 0, 1 });

                    //create well connected graph
                    storage.AddEdge(tx, id1, id2);
                    storage.AddEdge(tx, id2, id3);
                    storage.AddEdge(tx, id3, id1);
                    storage.AddEdge(tx, id2, id4);
                    storage.AddEdge(tx, id1, id4);
                    storage.AddEdge(tx, id3, id4);
                    storage.AddEdge(tx, id4, id3);
                    tx.Commit();
                }

                using (var tx = storage.ReadTransaction())
                {
                    var fetchedData  = new List <byte[]>();
                    var expectedData = new[]
                    {
                        new byte[] { 1, 2, 3 },
                        new byte[] { 3, 2, 1 },
                        new byte[] { 1, 1, 1 },
                        new byte[] { 1, 0, 1 }
                    };

                    var results = storage.Traverse()
                                  .WithStrategy(Traversal.Strategy.Dfs)
                                  .Execute(id1,
                                           vertexVisitor: reader =>
                    {
                        var data = reader.ReadData((int)VertexTableFields.Data);
                        fetchedData.Add(data);
                    });

                    //DFS has reverse traversal order
                    Assert.Equal(expectedData.Reverse(), fetchedData);
                }
            }
        }
Beispiel #21
0
        public void Construct()
        {
            _graph = new GraphStorage<string, Variable>();
            foreach (Variable variable in _storage.Variables)
            {
                _graph.AddNode(VariableKey(variable), variable);
            }
            foreach (Connection connection in _storage.Connections.Where(conn => conn.Type == ConnectionType.Data))
            {
                string nodeKey = GetConnectionNodeKey(connection.Source, connection.FBType);
                string connectedNodeKey = GetConnectionNodeKey(connection.Destination, connection.FBType);

                _graph.AddConnection(nodeKey, connectedNodeKey, k => k == connectedNodeKey);
                _graph.AddConnection(connectedNodeKey, nodeKey, k => k == nodeKey);
            }
        }
Beispiel #22
0
        public static GraphStorage SetGraphStorage(BlockGraph graph, int walletIdentifier, GraphStateEnum stateGraph)
        {
            string hash    = GraphCompression.GetUniqueGraphHash(walletIdentifier, graph.CompressedRaw);
            var    storage = new GraphStorage()
            {
                StoredHash            = hash,
                CompressedBytes       = graph.CompressedRaw,
                WalletIdentifierOwner = walletIdentifier,
                StateGraph            = stateGraph
            };

            var conn = muxer.GetDatabase(0);

            conn.StringSet(string.Format("graphs/{0}", hash), JsonConvert.SerializeObject(storage));
            return(storage);
        }
        public async Task BFS_FindOne_with_only_root_node_in_graph_returns_correct_results()
        {
            var graph = new GraphStorage("TestGraph", Env);
            using (var tx = graph.NewTransaction(TransactionFlags.ReadWrite))
            {
                graph.Commands.CreateNode(tx, JsonFromValue("test1"));
                tx.Commit();
            }

            using (var tx = graph.NewTransaction(TransactionFlags.Read))
            {
                var bfs = new BreadthFirstSearch(graph, CancelTokenSource.Token);
                var node = await bfs.FindOne(tx, data => ValueFromJson<string>(data).Equals("test1"));

                node.Should().NotBeNull();
            }
        }
 public DijkstraShortestPath(Transaction tx,
     GraphStorage graphStorage,
     Node root,
     Node targetNode,
     CancellationToken cancelToken)
     : base(tx,graphStorage,root,targetNode,
     new SingleDestinationShortestPathVisitor(root, targetNode,
         (nodeFrom, nodeTo) => 0,
         (traversalInfo, adjacentNode) => adjacentNode.EdgeTo.Weight + traversalInfo.TotalEdgeWeightUpToNow),
         new TraversalAlgorithm(tx,
         graphStorage,
         root,
         TraversalType.BFS,
         cancelToken),
     cancelToken    
     )
 {
     _shortestPathVisitor.IsProcessingQueueEmpty = () => _traversal.ProcessingQueueCount == 0;
 }      
 public AStarShortestPath(Transaction tx, 
     GraphStorage graphStorage, 
     Node root, 
     Node targetNode,
     Func<Node,Node,double> heuristic,
     CancellationToken cancelToken)
     :base(tx,graphStorage,root,targetNode,
     new AStarShortestPathVisitor(root, targetNode,
         heuristic,
         (traversalInfo, adjacentNode) => adjacentNode.EdgeTo.Weight + traversalInfo.TotalEdgeWeightUpToNow),
     new TraversalAlgorithm(tx,
         graphStorage,
         root,
         new PriorityQueueTraversalStore(new TraversalNodeInfoComparer(root, heuristic)),
         cancelToken),
     cancelToken)
 {
     _shortestPathVisitor.IsProcessingQueueEmpty = () => _traversal.ProcessingQueueCount == 0;
 }      
Beispiel #26
0
        public void Initialization_should_work()
        {
            //create in-memory
            using (var storage = new GraphStorage())
            { }

            //create persisted
            var tempPath = Path.GetTempPath() + Path.DirectorySeparatorChar + Guid.NewGuid();

            try
            {
                using (var storage = new GraphStorage(tempPath))
                {
                }
            }
            finally
            {
                Directory.Delete(tempPath, true);
            }
        }
Beispiel #27
0
        public void Simple_vertex_delete_should_work()
        {
            using (var storage = new GraphStorage())
            {
                long id;
                using (var tx = storage.WriteTransaction())
                {
                    id = storage.AddVertex(tx, new byte[] { 1, 2, 3 });
                    tx.Commit();
                }

                using (var tx = storage.WriteTransaction())
                {
                    storage.RemoveVertex(tx, id);
                    tx.Commit();
                }

                using (var tx = storage.ReadTransaction())
                    Assert.Null(storage.ReadVertexData(tx, id));
            }
        }
Beispiel #28
0
        public void Traversal_with_DFS_and_with_edges_visitor_should_visit_vertices_once()
        {
            using (var storage = new GraphStorage())
            {
                long id1, id2, id3;
                using (var tx = storage.WriteTransaction())
                {
                    id1 = storage.AddVertex(tx, new byte[] { 1, 2, 3 });
                    id2 = storage.AddVertex(tx, new byte[] { 3, 2, 1 });
                    id3 = storage.AddVertex(tx, new byte[] { 1, 1, 1 });
                    storage.AddEdge(tx, id1, id2, new byte[] { 12 });
                    storage.AddEdge(tx, id2, id3, new byte[] { 23 });
                    storage.AddEdge(tx, id3, id1, new byte[] { 31 });
                    tx.Commit();
                }

                using (var tx = storage.ReadTransaction())
                {
                    var fetchedData  = new List <byte[]>();
                    var expectedData = new[]
                    {
                        new byte[] { 12 },
                        new byte[] { 23 },
                        new byte[] { 31 }
                    };
                    var results = storage.Traverse()
                                  .WithStrategy(Traversal.Strategy.Dfs)
                                  .Execute(id1,
                                           edgeVisitor: reader =>
                    {
                        var data = reader.ReadData((int)EdgeTableFields.Data);
                        fetchedData.Add(data);
                    });

                    //DFS visits edges in the same manner as BFS, but vertices it visits in reverse
                    Assert.Equal(expectedData, fetchedData);
                }
            }
        }
Beispiel #29
0
        public void Traversal_with_max_results_should_return_proper_number_of_results()
        {
            using (var storage = new GraphStorage())
            {
                long id1, id2, id3;
                using (var tx = storage.WriteTransaction())
                {
                    id1 = storage.AddVertex(tx, new byte[] { 1, 2, 3 });
                    id2 = storage.AddVertex(tx, new byte[] { 3, 2, 1 });
                    id3 = storage.AddVertex(tx, new byte[] { 1, 1, 1 });
                    storage.AddEdge(tx, id1, id2);
                    storage.AddEdge(tx, id2, id3);
                    storage.AddEdge(tx, id3, id1);
                    tx.Commit();
                }

                using (var tx = storage.ReadTransaction())
                {
                    var results = storage.Traverse()
                                  .WithMaxResults(2)
                                  .Execute(id1);

                    results.Should()
                    .HaveCount(2)
                    .And
                    .Contain(new[] { id1, id2 });

                    results = storage.Traverse()
                              .WithMaxResults(2)
                              .Execute(id2);

                    results.Should()
                    .HaveCount(2)
                    .And
                    .Contain(new[] { id2, id3 });
                }
            }
        }
Beispiel #30
0
        public void Simple_vertex_read_write_should_work()
        {
            using (var storage = new GraphStorage())
            {
                long id1, id2;
                using (var tx = storage.WriteTransaction())
                {
                    id1 = storage.AddVertex(tx, new byte[] { 1, 2, 3 });
                    id2 = storage.AddVertex(tx, new byte[] { 3, 2, 1 });
                    tx.Commit();
                }

                using (var tx = storage.ReadTransaction())
                {
                    var data1 = storage.ReadVertexData(tx, id1);
                    Assert.NotNull(data1);
                    Assert.Equal(new byte[] { 1, 2, 3 }, data1);
                    var data2 = storage.ReadVertexData(tx, id2);
                    Assert.NotNull(data2);
                    Assert.Equal(new byte[] { 3, 2, 1 }, data2);
                }
            }
        }
Beispiel #31
0
        public void Traversal_with_max_results_lower_than_actual_results_should_have_no_effect()
        {
            using (var storage = new GraphStorage())
            {
                long id1, id2, id3;
                using (var tx = storage.WriteTransaction())
                {
                    id1 = storage.AddVertex(tx, new byte[] { 1, 2, 3 });
                    id2 = storage.AddVertex(tx, new byte[] { 3, 2, 1 });
                    id3 = storage.AddVertex(tx, new byte[] { 1, 1, 1 });
                    storage.AddEdge(tx, id1, id2);
                    storage.AddEdge(tx, id2, id3);
                    storage.AddEdge(tx, id3, id1);
                    tx.Commit();
                }

                using (var tx = storage.ReadTransaction())
                {
                    var results = storage.Traverse()
                                  .WithMaxResults(50)
                                  .Execute(id1);

                    results.Should()
                    .HaveCount(3)
                    .And
                    .ContainInOrder(id1, id2, id3);

                    results = storage.Traverse()
                              .Execute(id2);

                    results.Should()
                    .HaveCount(3)
                    .And
                    .ContainInOrder(id2, id3, id1);
                }
            }
        }
Beispiel #32
0
        private long Create2DepthHierarchy(GraphStorage graph)
        {
            long centerNodeKey = 0;
            using (var tx = graph.NewTransaction(TransactionFlags.ReadWrite))
            {
                var centerNode = graph.Commands.CreateNode(tx, JsonFromValue("centerNode"));
                centerNodeKey = centerNode.Key;


                for (var i = 1; i < 6; i++)
                {
                    var curChild = graph.Commands.CreateNode(tx,JsonFromValue("childNode" + i.ToString()));
                    graph.Commands.CreateEdgeBetween(tx, centerNode, curChild, JsonFromValue(i.ToString()));

                    for (var j = 1; j < 6; j++)
                    {
                        var curGrandChild = graph.Commands.CreateNode(tx, JsonFromValue(string.Concat("grandchild", i.ToString(), "child", i.ToString())));
                        graph.Commands.CreateEdgeBetween(tx, curChild, curGrandChild,JsonFromValue((i * 10 + j).ToString()));
                    }
                }
                tx.Commit();
            }
            return centerNodeKey;
        }
 public BreadthFirstSearch(GraphStorage graphStorage, CancellationToken cancelToken)
     : base(cancelToken)
 {
     _graphStorage = graphStorage;
 }
Beispiel #34
0
        public void Edge_predicate_should_filter_edge_types_correctly()
        {
            var graph = new GraphStorage("TestGraph", Env);
            Node node1, node2, node3, node4, node5;
            using (var tx = graph.NewTransaction(TransactionFlags.ReadWrite))
            {
                node1 = graph.Commands.CreateNode(tx, JsonFromValue("test1"));
                node2 = graph.Commands.CreateNode(tx, JsonFromValue("test2"));
                node3 = graph.Commands.CreateNode(tx, JsonFromValue("test3"));
                node4 = graph.Commands.CreateNode(tx, JsonFromValue("test4"));
                node5 = graph.Commands.CreateNode(tx, JsonFromValue("test5"));
                tx.Commit();
            }

            using (var tx = graph.NewTransaction(TransactionFlags.ReadWrite))
            {
                graph.Commands.CreateEdgeBetween(tx, node1, node2,type: 1);
                graph.Commands.CreateEdgeBetween(tx, node1, node3, type: 2);
                graph.Commands.CreateEdgeBetween(tx, node1, node4, type: 3);
                graph.Commands.CreateEdgeBetween(tx, node1, node5, type: 2);

                tx.Commit();
            }

            using (var tx = graph.NewTransaction(TransactionFlags.Read))
            {
                var adjacentNodes = graph.Queries.GetAdjacentOf(tx, node1, type => type == 2);
                adjacentNodes.Select(x => x.Node.Key).Should().Contain(new[] { node3.Key, node5.Key });
            }
        }
        public void Between_two_equivalent_paths_first_created_should_be_chosen()
        {
            var graph = new GraphStorage("TestGraph", Env);

            Node node1, node2, node3, node4;
            using (var tx = graph.NewTransaction(TransactionFlags.ReadWrite))
            {
                node1 = graph.Commands.CreateNode(tx, JsonFromValue(1));
                node2 = graph.Commands.CreateNode(tx, JsonFromValue(2));
                node3 = graph.Commands.CreateNode(tx, JsonFromValue(3));
                node4 = graph.Commands.CreateNode(tx, JsonFromValue(4));

                node1.ConnectWith(tx, node2, graph, 2);
                node2.ConnectWith(tx, node4, graph, 1);

                node1.ConnectWith(tx, node3, graph, 1);
                node3.ConnectWith(tx, node4, graph, 2);

                tx.Commit();
            }

            using (var tx = graph.NewTransaction(TransactionFlags.Read))
            {
                var shortestPathsData = GetAlgorithm(tx, graph, node1).Execute();

                var shortestNodePath = shortestPathsData.GetShortestPathToNode(node4).ToList();
                shortestNodePath.Should().ContainInOrder(node1.Key, node2.Key, node4.Key);
            }
        }
        public void Simple_shortest_path_with_varying_edge_weight_should_work()
        {
            var graph = new GraphStorage("TestGraph", Env);

            Node node1, node2, node3;
            using (var tx = graph.NewTransaction(TransactionFlags.ReadWrite))
            {
                node1 = graph.Commands.CreateNode(tx, JsonFromValue(1));
                node2 = graph.Commands.CreateNode(tx, JsonFromValue(2));
                node3 = graph.Commands.CreateNode(tx, JsonFromValue(3));

                node1.ConnectWith(tx, node2, graph, 2);
                node1.ConnectWith(tx, node3, graph, 10);
                node2.ConnectWith(tx, node3, graph, 2);

                tx.Commit();
            }

            using (var tx = graph.NewTransaction(TransactionFlags.Read))
            {
                var shortestPathsData = GetAlgorithm(tx, graph, node1).Execute();

                var shortestNodePath = shortestPathsData.GetShortestPathToNode(node3).ToList();
                shortestNodePath.Should().ContainInOrder(node1.Key, node2.Key, node3.Key);
            }
        }
Beispiel #37
0
        public void Read_and_writing_system_metadata_should_work()
        {
            var graph = new GraphStorage("TestGraph", Env);
            using (var tx = graph.NewTransaction(TransactionFlags.ReadWrite))
            {
                graph.Commands.PutToSystemMetadata(tx, "Foo", "Bar");
                graph.Commands.PutToSystemMetadata(tx, "FooNum", 123);
                graph.Commands.PutToSystemMetadata(tx, "FooBoolean", false);
                
                tx.Commit();
            }

            using (var tx = graph.NewTransaction(TransactionFlags.Read))
            {
                var bar = graph.Queries.GetFromSystemMetadata<string>(tx, "Foo");
                var fooNum = graph.Queries.GetFromSystemMetadata<int>(tx, "FooNum");
                var fooBoolean = graph.Queries.GetFromSystemMetadata<bool>(tx, "FooBoolean");

                Assert.AreEqual("Bar", bar);
                Assert.AreEqual(123, fooNum);
                Assert.AreEqual(false, fooBoolean);
            }
        }
Beispiel #38
0
 public static Task<List<Edge>> GetEdges(this Node node, Transaction tx, GraphStorage storage, CancellationToken token)
 {
     return storage.AdminQueries.GetEdgesOfNode(tx, node, token);
 }
Beispiel #39
0
 public static Edge ConnectWith(this Node node,Transaction tx,Node otherNode, GraphStorage storage,short weight = 1)
 {            
     return storage.Commands.CreateEdgeBetween(tx,node,otherNode,edgeWeight:weight);
 }
Beispiel #40
0
        public void Can_Iterate_On_Nearest_Nodes()
        {
            var graph = new GraphStorage("TestGraph", Env);
            long centerNodeKey = 0;

            centerNodeKey = Create2DepthHierarchy(graph);

            using (var tx = graph.NewTransaction(TransactionFlags.Read))
            {
                var centerNode = graph.Queries.LoadNode(tx, centerNodeKey);
                var nodeValues = new Dictionary<string, string>();
	            string curEdgeVal;
                string curNodeVal;

                foreach (var curNode in graph.Queries.GetAdjacentOf(tx, centerNode))
                {
                    var curEdge = graph.Queries.GetEdgesBetween(tx, centerNode, curNode).FirstOrDefault();              
                    Assert.IsNotNull(curEdge);

                    curEdgeVal = curEdge.Data.Value<string>("Value");
                    curNodeVal = curNode.Data.Value<string>("Value");

                    nodeValues.Add(curNodeVal, curEdgeVal);

                }

                nodeValues.Values.Should().NotContain("grandchild");
                Assert.AreEqual(nodeValues.Count, 5);
            }
        }
        public void No_path_between_nodes_should_result_in_null()
        {
            var graph = new GraphStorage("TestGraph", Env);

            Node node1, node2;
            using (var tx = graph.NewTransaction(TransactionFlags.ReadWrite))
            {
                node1 = graph.Commands.CreateNode(tx, JsonFromValue(1));
                node2 = graph.Commands.CreateNode(tx, JsonFromValue(2));

             
                tx.Commit();
            }

            using (var tx = graph.NewTransaction(TransactionFlags.Read))
            {
                var shortestPathsData = GetAlgorithm(tx, graph, node1).Execute();

                var shortestNodePath = shortestPathsData.GetShortestPathToNode(node2);
                shortestNodePath.Should().BeNull();
            }
        }
Beispiel #42
0
        public void Get_edges_between_two_nonexisting_nodes_should_return_empty_collection()
        {
            var graph = new GraphStorage("TestGraph", Env);

            using (var tx = graph.NewTransaction(TransactionFlags.ReadWrite))
            {
                var node1 = new Node(-1,JsonFromValue("node1"));
                var node2 = new Node(-2,JsonFromValue("node2"));

                var edgesList = graph.Queries.GetEdgesBetween(tx, node1, node2);
                edgesList.Should().BeEmpty();
            }                        
        }
 protected abstract IMultiDestinationShortestPath GetAlgorithm(Transaction tx, GraphStorage graph, Node rootNode);
        public async Task BFS_FindMany_with_connected_root_returns_correct_results()
        {
            var graph = new GraphStorage("TestGraph", Env);
            using (var tx = graph.NewTransaction(TransactionFlags.ReadWrite))
            {
                var node1 = graph.Commands.CreateNode(tx, JsonFromValue("test1"));
                var node2 = graph.Commands.CreateNode(tx, JsonFromValue("test2"));
                var node3 = graph.Commands.CreateNode(tx, JsonFromValue("test3"));
                var node4 = graph.Commands.CreateNode(tx, JsonFromValue("test4"));

                graph.Commands.CreateEdgeBetween(tx, node3, node1);
                graph.Commands.CreateEdgeBetween(tx, node3, node2);

                graph.Commands.CreateEdgeBetween(tx, node3, node4);
                graph.Commands.CreateEdgeBetween(tx, node2, node2);
                graph.Commands.CreateEdgeBetween(tx, node2, node4);
                graph.Commands.CreateEdgeBetween(tx, node1, node3);

                tx.Commit();
            }

            using (var tx = graph.NewTransaction(TransactionFlags.Read))
            {
                var bfs = new BreadthFirstSearch(graph, CancelTokenSource.Token);
                var nodes = await bfs.FindMany(tx, data => ValueFromJson<string>(data).Contains("2") ||
                                                           ValueFromJson<string>(data).Contains("4"));

                nodes.Select(x => ValueFromJson<string>(x.Data)).Should().Contain("test2", "test4");
            }
        }
        public void Cheap_long_path_over_short_expensive_path_should_be_chosen()
        {
            var graph = new GraphStorage("TestGraph", Env);

            Node node1, node2, node3, node4;
            using (var tx = graph.NewTransaction(TransactionFlags.ReadWrite))
            {
                node1 = graph.Commands.CreateNode(tx, JsonFromValue(1));
                node2 = graph.Commands.CreateNode(tx, JsonFromValue(2));
                node3 = graph.Commands.CreateNode(tx, JsonFromValue(3));
                node4 = graph.Commands.CreateNode(tx, JsonFromValue(4));

                node1.ConnectWith(tx, node2, graph, 1);
                node2.ConnectWith(tx, node3, graph, 1);
                node3.ConnectWith(tx, node4, graph, 1);

                node1.ConnectWith(tx, node4, graph, 10);

                tx.Commit();
            }

            using (var tx = graph.NewTransaction(TransactionFlags.Read))
            {
                var shortestPathsData = GetAlgorithm(tx, graph, node1).Execute();

                var shortestNodePath = shortestPathsData.GetShortestPathToNode(node4);
                shortestNodePath.Should().ContainInOrder(node1.Key, node2.Key, node3.Key, node4.Key);
            }
        }
Beispiel #46
0
        public async Task Can_Avoid_Duplicate_Nodes_InParallel_Adds()
        {
            var graph = new GraphStorage("TestGraph",Env);

            Parallel.For(0, 100, i =>
            {
                using (var tx = graph.NewTransaction(TransactionFlags.ReadWrite))
                {
	                graph.Commands.CreateNode(tx, JsonFromValue("newNode" + i));
	                tx.Commit();
                }
            });
           
            var fetchedKeys = new List<long>();

            using (var tx = graph.NewTransaction(TransactionFlags.Read))
            {
                var nodesList = await graph.AdminQueries.GetAllNodes(tx, CancelTokenSource.Token);
                nodesList.Select(node => node.Key).Should().OnlyHaveUniqueItems();
            }
        }
Beispiel #47
0
        public void Get_edges_between_existing_and_nonexisting_node_should_return_empty_collection()
        {
            var graph = new GraphStorage("TestGraph", Env);
            long node1Id = 0;

            using (var tx = graph.NewTransaction(TransactionFlags.ReadWrite))
            {
                var node1 = graph.Commands.CreateNode(tx, JsonFromValue("node1"));

                Assert.IsNotNull(node1);
                node1Id = node1.Key;
                
                tx.Commit();
            }

            using (var tx = graph.NewTransaction(TransactionFlags.ReadWrite))
            {
                Node node1 = graph.Queries.LoadNode(tx, node1Id);
                Node node2 = new Node(-2, JsonFromValue("node2"));

                var edgesList = graph.Queries.GetEdgesBetween(tx, node1, node2);
                edgesList.Should().BeEmpty();
            }
        }
 protected override Algorithms.ShortestPath.ISingleDestinationShortestPath GetAlgorithm(Transaction tx, GraphStorage graph, Node rootNode, Node targetNode)
 {
     return new DijkstraShortestPath(tx, graph, rootNode, targetNode, cancelTokenSource.Token);
 }
Beispiel #49
0
        public void Load_nonexisting_node_should_return_null() {
            var graph = new GraphStorage("TestGraph", Env);


            using (var tx = graph.NewTransaction(TransactionFlags.ReadWrite))
            {
                var illegalNode = graph.Commands.CreateNode(tx,JsonFromValue("onlyNode"));
                illegalNode.Should().NotBeNull();
            }

            using (var tx = graph.NewTransaction(TransactionFlags.Read)) {
                var noneExistingNode = graph.Queries.LoadNode(tx, 1);
                noneExistingNode.Should().BeNull();
            }

        }
Beispiel #50
0
 Project()
 {
     data          = null;
     graphSettings = null;
     name          = DateTime.Now.ToString();
 }