/// <summary>
/// Insert an edge from one of the noded input graphs.
/// Checks edges that are inserted to see if an
/// identical edge already exists.
/// If so, the edge is not inserted, but its label is merged
/// with the existing edge.
/// </summary>
/// <param name="e"></param>
protected virtual void InsertUniqueEdge(Edge e)
{
int foundIndex = _edgeList.FindEdgeIndex(e);
// If an identical edge already exists, simply update its label
if (foundIndex >= 0)
{
Edge existingEdge = _edgeList[foundIndex];
Label existingLabel = existingEdge.Label;
Label labelToMerge = e.Label;
// check if new edge is in reverse direction to existing edge
// if so, must flip the label before merging it
if (!existingEdge.IsPointwiseEqual(e))
{
labelToMerge = new Label(e.Label);
labelToMerge.Flip();
}
Depth depth = existingEdge.Depth;
// if this is the first duplicate found for this edge, initialize the depths
if (depth.IsNull())
{
depth.Add(existingLabel);
}
depth.Add(labelToMerge);
existingLabel.Merge(labelToMerge);
}
else
{
// no matching existing edge was found
// add this new edge to the list of edges in this graph
_edgeList.Add(e);
}
}
public void TestDeleteVertex()
{
EdgeList expected = new EdgeList();
EdgeList real = Program.Code();
real.DeleteVertex();
expected.Add(new Tuple <int, int>(0, 1));
expected.Add(new Tuple <int, int>(1, 2));
}
public void TestRemove()
{
EdgeList expected = new EdgeList();
EdgeList real = Program.Code();
real.Remove(new Tuple <int, int>(3, 0));
expected.Add(new Tuple <int, int>(0, 1));
expected.Add(new Tuple <int, int>(1, 3));
expected.Add(new Tuple <int, int>(1, 2));
expected.Add(new Tuple <int, int>(3, 2));
expected.Add(new Tuple <int, int>(0, 3));
Assert.AreEqual(expected.Count, real.Count);
Assert.AreEqual(expected.Contains(new Tuple <int, int>(3, 0)), real.Contains(new Tuple <int, int>(3, 0)));
}
static void Main(string[] args)
{
var input = Console.ReadLine();
var inputArr = input.ToCharArray();
Arr = inputArr;
var length = inputArr.Length;
var sortEdge = new EdgeList();
for (int i = 0; i < length; i++)
{
var edge = new Edge();
edge.Length = i + 1;
edge.Start = length - 1 - i;
sortEdge.Add(edge);
}
var sb = new StringBuilder();
foreach (var edge in sortEdge.Storage)
{
sb.Append(string.Format("{0} ", length - edge.Length));
}
Console.WriteLine(sb.ToString());
}
public eOperationStatus AppendEdge(int Width, int Height, int DeltaX, int DeltaY)
{
if (MostRecentlySelectedVertex == null)
{
return(eOperationStatus.NoVertexSelected);
}
// Add a new point
int nextindex = FindNextIndex();
Vertex vP = new Vertex();
vP.Index = nextindex;
vP.X = MostRecentlySelectedVertex.X + DeltaX;
vP.Y = MostRecentlySelectedVertex.Y + DeltaY;
VertexList.Add(vP);
// Add an edge
Edge oEdge = new Edge();
oEdge.Height = Height;
oEdge.Width = Width;
oEdge.p1 = MostRecentlySelectedVertex.Index;
oEdge.p2 = vP.Index;
oEdge.ID = "";
oEdge.HoleGroupID = "";
EdgeList.Add(oEdge);
return(eOperationStatus.OK);
}
public IEnumerable <TEdge> OutEdges(TVertex v)
{
IEdgeList <TVertex, TEdge> edges;
if (!this.vertedEdges.TryGetValue(v, out edges))
{
edges = new EdgeList <TVertex, TEdge>();
foreach (ITransitionFactory <TVertex, TEdge> transitionFactory
in this.TransitionFactories)
{
if (!transitionFactory.IsValid(v))
{
continue;
}
foreach (var edge in transitionFactory.Apply(v))
{
if (this.SuccessorVertexPredicate(edge.Target) &&
this.SuccessorEdgePredicate(edge))
{
edges.Add(edge);
}
}
}
this.vertedEdges[v] = edges;
}
return(edges);
}
public int RemoveOutEdgeIf(TVertex v, EdgePredicate <TVertex, TEdge> predicate)
{
GraphContracts.AssumeInVertexSet(this, v, "v");
GraphContracts.AssumeNotNull(predicate, "predicate");
EdgeList edges = this.vertexEdges[v];
EdgeList edgeToRemove = new EdgeList(edges.Count);
foreach (TEdge edge in edges)
{
if (predicate(edge))
{
edgeToRemove.Add(edge);
}
}
foreach (TEdge edge in edgeToRemove)
{
edges.Remove(edge);
this.OnEdgeRemoved(new EdgeEventArgs <TVertex, TEdge>(edge));
}
this.edgeCount -= edgeToRemove.Count;
GraphContracts.Assert(this.edgeCount >= 0);
return(edgeToRemove.Count);
}
/// <summary>
/// Inserted edges are checked to see if an identical edge already exists.
/// If so, the edge is not inserted, but its label is merged
/// with the existing edge.
/// </summary>
/// <param name="e"></param>
protected void InsertEdge(Edge e)
{
//<FIX> MD 8 Oct 03 speed up identical edge lookup
// fast lookup
Edge existingEdge = edgeList.FindEqualEdge(e);
// If an identical edge already exists, simply update its label
if (existingEdge != null)
{
Label existingLabel = existingEdge.Label;
Label labelToMerge = e.Label;
// check if new edge is in reverse direction to existing edge
// if so, must flip the label before merging it
if (!existingEdge.IsPointwiseEqual(e))
{
labelToMerge = new Label(e.Label);
labelToMerge.Flip();
}
existingLabel.Merge(labelToMerge);
// compute new depth delta of sum of edges
int mergeDelta = DepthDelta(labelToMerge);
int existingDelta = existingEdge.DepthDelta;
int newDelta = existingDelta + mergeDelta;
existingEdge.DepthDelta = newDelta;
}
else
{ // no matching existing edge was found
// add this new edge to the list of edges in this graph
//e.setName(name + edges.size());
edgeList.Add(e);
e.DepthDelta = DepthDelta(e.Label);
}
}
// Add a new line into the simple layout struct, new vertices and a new edge
public void AddEdge(PointF WorldFrom, PointF WorldTo, int Width, int Height)
{
int nextindex = FindNextIndex();
Vertex vP1 = new Vertex();
vP1.Index = nextindex++;
vP1.X = WorldFrom.X;
vP1.Y = WorldFrom.Y;
VertexList.Add(vP1);
Vertex vP2 = new Vertex();
vP2.Index = nextindex++;
vP2.X = WorldTo.X;
vP2.Y = WorldTo.Y;
VertexList.Add(vP2);
// Now add a segment
Edge oEdge = new Edge();
oEdge.Height = 30;
oEdge.Width = 10;
oEdge.p1 = vP1.Index;
oEdge.p2 = vP2.Index;
oEdge.ID = "";
oEdge.HoleGroupID = "";
EdgeList.Add(oEdge);
}
/// <summary>
/// Delete all vertexes and edges that have no <see cref="Part"/> associated with them.
/// </summary>
public void DeleteArtificialVertexes()
{
VertexList dummies = new VertexList();
foreach (V n in this.Vertexes)
{
if (n.Node == null)
{
dummies.Add(n);
}
}
foreach (V n in dummies)
{
DeleteVertex(n);
}
EdgeList dummies2 = new EdgeList();
foreach (E l in this.Edges)
{
if (l.Link == null)
{
dummies2.Add(l);
}
}
foreach (E l in dummies2)
{
DeleteEdge(l);
}
}
/// <inheritdoc />
public IEnumerable <TEdge> OutEdges(TVertex vertex)
{
if (vertex == null)
{
throw new ArgumentNullException(nameof(vertex));
}
if (!_verticesEdgesCache.TryGetValue(vertex, out IEdgeList <TVertex, TEdge> edges))
{
edges = new EdgeList <TVertex, TEdge>();
foreach (ITransitionFactory <TVertex, TEdge> transitionFactory in TransitionFactories)
{
if (!transitionFactory.IsValid(vertex))
{
continue;
}
foreach (TEdge edge in transitionFactory.Apply(vertex))
{
if (SuccessorVertexPredicate(edge.Target) &&
SuccessorEdgePredicate(edge))
{
edges.Add(edge);
}
}
}
_verticesEdgesCache[vertex] = edges;
}
return(edges);
}
public eOperationStatus AddHoleInMostRecentlySelectedEdge(int Width)
{
if (EdgeList.Count == 0)
{
return(eOperationStatus.NoEdgesDefined);
}
if (MostRecentlySelectedEdge == null)
{
return(eOperationStatus.NoEdgeSelected);
}
double thisEdgeLength = EdgeLength(MostRecentlySelectedEdge);
if (Width >= thisEdgeLength)
{
return(eOperationStatus.EdgeNotWideEnoughForOperation);
}
// Determine the interpolations based on the width and length
float WidthPercent = (float)(Width / thisEdgeLength);
Vertex v1 = FindVertexFromIndex(MostRecentlySelectedEdge.p1);
Vertex v2 = FindVertexFromIndex(MostRecentlySelectedEdge.p2);
/*
* Create vectors of the end points
*/
SVector2 f = new SVector2(v1.X, v1.Y);
SVector2 t = new SVector2(v2.X, v2.Y);
// Find a new end point and add a vertex for it
float lowpercent = (float).5 - WidthPercent;
SVector2 LowPartVector = SVector2.Interpolate(f, t, lowpercent);
Vertex vNew1 = NewVertex(LowPartVector.X, LowPartVector.Y);
// Create a new edge and add it
Edge newEdge = new Edge();
newEdge.Width = MostRecentlySelectedEdge.Width;
newEdge.Height = MostRecentlySelectedEdge.Height;
newEdge.ID = "";
newEdge.HoleGroupID = "";
newEdge.p1 = MostRecentlySelectedEdge.p1;
newEdge.p2 = vNew1.Index;
EdgeList.Add(newEdge);
// Add a new vertex for the other position on the other side of the hole
float highpercent = (float).5 + WidthPercent;
SVector2 HighPartVector = SVector2.Interpolate(f, t, highpercent);
Vertex vNew2 = NewVertex(HighPartVector.X, HighPartVector.Y);
// Modify the currently selected edge so that it starts at the vnew2
MostRecentlySelectedEdge.p1 = vNew2.Index;
return(eOperationStatus.OK);
}
public bool TryGetPath(
TVertex source,
TVertex target,
out IEnumerable <TEdge> path)
{
Contract.Requires(source != null);
Contract.Requires(target != null);
if (source.Equals(target))
{
path = null;
return(false);
}
var edges = new EdgeList <TVertex, TEdge>();
var todo = new Stack <SEquatableEdge <TVertex> >();
todo.Push(new SEquatableEdge <TVertex>(source, target));
while (todo.Count > 0)
{
var current = todo.Pop();
Contract.Assert(!current.Source.Equals(current.Target));
VertexData data;
if (this.data.TryGetValue(current, out data))
{
TEdge edge;
if (data.TryGetEdge(out edge))
{
edges.Add(edge);
}
else
{
TVertex intermediate;
if (data.TryGetPredecessor(out intermediate))
{
todo.Push(new SEquatableEdge <TVertex>(intermediate, current.Target));
todo.Push(new SEquatableEdge <TVertex>(current.Source, intermediate));
}
else
{
Contract.Assert(false);
path = null;
return(false);
}
}
}
else
{
// no path found
path = null;
return(false);
}
}
Contract.Assert(todo.Count == 0);
Contract.Assert(edges.Count > 0);
path = edges.ToArray();
return(true);
}
public void addEdge(int firstVertexId, int secondVertexId, int capacity, bool ignore)
{
Vertex first = getVertex(firstVertexId, VertexList);
Vertex second = getVertex(secondVertexId, VertexList);
int weight = 1000000 / capacity;
Edge created = new Edge(firstVertexId, secondVertexId, weight, capacity, first, second, false, ignore);
EdgeList.Add(created);
}
public void TestGetIncidentEdges()
{
EdgeList expected = new EdgeList();
EdgeList real = Program.Code().GetIncidentEdges(3);
real.Remove(new Tuple <int, int>(3, 0));
expected.Add(new Tuple <int, int>(3, 2));
Assert.AreEqual(expected.Count, real.Count);
}
private bool TryGetPathInternal(
[NotNull] TVertex source,
[NotNull] TVertex target,
out IEnumerable <TEdge> path)
{
#if DEBUG && !NET20
var set = new HashSet <TVertex> {
source, target
};
#endif
var edges = new EdgeList <TVertex, TEdge>();
var todo = new Stack <SEquatableEdge <TVertex> >();
todo.Push(new SEquatableEdge <TVertex>(source, target));
while (todo.Count > 0)
{
SEquatableEdge <TVertex> current = todo.Pop();
Debug.Assert(!current.Source.Equals(current.Target));
if (_data.TryGetValue(current, out VertexData data))
{
if (data.TryGetEdge(out TEdge edge))
{
edges.Add(edge);
}
else
{
if (data.TryGetPredecessor(out TVertex intermediate))
{
#if DEBUG && !NET20
Debug.Assert(set.Add(intermediate));
#endif
todo.Push(new SEquatableEdge <TVertex>(intermediate, current.Target));
todo.Push(new SEquatableEdge <TVertex>(current.Source, intermediate));
}
else
{
throw new InvalidOperationException("Cannot find predecessor.");
}
}
}
else
{
// No path found
path = null;
return(false);
}
}
Debug.Assert(todo.Count == 0);
Debug.Assert(edges.Count > 0);
path = edges;
return(true);
}
public virtual bool RemoveVertex(TVertex v)
{
GraphContracts.AssumeNotNull(v, "v");
if (!this.ContainsVertex(v))
{
return(false);
}
// remove outedges
{
EdgeList edges = this.vertexEdges[v];
if (this.EdgeRemoved != null) // lazily notify
{
foreach (TEdge edge in edges)
{
this.OnEdgeRemoved(new EdgeEventArgs <TVertex, TEdge>(edge));
}
}
this.edgeCount -= edges.Count;
edges.Clear();
}
// iterage over edges and remove each edge touching the vertex
EdgeList edgeToRemove = new EdgeList();
foreach (KeyValuePair <TVertex, EdgeList> kv in this.vertexEdges)
{
if (kv.Key.Equals(v))
{
continue; // we've already
}
// collect edge to remove
foreach (TEdge edge in kv.Value)
{
if (edge.Target.Equals(v))
{
edgeToRemove.Add(edge);
}
}
// remove edges
foreach (TEdge edge in edgeToRemove)
{
kv.Value.Remove(edge);
this.OnEdgeRemoved(new EdgeEventArgs <TVertex, TEdge>(edge));
}
// update count
this.edgeCount -= edgeToRemove.Count;
edgeToRemove.Clear();
}
System.Diagnostics.Debug.Assert(this.edgeCount >= 0);
this.vertexEdges.Remove(v);
this.OnVertexRemoved(new VertexEventArgs <TVertex>(v));
return(true);
}
private void insertVertexToSameSenseEdge(Face Fa, int Bounds, int Edge, Vertex3d V)
{
EdgeLoop EL = Fa.Bounds[Bounds];
Edge E = EL[Edge];
Face Neigbhbor = null;
int outloop = -1;
double d = Face.GetDualEdge(Fa, Bounds, Edge + 0.5, ref outloop, ref Neigbhbor);
EdgeLoop DualEL = Neigbhbor.Bounds[outloop];
int DualEdge = (int)d;
Edge F = DualEL[DualEdge];
// Zuerst die neue Kante
Edge NewEdge = new Edge();
EdgeList.Add(NewEdge);
NewEdge.SameSense = true;
NewEdge.EdgeStart = E.EdgeStart;
NewEdge.EdgeEnd = V;
Line3D L = new Line3D(NewEdge.EdgeStart.Value, V.Value);
EdgeCurveList.Add(L);
L.Neighbors = new Face[2];
L.Neighbors[0] = E.EdgeCurve.Neighbors[0];
L.Neighbors[1] = E.EdgeCurve.Neighbors[1];
NewEdge.EdgeCurve = L;
VertexList.Add(V);
E.EdgeStart = V;
E.EdgeCurve.A = V.Value;
EL.Insert(Edge, NewEdge);
// Duale
NewEdge = new Edge();
NewEdge.SameSense = false;
EdgeList.Add(NewEdge);
if (DualEdge + 1 < DualEL.Count)
{
DualEL.Insert(DualEdge + 1, NewEdge);
}
else
{
DualEL.Insert(0, NewEdge);
}
NewEdge.EdgeStart = V;
NewEdge.EdgeEnd = F.EdgeEnd;
F.EdgeEnd = V;
NewEdge.EdgeCurve = L;
}
public virtual bool RemoveVertex(TVertex v)
{
if (!this.ContainsVertex(v))
{
return(false);
}
// remove outedges
{
var edges = this.vertexEdges[v];
if (this.EdgeRemoved != null) // lazily notify
{
foreach (var edge in edges)
{
this.OnEdgeRemoved(edge);
}
}
this.edgeCount -= edges.Count;
edges.Clear();
}
// iterage over edges and remove each edge touching the vertex
var edgeToRemove = new EdgeList <TVertex, TEdge>();
foreach (var kv in this.vertexEdges)
{
if (kv.Key.Equals(v))
{
continue; // we've already
}
// collect edge to remove
foreach (var edge in kv.Value)
{
if (edge.Target.Equals(v))
{
edgeToRemove.Add(edge);
}
}
// remove edges
foreach (var edge in edgeToRemove)
{
kv.Value.Remove(edge);
this.OnEdgeRemoved(edge);
}
// update count
this.edgeCount -= edgeToRemove.Count;
edgeToRemove.Clear();
}
Contract.Assert(this.edgeCount >= 0);
this.vertexEdges.Remove(v);
this.OnVertexRemoved(v);
return(true);
}
public eOperationStatus SplitMostRecentlySelectedEdge(float RelativeDistance)
{
if (EdgeList.Count == 0)
{
return(eOperationStatus.NoEdgesDefined);
}
if (MostRecentlySelectedEdge == null)
{
return(eOperationStatus.NoEdgeSelected);
}
Vertex v1 = FindVertexFromIndex(MostRecentlySelectedEdge.p1);
Vertex v2 = FindVertexFromIndex(MostRecentlySelectedEdge.p2);
SVector2 f = new SVector2(v1.X, v1.Y);
SVector2 t = new SVector2(v2.X, v2.Y);
SVector2 interpolatedVector = SVector2.Interpolate(f, t, RelativeDistance);
/*
* Get the point at the at this distance mark
*/
PointF InterpolatedPoint = new PointF(interpolatedVector.X, interpolatedVector.Y);
// Add the interpolated point as a new vertex
Vertex vInterpolated = new Vertex();
vInterpolated.Index = FindNextIndex();
vInterpolated.X = InterpolatedPoint.X;
vInterpolated.Y = InterpolatedPoint.Y;
VertexList.Add(vInterpolated);
// Create a new edge with two points, the interpolated point and the current p2
Edge newEdge = new Edge();
newEdge.Width = MostRecentlySelectedEdge.Width;
newEdge.Height = MostRecentlySelectedEdge.Height;
newEdge.ID = "";
newEdge.HoleGroupID = "";
newEdge.p1 = vInterpolated.Index;
newEdge.p2 = MostRecentlySelectedEdge.p2;
EdgeList.Add(newEdge);
// update the current edge, set its 'p2' point to the interpolated point. This will trim it
// Also, clear out any holes, the split edge requires a reset
MostRecentlySelectedEdge.p2 = vInterpolated.Index;
MostRecentlySelectedEdge.HoleGroupID = "";
return(eOperationStatus.OK);
}
public virtual bool RemoveVertex(TVertex v)
{
GraphContracts.AssumeNotNull(v, "v");
if (!this.ContainsVertex(v))
{
return(false);
}
// collect edges to remove
EdgeList edgesToRemove = new EdgeList();
foreach (TEdge outEdge in this.OutEdges(v))
{
this.vertexInEdges[outEdge.Target].Remove(outEdge);
edgesToRemove.Add(outEdge);
}
foreach (TEdge inEdge in this.InEdges(v))
{
// might already have been removed
if (this.vertexOutEdges[inEdge.Source].Remove(inEdge))
{
edgesToRemove.Add(inEdge);
}
}
// notify users
if (this.EdgeRemoved != null)
{
foreach (TEdge edge in edgesToRemove)
{
this.OnEdgeRemoved(new EdgeEventArgs <TVertex, TEdge>(edge));
}
}
this.vertexOutEdges.Remove(v);
this.vertexInEdges.Remove(v);
this.edgeCount -= edgesToRemove.Count;
this.OnVertexRemoved(new VertexEventArgs <TVertex>(v));
GraphContracts.Assert(this.edgeCount >= 0);
return(true);
}
public void AddEdge(Vertex a, Vertex b)
{
Edge edga = new Edge(a, b);
//Edge edgb = new Edge(b,a);
//if (!EdgeList.Contains(edga) && !EdgeList.Contains(edgb))
//{
EdgeList.Add(edga);
//}
}
public static EdgeList ToEdges(BipartiteGraph g, List <GraphNode> cycle)
{
var elist = new EdgeList();
for (int i = 1; i < cycle.Count; i++)
{
Edge edg = g.Edges.FindByNodes(cycle[cycle.Count - i], cycle[cycle.Count - i - 1]);
elist.Add(edg);
}
return(elist);
}
/// <inheritdoc />
public virtual bool RemoveVertex(TVertex vertex)
{
if (!ContainsVertex(vertex))
{
return(false);
}
// Collect edges to remove
var edgesToRemove = new EdgeList <TVertex, TEdge>();
foreach (TEdge outEdge in OutEdges(vertex))
{
_vertexInEdges[outEdge.Target].Remove(outEdge);
edgesToRemove.Add(outEdge);
}
foreach (TEdge inEdge in InEdges(vertex))
{
// Might already have been removed
if (_vertexOutEdges[inEdge.Source].Remove(inEdge))
{
edgesToRemove.Add(inEdge);
}
}
// Notify users
if (EdgeRemoved != null)
{
foreach (TEdge edge in edgesToRemove)
{
OnEdgeRemoved(edge);
}
}
_vertexOutEdges.Remove(vertex);
_vertexInEdges.Remove(vertex);
EdgeCount -= edgesToRemove.Count;
OnVertexRemoved(vertex);
return(true);
}
public virtual bool RemoveVertex(TVertex v)
{
if (!this.ContainsVertex(v))
{
return(false);
}
// collect edges to remove
var edgesToRemove = new EdgeList <TVertex, TEdge>();
foreach (var outEdge in this.OutEdges(v))
{
this.vertexInEdges[outEdge.Target].Remove(outEdge);
edgesToRemove.Add(outEdge);
}
foreach (var inEdge in this.InEdges(v))
{
// might already have been removed
if (this.vertexOutEdges[inEdge.Source].Remove(inEdge))
{
edgesToRemove.Add(inEdge);
}
}
// notify users
if (this.EdgeRemoved != null)
{
foreach (TEdge edge in edgesToRemove)
{
this.OnEdgeRemoved(edge);
}
}
this.vertexOutEdges.Remove(v);
this.vertexInEdges.Remove(v);
this.edgeCount -= edgesToRemove.Count;
this.OnVertexRemoved(v);
return(true);
}
/// <summary>
/// Deletes all <see cref="Edge"/>s whose "to vertex" and "from vertex" are the same vertex.
/// </summary>
public void DeleteSelfEdges()
{
EdgeList deleteList = new EdgeList();
foreach (E link in this.Edges)
{
if (link.FromVertex == link.ToVertex)
{
deleteList.Add(link);
}
}
for (int i = 0; i < deleteList.Count; i++)
{
DeleteEdge(deleteList[i]);
}
}
internal void DeleteUselessEdges()
{
EdgeList deleteList = new EdgeList();
foreach (E link in this.Edges)
{
if (link.FromVertex == null || link.ToVertex == null)
{
deleteList.Add(link);
}
}
for (int i = 0; i < deleteList.Count; i++)
{
DeleteEdge(deleteList[i]);
}
}
public int RemoveInEdgeIf(TVertex v, EdgePredicate <TVertex, TEdge> predicate)
{
var edges = new EdgeList <TVertex, TEdge>();
foreach (var edge in this.InEdges(v))
{
if (predicate(edge))
{
edges.Add(edge);
}
}
foreach (var edge in edges)
{
this.RemoveEdge(edge);
}
return(edges.Count);
}
public eOperationStatus AppendEdge(int Width, int Height, int DeltaX, int DeltaY)
{
if (MostRecentlySelectedLayer == null)
{
return(eOperationStatus.NoLayerSelected);
}
eOperationStatus sts = MostRecentlySelectedLayer.AppendEdge(Width, Height, DeltaX, DeltaY);
if (sts != eOperationStatus.OK)
{
return(sts);
}
#if false
if (MostRecentlySelectedVertex == null)
{
return(eOperationStatus.NoVertexSelected);
}
// Add a new point
int nextindex = FindNextIndex();
Vertex vP = new Vertex();
vP.Index = nextindex;
vP.X = MostRecentlySelectedVertex.X + DeltaX;
vP.Y = MostRecentlySelectedVertex.Y + DeltaY;
VertexList.Add(vP);
// Add an edge
Edge oEdge = new Edge();
oEdge.Height = Height;
oEdge.Width = Width;
oEdge.p1 = MostRecentlySelectedVertex.Index;
oEdge.p2 = vP.Index;
oEdge.ID = "";
oEdge.HoleGroupID = "";
EdgeList.Add(oEdge);
#endif
// Redraw shapes
DrawShapes();
return(eOperationStatus.OK);
}
public void TestAddByIndex()
{
EdgeList expected = new EdgeList();
EdgeList real = Program.Code();
real.AddByIndex(1, new Edge(new Tuple <int, int>(0, 0)));
expected.Add(new Tuple <int, int>(0, 1));
expected.Add(new Tuple <int, int>(0, 0));
expected.Add(new Tuple <int, int>(3, 0));
expected.Add(new Tuple <int, int>(1, 3));
expected.Add(new Tuple <int, int>(1, 2));
expected.Add(new Tuple <int, int>(3, 2));
expected.Add(new Tuple <int, int>(0, 3));
Assert.AreEqual(expected.Count, real.Count);
Assert.AreEqual(expected.GetEdge(1).Data.Item1, real.GetEdge(1).Data.Item1);
}
private static List<List<string>> GetStraight(MatrixWithHeaders matrixWithHeaders)
{
Dictionary<object, IEnumerable<IEdge<object>>> vertexEdges = new Dictionary<object, IEnumerable<IEdge<object>>>();
BidirectionalGraph<object, IEdge<object>> graph = Graph.AdjacentyMatrixToGraph(matrixWithHeaders) as BidirectionalGraph<object, IEdge<object>>;
List<List<string>> straight = new List<List<string>>();
EdgeList<string, Edge<string>> candidates = new EdgeList<string, Edge<string>>();
var matrix = matrixWithHeaders.Matrix;
var headers = matrixWithHeaders.Headers;
var vertexes = graph.Vertices;
foreach (var item in vertexes)
{
var inEdges = graph.InEdges(item);
var outEdges = graph.OutEdges(item);
if (inEdges.Count() == 1 && outEdges.Count() == 1)
{
candidates.Add(new Edge<string>(inEdges.ElementAt(0).Source.ToString(), inEdges.ElementAt(0).Target.ToString()));
candidates.Add(new Edge<string>(outEdges.ElementAt(0).Source.ToString(), outEdges.ElementAt(0).Target.ToString()));
}
}
for (int x = candidates.Count() - 1; x > 0; x--)
{
if (candidates[x - 1].Source == candidates[x].Source && candidates[x - 1].Target == candidates[x].Target)
{
candidates.RemoveAt(x);
}
}
for (int x = 0; x < candidates.Count; x++)
{
for (int y = x + 1; y < candidates.Count; y++)
{
IEdge<object> edge = null;
graph.TryGetEdge(candidates[x].Source, candidates[y].Target, out edge);
if (edge != null)
{
var existItems = candidates.Select(z => z.Source == edge.Source.ToString() && z.Target == edge.Target.ToString()).ToList();
bool exist = false;
foreach (var item in existItems)
{
exist = exist || item;
}
if (exist == false)
{
List<string> tempList = new List<string>();
for (int z = x; z <= y; z++)
{
if (tempList.Contains(candidates[z].Source) == false)
{
tempList.Add(candidates[z].Source);
}
if (tempList.Contains(candidates[z].Target) == false)
{
tempList.Add(candidates[z].Target);
}
}
straight.Add(tempList);
}
}
}
}
return straight;
}
