public void Add(LineChain2 <T> chain, LeakyResizableArray <Node <T> > nodes, LeakyResizableArray <Edge <T> > edges)
{
if (chain == null)
{
return;
}
this.AddImpl(chain, chain.Points, false, nodes, edges);
}
public void Add(Ring2 <T> ring, LeakyResizableArray <Node <T> > nodes, LeakyResizableArray <Edge <T> > edges)
{
if (ring == null)
{
return;
}
this.AddImpl(ring, ring.Points, true, nodes, edges);
}
internal NodeFront(LeakyResizableArray <Node <T> > masterNodes)
{
if (masterNodes == null)
{
throw new ArgumentNullException();
}
this.masterNodes = masterNodes;
this.Reset();
}
internal void Add(Point2 <T> point, LeakyResizableArray <Node <T> > nodes)
{
if (point == null)
{
return;
}
Node <T> node = new Node <T>(point, point);
this.Nodes.Add(node);
nodes.Add(node);
//this.Points.Add(point);
}
public void Add(IEnumerable <Point2 <T> > chain, bool isRing, LeakyResizableArray <Node <T> > nodes, LeakyResizableArray <Edge <T> > edges)
{
if (chain == null)
{
return;
}
List <Point2 <T> > chainPoints = RemoveDups(chain, isRing);
if (chainPoints.Count < 3)
{
return;
}
this.AddImpl(chainPoints, chainPoints, isRing, nodes, edges);
}
public void Add(Point2 <T>[] chain, bool isRing, LeakyResizableArray <Node <T> > nodes)
{
if (chain == null || chain.Length < 3)
{
return;
}
List <Point2 <T> > chainPoints = RemoveDups(chain, isRing);
if (chainPoints.Count < 3)
{
return;
}
this.AddImpl(chainPoints, chainPoints, isRing, nodes);
}
public Point2 <T>[] ToArray()
{
LeakyResizableArray <Point2 <T> > pts = new LeakyResizableArray <Point2 <T> >();
foreach (Polyline2 <T> ch in this.Lines)
{
foreach (Point2 <T> pt in ch.Points)
{
pts.Add(pt);
}
}
pts.TrimExcess();
return(pts.Data);
}
public PolylineBag2 <T> ConstructPolylineBag(IEnumerable <Polyline2 <T> > chains)
{
if (chains != null)
{
LeakyResizableArray <Polyline2 <T> > chainSet = new LeakyResizableArray <Polyline2 <T> >();
foreach (Polyline2 <T> ch in chains)
{
if (ch == null)
{
return(null);
}
chainSet.Add(ch);
}
chainSet.TrimExcess();
return(new PolylineBag2 <T>(chainSet.Data));
}
return(null);
}
internal void Add(Point2 <T> start, Point2 <T> end, LeakyResizableArray <Node <T> > nodes)
{
if (start == null || end == null || start.Equals(end))
{
return;
}
LineSegment2 <T> seg = start.Factory.ConstructSegment(start, end);
Node <T> n = new Node <T>(start, seg);
Node <T> p = new Node <T>(end, seg);
this.Nodes.Add(n);
this.Nodes.Add(p);
nodes.Add(n);
nodes.Add(p);
Edge <T> e = new Edge <T>(n, p);
this.Edges.Add(e);
}
internal void Add(LineSegment2 <T> segment, LeakyResizableArray <Node <T> > nodes)
{
if (segment == null)
{
return;
}
//this.Points.Add(segment.Start);
//this.Points.Add(segment.End);
Node <T> n = new Node <T>(segment.Start, segment);
Node <T> p = new Node <T>(segment.End, segment);
this.Nodes.Add(n);
this.Nodes.Add(p);
nodes.Add(n);
nodes.Add(p);
Edge <T> e = new Edge <T>(n, p);
this.Edges.Add(e);
}
public RingBag2 <T> ConstructRingBag(IEnumerable <Ring2 <T> > chains)
{
if (chains != null)
{
LeakyResizableArray <Ring2 <T> > chainSet = new LeakyResizableArray <Ring2 <T> >();
foreach (Ring2 <T> ch in chains)
{
if (ch == null)
{
return(null);
}
chainSet.Add(ch);
}
chainSet.TrimExcess();
Ring2 <T>[] Chains = chainSet.Data;
return(new RingBag2 <T>(Chains));
}
return(null);
}
public override RingSet2 <double> ConstructRingSet(IEnumerable <Ring2 <double> > chains)
{
if (chains == null)
{
return(null);
}
LeakyResizableArray <Ring2 <double> > chainSet = new LeakyResizableArray <Ring2 <double> >();
foreach (Ring2 <double> ch in chains)
{
if (ch == null)
{
return(null);
}
chainSet.Add(ch);
}
chainSet.TrimExcess();
Ring2 <double>[] Chains = chainSet.Data;
PlanarChainGraph <double> graph = new PlanarChainGraph <double>();
foreach (Ring2 <double> ch in Chains)
{
if (ch == null)
{
return(null); //can't have null chains
}
graph.Add(ch);
}
if (PlanarGraphUtils.AnyIntersections(graph)) //there must be overlap
{
return(null);
}
return(new RingSet2 <double>(Chains));
}
private void AddImpl(object parentShape, IEnumerable <Point2 <T> > chain, bool isRing, LeakyResizableArray <Node <T> > nodes, LeakyResizableArray <Edge <T> > edges)
{
int firstIndex = (int)this.Nodes.Count;
int firstEdge = (int)this.Edges.Count;
Node <T> n = null;
Node <T> p = null;
Edge <T> e = null;
Edge <T> prev = null;
foreach (Point2 <T> pt in chain)
{
p = n;
n = new Node <T>(pt, parentShape);
if (p != null)
{
prev = e;
e = new Edge <T>(p, n);
if (prev != null)
{
e.Previous = prev;
prev.Next = e;
}
this.Edges.Add(e);
edges.Add(e);
}
this.Nodes.Add(n);
nodes.Add(n);
}
if (isRing) //wraparound
{
p = n; //last node added above
n = this.Nodes.Data[firstIndex];
prev = e; //last edge added above
e = new Edge <T>(p, n);
e.Previous = prev;
prev.Next = e;
//connect the wrap
prev = e;
e = this.Edges.Data[firstEdge];
e.Previous = prev;
prev.Next = e;
this.Edges.Add(e);
edges.Add(e);
}
}
