double GetAreaOldOverlapsBoxesSegments(List <TreeNode> vMovesCritical)
        {
            double a = 0;

            foreach (var u in vMovesCritical)
            {
                if (oldOverlapsBoxes.ContainsKey(u))
                {
                    var uOverlaps = oldOverlapsBoxes[u];
                    foreach (var w in uOverlaps)
                    {
                        var rect = Rectangle.Intersect(u.rect, w.rect);
                        if (!rect.IsEmpty)
                        {
                            a += rect.Area;
                        }
                    }
                }
                if (oldOverlapsSegments.ContainsKey(u))
                {
                    var uOverlaps = oldOverlapsSegments[u];
                    foreach (var seg in uOverlaps)
                    {
                        a += RectSegIntersection.GetOverlapAmount(u.rect, seg.p1, seg.p2);
                    }
                }
            }
            return(a);
        }
        List <Segment> GetAllSegmentsIntersecting(Rectangle rect)
        {
            var segmentsIntersecting = new List <Segment>();
            var boxIntersecting      = _segmentTree.GetAllIntersecting(rect);

            foreach (var seg in boxIntersecting)
            {
                if (RectSegIntersection.Intersect(rect, seg.p1, seg.p2))
                {
                    segmentsIntersecting.Add(seg);
                }
            }
            return(segmentsIntersecting);
        }
        void AddNodesForBoxSegmentOverlaps(out List <Point> sites, out List <SymmetricSegment> edges)
        {
            sites = new List <Point>();
            edges = new List <SymmetricSegment>();

            foreach (var rect in moveableRectangles)
            {
                List <Segment> segments = GetAllSegmentsIntersecting(rect);
                if (!segments.Any())
                {
                    continue;
                }

                var seg = segments.First();
                //foreach (var seg in segments)
                //{
                Point p;
                Point pClosestOnSeg = RectSegIntersection.ClosestPointOnSegment(seg.p1, seg.p2, rect.Center);

                // if too close
                if ((pClosestOnSeg - rect.Center).Length < 10 * PrecisionDelta)
                {
                    Point d     = (seg.p2 - seg.p2).Rotate90Ccw();
                    Point delta = 0.5 * GetShiftUntilNoLongerOverlapRectSeg(rect, seg, d);
                    p = Round(rect.Center + delta);
                }
                else
                {
                    p = Round(0.5 * (rect.Center + pClosestOnSeg));
                }

                TreeNode node = new TreeNode {
                    isFixed = false, sitePoint = p, type = SiteType.AdditionalPointBoxSegmentOverlap, segment = seg, rect = rect, label = "SegOvlp "
                };
                if (!pointToTreeNode.ContainsKey(p))
                {
                    sites.Add(p);
                    pointToTreeNode[p] = node;
                    edges.Add(new SymmetricSegment(p, Round(rect.Center)));
                }

                TreeNode box = pointToTreeNode[Round(rect.Center)];
                if (box.type == SiteType.RectMoveable)
                {
                    node.label += box.label;
                }
                //}
            }
        }
        bool IsCrossedBySegment(SymmetricSegment edge)
        {
            var  intersectingSegments = _segmentTree.GetAllIntersecting(new Rectangle(edge.A, edge.B));
            bool hasIntersection      = false;

            foreach (var seg in intersectingSegments)
            {
                if (RectSegIntersection.SegmentsIntersect(edge.A, edge.B, seg.p1, seg.p2))
                {
                    hasIntersection = true;
                    break;
                }
            }
            return(hasIntersection);
        }
 void SaveCurrentOverlapsSegments()
 {
     oldOverlapsSegments = new Dictionary <TreeNode, List <Segment> >();
     foreach (var v in _moveableRectanglesTree.GetAllLeaves())
     {
         var vOverlaps = _segmentTree.GetAllIntersecting(v.rect);
         if (!vOverlaps.Any())
         {
             continue;
         }
         var vOverlapsList = new List <Segment>();
         foreach (var s in vOverlaps)
         {
             if (RectSegIntersection.Intersect(v.rect, s.p1, s.p2))
             {
                 vOverlapsList.Add(s);
             }
         }
         if (vOverlapsList.Any())
         {
             oldOverlapsSegments.Add(v, vOverlapsList);
         }
     }
 }
 Point GetShiftUntilNoLongerOverlapRectSeg(Rectangle rect, Segment segment, Point moveDir)
 {
     return(RectSegIntersection.GetOrthShiftUntilNoLongerOverlapRectSeg(rect, segment.p1, segment.p2, moveDir));
 }