Exemple #1
0
        private List <Point> GetAllPointsInWindingOrder()
        {
            //return Edges.SelectMany(e => e.Points).Distinct().ToList();
            List <Point> points = new List <Point>();
            // The edges were added in order, but we don't know if the points within the edges are in order.
            // Therefore we look at the previous edge to figoure out which point has allready been visited

            Edge previous = Edges.First();

            foreach (Edge current in Edges.Skip(1).Take(Edges.Count - 2))
            {
                if (points.Count == 0)
                {
                    Point firstPoint = previous.PointOnlyInThis(current);
                    points.Add(firstPoint);
                    Point secondPoint = previous.PointInBoth(current);
                    points.Add(secondPoint);
                }

                Point nextPoint = current.PointOnlyInThis(previous);
                points.Add(nextPoint);

                previous = current;
            }

            return(points);
        }
Exemple #2
0
 /// <summary>
 /// Removes all edges between vertices.
 /// Vertices still remains in graph but any of them are connected.
 /// </summary>
 public void ClearEdges()
 {
     while (Edges.Any())
     {
         RemoveEdge(Edges.First());
     }
 }
Exemple #3
0
 public Edge GetRightEdgeBy(Edge edge)
 {
     if (edge == null)
     {
         return(Edges.First());
     }
     if (Edges.FirstOrDefault(item => item == edge) == null)
     {
         throw new System.Exception("Ребро должно принадлежать этому узлу!");
     }
     if (edge == South)
     {
         return(East ?? Edges.FirstOrDefault(item => item != edge));
     }
     if (edge == East)
     {
         return(South ?? Edges.FirstOrDefault(item => item != edge));
     }
     if (edge == Nord)
     {
         return(West ?? Edges.FirstOrDefault(item => item != edge));
     }
     if (edge == West)
     {
         return(Nord ?? Edges.FirstOrDefault(item => item != edge));
     }
     throw new System.Exception("Ну такого просто не может быть!");
 }
Exemple #4
0
        public bool HasNegativeCycles()
        {
            var originalNode = Edges.First().Key;
            var costs        = NodeValues
                               .Where(e => !e.Equals(originalNode))
                               .ToDictionary(e => e, e => new InfinityInt(true));

            Dictionary <V, V> predecessors = NodeValues
                                             .Where(e => !e.Equals(originalNode))
                                             .ToDictionary(e => e, e => default(V));


            costs.Add(originalNode, new InfinityInt(0));

            for (int i = 1; i <= NodeValues.Count + 1; i++)
            {
                foreach (KeyValuePair <V, List <Edge> > edges in Edges)
                {
                    foreach (Edge e in edges.Value)
                    {
                        if (!costs[e.From.Value].IsInfinity && (costs[e.To.Value].IsInfinity || costs[e.From.Value].Value + e.Distance < costs[e.To.Value].Value))
                        {
                            if (i == NodeValues.Count)
                            {
                                return(true);
                            }
                            costs[e.To.Value]        = new InfinityInt(costs[e.From.Value].Value + e.Distance);
                            predecessors[e.To.Value] = e.From.Value;
                        }
                    }
                }
            }

            return(false);
        }
Exemple #5
0
 /// <summary>
 ///     Others the edge.
 /// </summary>
 /// <param name="thisVertex">The this vertex.</param>
 /// <param name="willAcceptNullAnswer">if set to <c>true</c> [will accept null answer].</param>
 /// <returns>Edge.</returns>
 public Edge OtherEdge(Vertex thisVertex, bool willAcceptNullAnswer = false)
 {
     if (willAcceptNullAnswer)
     {
         return(Edges.FirstOrDefault(e => e != null && e.To != thisVertex && e.From != thisVertex));
     }
     return(Edges.First(e => e != null && e.To != thisVertex && e.From != thisVertex));
 }
Exemple #6
0
 public int DistanceToAdjacent(GraphNode <TVal> other)
 {
     if (!IsAdjacent(other))
     {
         throw new ArgumentException("this node is not adjacent");
     }
     return(Edges.First(x => x.GetOther(this) == other).Weight);
 }
Exemple #7
0
        public string GetWeight(string vertexToName)
        {
            if (Name == vertexToName && Edges.All(e => e.VertexTo.Name != vertexToName))
            {
                return(string.Empty);
            }

            return(Edges.First(e => e.VertexTo.Name == vertexToName).GetWeightString());
        }
Exemple #8
0
 /// <summary>
 /// Enumerates all the interior angles of the polygon.
 /// </summary>
 public IEnumerable <Angle> Angles()
 {
     for (int i = 1; i < Edges.Count; i++)
     {
         var previous = Edges[i - 1];
         var next     = Edges[i];
         yield return(next.AngleBetween(previous).Supplement());
     }
     yield return(Edges.First().AngleBetween(Edges.Last()).Supplement());
 }
Exemple #9
0
        private Line _getNormalLine()
        {
            IVector vector1 = (Edges.OrderBy(s => s.EndPoint.X).ThenBy(s => s.EndPoint.Y).ThenByUnit(s => s.EndPoint.Z)
                               .First());

            IVector vector2 = Edges.First(s => s.BasePoint == vector1.EndPoint);

            var normal = vector1.Direction.CrossProduct(vector2.Direction);

            return(new Line(vector1.BasePoint, normal));
        }
Exemple #10
0
        private void changeColor(List <Pair <int, int> > target, Color color)
        {
            changeAllColor(Colors.Black);

            foreach (var result in target)
            {
                var edge = Edges.First(i =>
                                       (i.Pos.First.Key == result.First && i.Pos.Second.Key == result.Second) ||
                                       (i.Pos.Second.Key == result.First && i.Pos.First.Key == result.Second));

                edge.Color = new SolidColorBrush(color);
            }
        }
Exemple #11
0
        public void SetupParallelEdges(int edge1Id, int edge2Id, bool parallel)
        {
            var edge1 = Edges.First(e => e.Id == edge1Id);
            var edge2 = Edges.First(e => e.Id == edge2Id);

            var vertex11 = Vertices.First(v => v.Id == edge1.Vertices[0].Id);
            var vertex12 = Vertices.First(v => v.Id == edge1.Vertices[1].Id);
            var vertex21 = Vertices.First(v => v.Id == edge2.Vertices[0].Id);
            var vertex22 = Vertices.First(v => v.Id == edge2.Vertices[1].Id);

            var intEdges = new List <int> {
                edge1Id, edge2Id
            };
            var intVertices = new List <int>();

            if (vertex11.Point.X < vertex12.Point.X)
            {
                intVertices.Add(vertex11.Id);
                intVertices.Add(vertex12.Id);
            }
            else
            {
                intVertices.Add(vertex12.Id);
                intVertices.Add(vertex11.Id);
            }

            if (vertex21.Point.X < vertex22.Point.X)
            {
                intVertices.Add(vertex21.Id);
                intVertices.Add(vertex22.Id);
            }
            else
            {
                intVertices.Add(vertex22.Id);
                intVertices.Add(vertex21.Id);
            }

            var parallelEdges = new ParallelEdges
            {
                Parallel = parallel,
                Edges    = intEdges,
                Vertices = intVertices
            };

            ParallelPairs.Add(parallelEdges);
        }
Exemple #12
0
        /// <summary>
        /// Removes an edge between two vertices, if such edge exists.
        /// </summary>
        public void RemoveEdge(IVertex <T> startVertex, IVertex <T> endVertex)
        {
            if (!ContainsVertex(startVertex) || !ContainsVertex(endVertex))
            {
                throw new InvalidOperationException("One or more vertex does not belong to graph.");
            }

            if (!AreAdjacent(startVertex, endVertex))
            {
                throw new InvalidOperationException("There is no such edge in the graph.");
            }

            var edge = Edges.First(x => x.StartVertex.Equals(startVertex) &&
                                   x.EndVertex.Equals(endVertex));

            Edges.Remove(edge);

            edge.CurrentGraph = null;
        }
Exemple #13
0
        private async Task show(List <Pair <int, int> > target, Color color)
        {
            await exactStop();

            Logs.Add(new LogViewModel("start shower"));

            _cts = new CancellationTokenSource();

            try
            {
                changeAllColor(Colors.Black);

                await Task.Delay(500, _cts.Token);

                while (true)
                {
                    foreach (var result in target)
                    {
                        var edge = Edges.First(i =>
                                               (i.Pos.First.Key == result.First && i.Pos.Second.Key == result.Second) ||
                                               (i.Pos.Second.Key == result.First && i.Pos.First.Key == result.Second));

                        edge.Color = new SolidColorBrush(color);

                        await Task.Delay(1000, _cts.Token);
                    }

                    changeAllColor(Colors.Black);

                    await Task.Delay(1000, _cts.Token);
                }
            }
            catch (OperationCanceledException)
            {
                changeAllColor(Colors.Black);
                _cts = null;
                Logs.Add(new LogViewModel("stop shower"));
            }
        }
Exemple #14
0
        public IEdge GetEdge(object from, object to)
        {
            if (!(from is double) || !(to is double))
            {
                throw new ArgumentException("Only double accepted");
            }
            if (!Nodes.ContainsKey(from) || !Nodes.ContainsKey(to))
            {
                throw new ArgumentException("Node not find");
            }
            IEdge ed;

            try
            {
                ed = Edges.First((IEdge e) => (double)e.From == (double)from && (double)e.To == (double)to || (double)e.From == (double)to && (double)e.To == (double)from);
            }
            catch (Exception ex)
            {
                return(null);
            }
            return(ed);
        }
Exemple #15
0
        public void Redraw(bool clear = false)
        {
            if (clear)
            {
                foreach (var vertex in Vertices)
                {
                    _window.DrawDot(vertex.Point, Color.White);
                }
            }
            else
            {
                foreach (var vertex in Vertices)
                {
                    _window.DrawDot(vertex.Point, Color.Crimson);
                }
            }

            var parallels      = new List <int>();
            var perpendiculars = new List <int>();

            foreach (var parallelPair in ParallelPairs)
            {
                if (parallelPair.Parallel)
                {
                    parallels.Add(parallelPair.Edges[0]);
                    parallels.Add(parallelPair.Edges[1]);
                }
                else
                {
                    perpendiculars.Add(parallelPair.Edges[0]);
                    perpendiculars.Add(parallelPair.Edges[1]);
                }
            }

            foreach (var dot in DotsToClear)
            {
                _window.DrawDot(dot, Color.White);
            }
            DotsToClear = new List <Point>();

            int i = 0;

            if (!clear)
            {
                foreach (var parallelPair in ParallelPairs)
                {
                    foreach (var edgeInt in parallelPair.Edges)
                    {
                        var edge     = Edges.First(e => e.Id == edgeInt);
                        var start    = edge.Points.First();
                        var end      = edge.Points.Last();
                        var midPoint = new Point((start.X + end.X) / 2, (start.Y + end.Y) / 2);
                        _window.DrawDot(midPoint, _dotColors[i]);
                        DotsToClear.Add(midPoint);
                    }

                    i = (i + 1) % _dotColors.Length;
                }
            }

            foreach (var edge in Edges)
            {
                if (clear)
                {
                    _window.DrawPoints(edge.Points, Color.White);
                }
                else
                {
                    _window.DrawPoints(edge.Points, _color);
                }
            }
        }
Exemple #16
0
 public Edge GetEdgeByPredicate(object value)
 {
     return(Edges.First(e => e.Predicate.Value == value));
 }
Exemple #17
0
 /// <summary>
 /// Get edge which is connection between two nodes.
 /// </summary>
 /// <param name="node1">One of all available nodes from List of Nodes.
 /// <seealso cref="AISDEProject.Node"/>
 /// </param>
 /// <param name="node2">Second remaining node from List of Nodes.
 /// <seealso cref="AISDEProject.Node"/>
 /// </param>
 /// <returns>Method returns Edge with these two nodes.<seealso cref="AISDEProject.Edge"/></returns>
 Edge GetEdge(Node node1, Node node2) => Edges.
 First(e => (e.Begin.Equals(node1) && e.End.Equals(node2)) || (e.Begin.Equals(node2) && e.End.Equals(node1)));
Exemple #18
0
 public GroundEdge GetEdge(GroundPoint pointA, GroundPoint pointB)
 {
     return(Edges.First(edge => (edge.PointA == pointA && edge.PointB == pointB) ||
                        (edge.PointA == pointB && edge.PointB == pointA)));
 }
Exemple #19
0
 public Edge GetEdge(Vertex other)
 {
     return(Edges.First((e) => e.Contains(other)));
 }