public StatusNode insert(Transition surrounding, EventNode ev)
{
var prev = surrounding.prev;
var here = surrounding.here;
var node = new StatusNode()
{
ev = ev
};
node.prev = prev;
node.next = here;
prev.next = node;
if (here != null)
{
here.prev = node;
}
return(node);
}
public Transition findTransition(EventNode ev)
{
var prev = root;
var here = root.next;
while (here != null)
{
if (findTransitionPredicate(ev, here))
{
break;
}
prev = here;
here = here.next;
}
return(new Transition()
{
before = prev == root ? null : prev.ev,
after = here != null ? here.ev : null,
here = here,
prev = prev
});
}
private bool findTransitionPredicate(EventNode ev, StatusNode here)
{
var comp = statusCompare(ev, here.ev);
return(comp > 0);
}
public void eventAdd(EventNode ev, Point other_pt)
{
event_root.insertBefore(ev, other_pt);
}
private EventNode checkIntersection(EventNode ev1, EventNode ev2)
{
// returns the segment equal to ev1, or false if nothing equal
var seg1 = ev1.seg;
var seg2 = ev2.seg;
var a1 = seg1.start;
var a2 = seg1.end;
var b1 = seg2.start;
var b2 = seg2.end;
if (buildLog != null)
{
buildLog.checkIntersection(seg1, seg2);
}
Intersection intersect;
if (!Epsilon.linesIntersect(a1, a2, b1, b2, out intersect))
{
// segments are parallel or coincident
// if points aren't collinear, then the segments are parallel, so no intersections
if (!Epsilon.pointsCollinear(a1, a2, b1))
{
return(null);
}
// otherwise, segments are on top of each other somehow (aka coincident)
if (Epsilon.pointsSame(a1, b2) || Epsilon.pointsSame(a2, b1))
{
return(null); // segments touch at endpoints... no intersection
}
var a1_equ_b1 = Epsilon.pointsSame(a1, b1);
var a2_equ_b2 = Epsilon.pointsSame(a2, b2);
if (a1_equ_b1 && a2_equ_b2)
{
return(ev2); // segments are exactly equal
}
var a1_between = !a1_equ_b1 && Epsilon.pointBetween(a1, b1, b2);
var a2_between = !a2_equ_b2 && Epsilon.pointBetween(a2, b1, b2);
// handy for debugging:
// buildLog.log({
// a1_equ_b1: a1_equ_b1,
// a2_equ_b2: a2_equ_b2,
// a1_between: a1_between,
// a2_between: a2_between
// });
if (a1_equ_b1)
{
if (a2_between)
{
// (a1)---(a2)
// (b1)----------(b2)
eventDivide(ev2, a2);
}
else
{
// (a1)----------(a2)
// (b1)---(b2)
eventDivide(ev1, b2);
}
return(ev2);
}
else if (a1_between)
{
if (!a2_equ_b2)
{
// make a2 equal to b2
if (a2_between)
{
// (a1)---(a2)
// (b1)-----------------(b2)
eventDivide(ev2, a2);
}
else
{
// (a1)----------(a2)
// (b1)----------(b2)
eventDivide(ev1, b2);
}
}
// (a1)---(a2)
// (b1)----------(b2)
eventDivide(ev2, a1);
}
}
else
{
// otherwise, lines intersect at i.pt, which may or may not be between the endpoints
// is A divided between its endpoints? (exclusive)
if (intersect.alongA == 0)
{
if (intersect.alongB == -1) // yes, at exactly b1
{
eventDivide(ev1, b1);
}
else if (intersect.alongB == 0) // yes, somewhere between B's endpoints
{
eventDivide(ev1, intersect.pt);
}
else if (intersect.alongB == 1) // yes, at exactly b2
{
eventDivide(ev1, b2);
}
}
// is B divided between its endpoints? (exclusive)
if (intersect.alongB == 0)
{
if (intersect.alongA == -1) // yes, at exactly a1
{
eventDivide(ev2, a1);
}
else if (intersect.alongA == 0) // yes, somewhere between A's endpoints (exclusive)
{
eventDivide(ev2, intersect.pt);
}
else if (intersect.alongA == 1) // yes, at exactly a2
{
eventDivide(ev2, a2);
}
}
}
return(null);
}
private Transition statusFindSurrounding(EventNode ev)
{
return(status_root.findTransition(ev));
}
public void eventAdd(EventNode ev, Vector2 other_pt)
{
event_root.insertBefore(ev, other_pt);
}
