/// <summary>
/// Return a list of the <c>MonotoneChain</c>s
/// for the given list of coordinates.
/// </summary>
/// <param name="pts"></param>
/// <param name="context"></param>
public static IList GetChains(ICoordinate[] pts, object context)
{
IList mcList = new ArrayList();
int[] startIndex = GetChainStartIndices(pts);
for (int i = 0; i < startIndex.Length - 1; i++)
{
MonotoneChain mc = new MonotoneChain(pts, startIndex[i], startIndex[i + 1], context);
mcList.Add(mc);
}
return mcList;
}
/// <summary>
///
/// </summary>
/// <param name="start0"></param>
/// <param name="end0"></param>
/// <param name="mc"></param>
/// <param name="start1"></param>
/// <param name="end1"></param>
/// <param name="mco"></param>
private void ComputeOverlaps(int start0, int end0, MonotoneChain mc, int start1, int end1, MonotoneChainOverlapAction mco)
{
ICoordinate p00 = pts[start0];
ICoordinate p01 = pts[end0];
ICoordinate p10 = mc.pts[start1];
ICoordinate p11 = mc.pts[end1];
// terminating condition for the recursion
if (end0 - start0 == 1 && end1 - start1 == 1)
{
mco.Overlap(this, start0, mc, start1);
return;
}
// nothing to do if the envelopes of these chains don't overlap
mco.TempEnv1.Init(p00, p01);
mco.TempEnv2.Init(p10, p11);
if (! mco.TempEnv1.Intersects(mco.TempEnv2))
return;
// the chains overlap, so split each in half and iterate (binary search)
int mid0 = (start0 + end0) / 2;
int mid1 = (start1 + end1) / 2;
// Assert: mid != start or end (since we checked above for end - start <= 1)
// check terminating conditions before recursing
if (start0 < mid0)
{
if (start1 < mid1)
ComputeOverlaps(start0, mid0, mc, start1, mid1, mco);
if (mid1 < end1)
ComputeOverlaps(start0, mid0, mc, mid1, end1, mco);
}
if (mid0 < end0)
{
if (start1 < mid1)
ComputeOverlaps(mid0, end0, mc, start1, mid1, mco);
if (mid1 < end1)
ComputeOverlaps(mid0, end0, mc, mid1, end1, mco);
}
}
/// <summary>
///
/// </summary>
/// <param name="mc"></param>
/// <param name="mco"></param>
public void ComputeOverlaps(MonotoneChain mc, MonotoneChainOverlapAction mco)
{
ComputeOverlaps(start, end, mc, mc.start, mc.end, mco);
}
/// <summary>
/// This function can be overridden if the original chains are needed.
/// </summary>
/// <param name="mc1"></param>
/// <param name="start1">The index of the start of the overlapping segment from mc1.</param>
/// <param name="mc2"></param>
/// <param name="start2">The index of the start of the overlapping segment from mc2.</param>
public virtual void Overlap(MonotoneChain mc1, int start1, MonotoneChain mc2, int start2)
{
mc1.GetLineSegment(start1, ref overlapSeg1);
mc2.GetLineSegment(start2, ref overlapSeg2);
Overlap(overlapSeg1, overlapSeg2);
}
/// <summary>
/// This function can be overridden if the original chain is needed.
/// </summary>
/// <param name="mc"></param>
/// <param name="start"></param>
public virtual void Select(MonotoneChain mc, int start)
{
mc.GetLineSegment(start, ref SelectedSegment);
Select(SelectedSegment);
}
/// <summary>
///
/// </summary>
/// <param name="rayEnv"></param>
/// <param name="mcSelecter"></param>
/// <param name="mc"></param>
private void TestMonotoneChain(IEnvelope rayEnv, MCSelecter mcSelecter, MonotoneChain mc)
{
mc.Select(rayEnv, mcSelecter);
}
/// <summary>
///
/// </summary>
/// <param name="mc1"></param>
/// <param name="start1"></param>
/// <param name="mc2"></param>
/// <param name="start2"></param>
public override void Overlap(MonotoneChain mc1, int start1, MonotoneChain mc2, int start2)
{
SegmentString ss1 = (SegmentString) mc1.Context;
SegmentString ss2 = (SegmentString) mc2.Context;
si.ProcessIntersections(ss1, start1, ss2, start2);
}
/// <summary>
/// This function can be overridden if the original chain is needed.
/// </summary>
/// <param name="mc"></param>
/// <param name="start"></param>
public virtual void Select(MonotoneChain mc, int start)
{
mc.GetLineSegment(start, ref SelectedSegment);
Select(SelectedSegment);
}
/// <summary>
///
/// </summary>
/// <param name="mc"></param>
/// <param name="startIndex"></param>
public override void Select(MonotoneChain mc, int startIndex)
{
SegmentString ss = (SegmentString) mc.Context;
// don't snap a vertex to itself
if (parentEdge != null)
if (ss == parentEdge && startIndex == vertexIndex)
return;
isNodeAdded = SimpleSnapRounder.AddSnappedNode(hotPixel, ss, startIndex);
}
/// <summary>
///
/// </summary>
/// <param name="mc"></param>
/// <param name="mco"></param>
public void ComputeOverlaps(MonotoneChain mc, MonotoneChainOverlapAction mco)
{
ComputeOverlaps(start, end, mc, mc.start, mc.end, mco);
}
/// <summary>
/// This function can be overridden if the original chains are needed.
/// </summary>
/// <param name="mc1"></param>
/// <param name="start1">The index of the start of the overlapping segment from mc1.</param>
/// <param name="mc2"></param>
/// <param name="start2">The index of the start of the overlapping segment from mc2.</param>
public virtual void Overlap(MonotoneChain mc1, int start1, MonotoneChain mc2, int start2)
{
mc1.GetLineSegment(start1, ref overlapSeg1);
mc2.GetLineSegment(start2, ref overlapSeg2);
Overlap(overlapSeg1, overlapSeg2);
}
