public void Equals()
{
var edge1 = default(SEdge <int>);
var edge2 = new SEdge <int>(0, 0);
var edge3 = new SEdge <int>(1, 2);
var edge4 = new SEdge <int>(1, 2);
var edge5 = new SEdge <int>(2, 1);
Assert.AreEqual(edge1, edge1);
Assert.AreEqual(edge1, edge2); // Is equatable
Assert.AreEqual(edge2, edge1); // Is equatable
Assert.IsTrue(edge1.Equals(edge2)); // Is equatable
Assert.IsTrue(edge2.Equals(edge1)); // Is equatable
Assert.AreNotEqual(edge1, edge3);
Assert.AreNotEqual(edge3, edge1);
Assert.IsFalse(edge1.Equals(edge3));
Assert.IsFalse(edge3.Equals(edge1));
Assert.AreEqual(edge3, edge4);
Assert.AreEqual(edge4, edge3);
Assert.IsTrue(edge3.Equals(edge4));
Assert.IsTrue(edge4.Equals(edge3));
Assert.AreNotEqual(edge3, edge5);
Assert.AreNotEqual(edge5, edge3);
Assert.IsFalse(edge3.Equals(edge5));
Assert.IsFalse(edge5.Equals(edge3));
Assert.AreNotEqual(edge1, null);
Assert.IsFalse(edge1.Equals(null));
}
private static bool AddSingleEdge(SEdge <AssemblyDefinition> sEdge)
{
if (_edges.Contains(sEdge))
{
return(false);
}
string source = sEdge.Source.Name.Name;
string target = sEdge.Target.Name.Name;
if (_exclusions.Contains(source) || _exclusions.Contains(target))
{
return(false);
}
Trace.WriteLine(source + " => " + target);
_edges.Add(sEdge);
EnsureEdgeList(source);
EnsureEdgeList(target);
if (!_edgeList[source].Contains(target))
{
_edgeList[source].Add(target);
}
return(true);
}
public void ObjectToString()
{
var edge1 = new SEdge <int>(1, 2);
var edge2 = new SEdge <int>(2, 1);
Assert.AreEqual("1 -> 2", edge1.ToString());
Assert.AreEqual("2 -> 1", edge2.ToString());
}
public void SEdgeTestEverything()
{
var e = new SEdge <int>(0, 1);
Assert.AreEqual(0, e.Source);
Assert.AreEqual(1, e.Target);
Assert.AreEqual(String.Format("{0}->{1}", 0, 1), e.ToString());
}
public void EdgeArrayToAdjacencyGraph()
{
var edges = new SEdge<int>[] {
new SEdge<int>(1, 2),
new SEdge<int>(0, 1)
};
var graph = edges.ToAdjacencyGraph<int, SEdge<int>>();
}
public void EdgeArrayToAdjacencyGraph()
{
var edges = new SEdge <int>[] {
new SEdge <int>(1, 2),
new SEdge <int>(0, 1)
};
var graph = edges.ToAdjacencyGraph <int, SEdge <int> >();
}
public void EqualsDefaultEdge_ReferenceTypeExtremities()
{
var edge1 = default(SEdge <TestVertex>);
var edge2 = new SEdge <TestVertex>();
Assert.AreEqual(edge1, edge2);
Assert.AreEqual(edge2, edge1);
Assert.IsTrue(edge1.Equals(edge2));
Assert.IsTrue(edge2.Equals(edge1));
}
public void RenderGraphWithGraphviz()
{
var edges = new SEdge<int>[] {
new SEdge<int>(1, 2),
new SEdge<int>(0, 1),
new SEdge<int>(0, 3),
new SEdge<int>(2, 3)
};
var graph = edges.ToAdjacencyGraph<int, SEdge<int>>();
Console.WriteLine(graph.ToGraphviz());
}
public void RenderGraphWithGraphviz()
{
var edges = new SEdge <int>[] {
new SEdge <int>(1, 2),
new SEdge <int>(0, 1),
new SEdge <int>(0, 3),
new SEdge <int>(2, 3)
};
var graph = edges.ToAdjacencyGraph <int, SEdge <int> >();
Console.WriteLine(graph.ToGraphviz());
}
private static void AddEdges(AssemblyDefinition asm, int depth)
{
//if(depth > MaxDepth)
// return;
foreach (var dep in asm.Dependencies())
{
var sEdge = new SEdge<AssemblyDefinition>(asm, dep);
if (!AddSingleEdge(sEdge))
continue;
AddEdges(dep, depth + 1);
}
}
public void TransitiveReduction_ValueType()
{
// Test 1
var edge12 = new SEdge <int>(1, 2);
var edge13 = new SEdge <int>(1, 3);
var edge14 = new SEdge <int>(1, 4);
var edge15 = new SEdge <int>(1, 5);
var edge24 = new SEdge <int>(2, 4);
var edge34 = new SEdge <int>(3, 4);
var edge35 = new SEdge <int>(3, 5);
var edge45 = new SEdge <int>(4, 5);
var graph = new AdjacencyGraph <int, SEdge <int> >();
graph.AddVerticesAndEdgeRange(new[]
{
edge12, edge13, edge14, edge15,
edge24, edge34, edge35, edge45
});
BidirectionalGraph <int, SEdge <int> > result = graph.ComputeTransitiveReduction();
AssertHasVertices(result, new[] { 1, 2, 3, 4, 5 });
AssertHasEdges(
result,
new[] { edge12, edge13, edge24, edge34, edge45 });
Assert.AreEqual(5, result.EdgeCount);
// Test 2
var edge01 = new SEdge <int>(0, 1);
var edge02 = new SEdge <int>(0, 2);
var edge03 = new SEdge <int>(0, 3);
var edge23 = new SEdge <int>(2, 3);
var edge25 = new SEdge <int>(2, 5);
var edge65 = new SEdge <int>(6, 5);
var edge67 = new SEdge <int>(6, 7);
var edge74 = new SEdge <int>(7, 4);
graph = new AdjacencyGraph <int, SEdge <int> >();
graph.AddVerticesAndEdgeRange(new[]
{
edge01, edge02, edge03, edge23,
edge24, edge25, edge35, edge45,
edge65, edge67, edge74
});
result = graph.ComputeTransitiveReduction();
AssertHasVertices(result, new[] { 0, 1, 2, 3, 4, 5, 6, 7 });
AssertHasEdges(
result,
new[] { edge01, edge02, edge23, edge24, edge35, edge45, edge67, edge74 });
}
private static void AddEdges(AssemblyDefinition asm, int depth)
{
//if(depth > MaxDepth)
// return;
foreach (var dep in asm.Dependencies())
{
var sEdge = new SEdge <AssemblyDefinition>(asm, dep);
if (!AddSingleEdge(sEdge))
{
continue;
}
AddEdges(dep, depth + 1);
}
}
public void Equals()
{
var edge1 = default(SEdge <int>);
var edge2 = new SEdge <int>(0, 0);
var edge3 = new SEdge <int>(1, 2);
var edge4 = new SEdge <int>(1, 2);
var edge5 = new SEdge <int>(2, 1);
Assert.AreEqual(edge1, edge1);
Assert.AreEqual(edge1, edge2); // Is equatable
Assert.AreNotEqual(edge1, edge3);
Assert.AreEqual(edge3, edge4);
Assert.AreNotEqual(edge3, edge5);
Assert.AreNotEqual(edge1, null);
}
private void OnDfsBackEdge(SEdge <CurveVertex> e)
{
// e.Target --> e.Source is a back edge, that means there is a loop.
var loop = new List <SEdge <CurveVertex> >();
loop.Add(e);
var edge = e;
do
{
var prevEdge = _observer.VertexPredecessors[edge.Source];
loop.Add(prevEdge);
if (prevEdge.Source == e.Target)
{
break;
}
edge = prevEdge;
} while (true);
_allLoops.Add(loop.ToArray());
}
private static bool AddSingleEdge(SEdge<AssemblyDefinition> sEdge)
{
if (_edges.Contains(sEdge))
return false;
string source = sEdge.Source.Name.Name;
string target = sEdge.Target.Name.Name;
if(_exclusions.Contains(source) || _exclusions.Contains(target))
return false;
Trace.WriteLine(source + " => " + target);
_edges.Add(sEdge);
EnsureEdgeList(source);
EnsureEdgeList(target);
if (!_edgeList[source].Contains(target))
_edgeList[source].Add(target);
return true;
}
public void OnBeforeSerialize()
{
if (isDirty)
{
isDirty = false;
nodes.Clear();
edges.Clear();
// first pass, store node data
foreach (GraphNode <N> graphNode in digraph.Nodes())
{
SNode snode = new SNode(graphNode.Id, graphNode.Data);
if (!nodes.Contains(snode))
{
nodes.Add(snode);
}
}
// second pass, store edge data
foreach (GraphEdge <E> graphEdge in digraph.Edges())
{
SEdge sedge = new SEdge(graphEdge.FromId, graphEdge.ToId, graphEdge.Weight, (int)graphEdge.Directionality);
if (!edges.Contains(sedge))
{
edges.Add(sedge);
}
}
Type nType = typeof(N);
Type eType = typeof(E);
if (nodeTypeName == null || (!nodeTypeName.Equals(nType) || !edgeTypeName.Equals(eType)))
{
nodeTypeName = nType.IsPrimitive || nType.Equals(typeof(string)) ? nType.Name.ToLower() : nType.Name;
edgeTypeName = eType.IsPrimitive || eType.Equals(typeof(string)) ? eType.Name.ToLower() : eType.Name;
}
}
}
static void InitTriInfo(ref STriInfo[] pTriInfos, int[] pTriListIn, ref SMikkTSpaceContext context, int iNrTrianglesIn)
{
int f = 0, i = 0;
for (f = 0; f < iNrTrianglesIn; ++f)
{
pTriInfos[f].faceNeighbors = new int[3];
pTriInfos[f].AssignedGroup = new SGroup[3];
for (i = 0; i < 3; ++i)
{
pTriInfos[f].faceNeighbors[i] = -1;
pTriInfos[f].iFlag |= GROUP_WITH_ANY;
}
}
for (f = 0; f < iNrTrianglesIn; ++f)
{
Vector3 v1 = GetPosition(ref context, pTriListIn[f * 3]);
Vector3 v2 = GetPosition(ref context, pTriListIn[f * 3 + 1]);
Vector3 v3 = GetPosition(ref context, pTriListIn[f * 3 + 2]);
Vector2 t1 = GetTexCoord(ref context, pTriListIn[f * 3]);
Vector2 t2 = GetTexCoord(ref context, pTriListIn[f * 3 + 1]);
Vector2 t3 = GetTexCoord(ref context, pTriListIn[f * 3 + 2]);
Vector2 t2x = t2 - t1;
Vector2 t3x = t3 - t1;
Vector3 d1 = v2 - v1;
Vector3 d2 = v3 - v1;
float signedAreasSTx2 = t2x.X * t3x.Y - t2x.Y * t3x.X;
Vector3 vOs = d1 * t3x.Y - d2 * t2x.Y;
Vector3 vOt = d1 * -t3x.X - d2 * t2x.X;
pTriInfos[f].iFlag |= (signedAreasSTx2 > 0 ? ORIENT_PRESERVING : 0);
if (NotZero(signedAreasSTx2))
{
float fAbsArea = Math.Abs(signedAreasSTx2);
float fLenOs = vOs.Length;
float fLenOt = vOt.Length;
float fS = ((pTriInfos[f].iFlag & ORIENT_PRESERVING) == 0) ? -1.0f : 1.0f;
if (NotZero(fLenOs))
{
pTriInfos[f].vOs = fS / fLenOs * vOs;
}
if (NotZero(fLenOt))
{
pTriInfos[f].vOt = fS / fLenOt * vOt;
}
pTriInfos[f].fMagS = fLenOs / fAbsArea;
pTriInfos[f].fMagT = fLenOt / fAbsArea;
if (NotZero(pTriInfos[f].fMagS) && NotZero(pTriInfos[f].fMagT))
{
pTriInfos[f].iFlag &= (~GROUP_WITH_ANY);
}
}
}
{
SEdge[] pEdges = new SEdge[iNrTrianglesIn * 3];
//build neighbors fast
BuildNeighborsFast(ref pTriInfos, ref pEdges, pTriListIn, iNrTrianglesIn);
}
}
public void AddVerticesAndEdge328()
{
UndirectedGraph<int, SEdge<int>> undirectedGraph;
bool b;
undirectedGraph = UndirectedGraphFactory.Create(false);
SEdge<int> s0 = new SEdge<int>(357, 515);
b = this.AddVerticesAndEdge<int, SEdge<int>>(undirectedGraph, s0);
Assert.AreEqual<bool>(true, b);
Assert.IsNotNull((object)undirectedGraph);
Assert.IsNotNull(undirectedGraph.EdgeEqualityComparer);
Assert.AreEqual<int>(4, undirectedGraph.EdgeCapacity);
Assert.AreEqual<bool>(false, undirectedGraph.IsDirected);
Assert.AreEqual<bool>(false, undirectedGraph.AllowParallelEdges);
Assert.AreEqual<int>(1, undirectedGraph.EdgeCount);
}
private void OnDfsForwardOrCrossEdge(SEdge <CurveVertex> e)
{
}
