Esempio n. 1
0
        public void Parallelize(Vertex changedVertex = null)
        {
            foreach (var parallelEdges in ParallelPairs.OrderBy(p => p.Parallel))
            {
                var parallel = parallelEdges.Parallel;
                var parallelEdgesVertices = parallelEdges.Vertices;

                if (parallel && changedVertex != null && (changedVertex.Id == parallelEdgesVertices[2] ||
                                                          changedVertex.Id == parallelEdgesVertices[3]))
                {
                    var first2 = parallelEdgesVertices.Take(2);
                    var last2  = parallelEdgesVertices.Skip(2).ToList();
                    last2.AddRange(first2);
                    parallelEdgesVertices = last2;
                }

                var point11 = Vertices.First(v => v.Id == parallelEdgesVertices[0]).Point;
                var point12 = Vertices.First(v => v.Id == parallelEdgesVertices[1]).Point;
                var point21 = Vertices.First(v => v.Id == parallelEdgesVertices[2]).Point;
                var point22 = Vertices.First(v => v.Id == parallelEdgesVertices[3]).Point;
                var vert22  = Vertices.First(v => v.Id == parallelEdgesVertices[3]);

                var length1 = point11.Length(point12);
                var length2 = point21.Length(point22) + 0.6;

                var diffP1 = point12.Minus(point11);
                if (!parallel)
                {
                    diffP1 = new Point(diffP1.Y, -diffP1.X);
                }

                var newP22 = point21.Add(diffP1.Multiply(length2 / length1));
                ShiftVertex(vert22, newP22);
            }
        }
Esempio n. 2
0
        public void DeleteVertex(Vertex vertex)
        {
            if (Vertices.Count <= 3)
            {
                return;
            }

            var prevVertex = vertex.Edges[0].Vertices[0];
            var nextVertex = vertex.Edges[1].Vertices[1];
            var prevEdge   = vertex.Edges[0];
            var nextEdge   = vertex.Edges[1];

            _window.DrawPoints(vertex.Edges[0].Points, DefaultColor);
            _window.DrawPoints(vertex.Edges[1].Points, DefaultColor);
            _window.DrawDot(vertex.Point, DefaultColor);

            var newEdgePoints = GetLine(nextVertex.Point.X, nextVertex.Point.Y, prevVertex.Point.X, prevVertex.Point.Y);
            var maxEdgeId     = Edges.Select(e => e.Id).Max();
            var newEdge       = new Edge(maxEdgeId + 1, newEdgePoints);

            prevVertex.Edges[1] = nextVertex.Edges[0] = newEdge;
            newEdge.Vertices[0] = prevVertex;
            newEdge.Vertices[1] = nextVertex;

            Edges.Add(newEdge);
            Vertices.Remove(vertex);
            Edges.Remove(prevEdge);
            Edges.Remove(nextEdge);

            ParallelPairs.RemoveAll(pair => pair.Vertices.Contains(vertex.Id));

            _window.RedrawAll();
        }
Esempio n. 3
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);
        }
Esempio n. 4
0
        public void AddVertexOnEdge(Point edgePoint, Edge edge)
        {
            _window.DrawPoints(edge.Points, DefaultColor);

            ParallelPairs.RemoveAll(pair => pair.Edges.Contains(edge.Id));

            var prevVertex = edge.Vertices[0];
            var nextVertex = edge.Vertices[1];

            var maxVertexId    = Vertices.Select(v => v.Id).Max();
            var maxEdgeId      = Edges.Select(e => e.Id).Max();
            var prevEdgePoints = GetLine(edgePoint.X, edgePoint.Y, prevVertex.Point.X, prevVertex.Point.Y);
            var nextEdgePoints = GetLine(edgePoint.X, edgePoint.Y, nextVertex.Point.X, nextVertex.Point.Y);

            var newVertex   = new Vertex(maxVertexId + 1, edgePoint);
            var newPrevEdge = new Edge(maxEdgeId + 1, prevEdgePoints);
            var newNextEdge = new Edge(maxEdgeId + 2, nextEdgePoints);

            newVertex.Edges[0] = newPrevEdge;
            newVertex.Edges[1] = newNextEdge;

            newPrevEdge.Vertices[0] = prevVertex;
            newPrevEdge.Vertices[1] = newVertex;
            newNextEdge.Vertices[0] = newVertex;
            newNextEdge.Vertices[1] = nextVertex;

            prevVertex.Edges[1] = newPrevEdge;
            nextVertex.Edges[0] = newNextEdge;

            Edges.Remove(edge);
            Edges.Add(newPrevEdge);
            Edges.Add(newNextEdge);
            Vertices.Add(newVertex);

            _window.RedrawAll();
        }
Esempio n. 5
0
 public void DeleteEdgeRelation(Edge edge)
 {
     ParallelPairs.RemoveAll(pair => pair.Edges.Contains(edge.Id));
     _window.RedrawAll();
 }