void IntersectWithTree(LinkedPoint horizontalPoint) { double left, right; bool xAligned; Debug.Assert(ApproximateComparer.Close(horizontalPoint.Y,horizontalPoint.Next.Y)); var y = horizontalPoint.Y; if(horizontalPoint.Point.X<horizontalPoint.Next.Point.X) { left = horizontalPoint.Point.X; right = horizontalPoint.Next.Point.X; xAligned=true; }else { right= horizontalPoint.Point.X; left = horizontalPoint.Next.Point.X; xAligned=false; } if(xAligned) for( var node = tree.FindFirst(p => left<= p.Point.X); node!=null && node.Item.Point.X <= right ; node=tree.Next(node)) { var p = new Point(node.Item.Point.X, y ); horizontalPoint = TrySplitHorizontalPoint(horizontalPoint, p, true); TrySplitVerticalPoint(node.Item,p); }else //xAligned==false for (var node = tree.FindLast(p => p.Point.X <= right); node != null && node.Item.Point.X >= left; node = tree.Previous(node)) { var p = new Point(node.Item.Point.X, y); horizontalPoint = TrySplitHorizontalPoint(horizontalPoint, p, false); TrySplitVerticalPoint(node.Item, p); } }
public LinkedPoint() { ThisPoint = new Point(); Input = new List <LinkedPoint>(); OutputSameLevel = new List <LinkedPoint>(); Output = null; }
public LinkedPoint GetLongestRiverInStorage() { if (!isLinked) { throw new ArgumentException("Points weren't linked"); } LinkedPoint res = points[0]; LinkedPoint curr, currstart; int maxLengthCounter = 0; for (int i = 0; i < this.pointsCount; ++i) { currstart = curr = points[i]; int currLengthCounter = 0; while (curr != null) { curr = curr.Output; ++currLengthCounter; } if (maxLengthCounter < currLengthCounter) { maxLengthCounter = currLengthCounter; res = currstart; } } return(res); }
public LinkedPoint(double x, double y, double height) { ThisPoint = new Point(x, y, height); Input = new List <LinkedPoint>(); OutputSameLevel = new List <LinkedPoint>(); Output = null; }
void ProcessEvent(LinkedPoint linkedPoint, double z){ if(ApproximateComparer.Close(linkedPoint.Next.Point.X, linkedPoint.Point.X)) if(z==Low(linkedPoint)) ProcessLowLinkedPointEvent(linkedPoint); else ProcessHighLinkedPointEvent(linkedPoint); else IntersectWithTree(linkedPoint); }
// bool Correct() { // foreach (var kv in verticesToPathOffsets) { // Point p = kv.Key; // Dictionary<Path, LinkedPoint> pathOffs = kv.Value; // foreach (var pathOff in pathOffs) { // var path = pathOff.Key; // var linkedPoint = pathOff.Value; // if (linkedPoint.Point != p) // return false; // if (FindLinkedPointInPath(path, p) == null) { // return false; // } // } // } // return true; // } void CollapseLoopingPath(Path loopingPath, LinkedPoint departureFromLooping, LinkedPoint arrivalToLooping, Path stemPath, LinkedPoint arrivalToStem){ var departurePointOnStem = FindLinkedPointInPath(stemPath, departureFromLooping.Point); IEnumerable<Point> pointsToInsert = GetPointsInBetween(departurePointOnStem, arrivalToStem); if(Before(departureFromLooping, arrivalToLooping)){ CleanDisappearedPiece(departureFromLooping, arrivalToLooping, loopingPath); ReplacePiece(departureFromLooping, arrivalToLooping, pointsToInsert,loopingPath); }else{ CleanDisappearedPiece(arrivalToLooping, departureFromLooping, loopingPath); ReplacePiece(arrivalToLooping, departureFromLooping, pointsToInsert.Reverse(),loopingPath); } }
private double DefineWaterIncomeForPoint(LinkedPoint p) { if (p.waterIncomeDefined) { return(p.ThisPoint.WaterIncome); } else { double sum = 0; for (int i = 0; i < p.Input.Count; ++i) { sum += DefineWaterIncomeForPoint(p.Input[i]); } sum *= WATER_INCOME_ADDITION_COEFFICIENT; p.ThisPoint.WaterIncome += sum; p.waterIncomeDefined = true; return(sum); } }
void CleanDisappearedPiece(LinkedPoint a, LinkedPoint b, Path loopingPath){ foreach (var point in GetPointsInBetween(a, b)) { var pathOffset = verticesToPathOffsets[point]; Debug.Assert(pathOffset.ContainsKey(loopingPath)); pathOffset.Remove(loopingPath); } }
static LinkedPoint CreateLinkedVertexOfEdgePath(Path path) { var pathPoint = new LinkedPoint(path.PathPoints.First()); var first = pathPoint; #if SHARPKIT //https://code.google.com/p/sharpkit/issues/detail?id=368 path.PathPoints.Skip(1).Aggregate(pathPoint, (lp, p) => { lp.Next = new LinkedPoint(p); return lp.Next; }); #else path.PathPoints.Skip(1).Aggregate(pathPoint, (lp, p) => lp.Next = new LinkedPoint(p)); #endif return first; }
static double Low(LinkedPoint vertPoint) { return Math.Min(vertPoint.Point.Y, vertPoint.Next.Point.Y); }
void ReplacePiece(LinkedPoint a, LinkedPoint b, IEnumerable<Point> points, Path loopingPath){ var prevPoint = a; foreach (var point in points){ var lp = new LinkedPoint(point); prevPoint.Next = lp; prevPoint = lp; var pathOffset = verticesToPathOffsets[point]; Debug.Assert(!pathOffset.ContainsKey(loopingPath)); pathOffset[loopingPath] = prevPoint; } prevPoint.Next = b; }
static void InsertPoints(LinkedPoint pathLinkedVertex, Point[] arrayOfPoints, int i, int j) { if (i < j) pathLinkedVertex.InsertVerts(i, j, arrayOfPoints); else pathLinkedVertex.InsertVertsInReverse(j, i, arrayOfPoints); }
static IEnumerable<Point> GetPointsInBetween(LinkedPoint a, LinkedPoint b){ for(var i=a.Next;i!=b;i=i.Next) yield return i.Point; }
static double High(LinkedPoint vertPoint) { return Math.Max(vertPoint.Point.Y, vertPoint.Next.Point.Y); }
void ProcessLowLinkedPointEvent(LinkedPoint linkedPoint) { tree.Insert(linkedPoint); }
static void TrySplitVerticalPoint(LinkedPoint linkedPoint, Point point) { Debug.Assert(ApproximateComparer.Close(linkedPoint.X, linkedPoint.Next.X)); if (Low(linkedPoint) + ApproximateComparer.DistanceEpsilon < point.Y && point.Y + ApproximateComparer.DistanceEpsilon < High(linkedPoint)) linkedPoint.SetNewNext(point); }
static LinkedPoint TrySplitHorizontalPoint(LinkedPoint horizontalPoint, Point point, bool xAligned) { Debug.Assert(ApproximateComparer.Close(horizontalPoint.Y, horizontalPoint.Next.Y)); if (xAligned && horizontalPoint.X + ApproximateComparer.DistanceEpsilon < point.X && point.X + ApproximateComparer.DistanceEpsilon < horizontalPoint.Next.X || !xAligned && horizontalPoint.Next.X + ApproximateComparer.DistanceEpsilon < point.X && point.X + ApproximateComparer.DistanceEpsilon < horizontalPoint.X) { horizontalPoint.SetNewNext(point); return horizontalPoint.Next; } return horizontalPoint; }
/// <summary> /// checks that a is before b in the path /// </summary> /// <param name="a"></param> /// <param name="b"></param> /// <returns>true is a is before b in the path</returns> static bool Before(LinkedPoint a, LinkedPoint b){ for(a=a.Next;a!=null;a=a.Next) if(a==b) return true; return false; }
void ProcessHighLinkedPointEvent(LinkedPoint linkedPoint) { tree.Remove(linkedPoint); }