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);
}
