private static void ResetGraph(PlanarGraph pg)
{
foreach (PlanarNode n in pg.planarNodes.Values)
{
n.parent = null;
n.children = new List <PlanarNode>();
n.dist = int.MaxValue;
n.state = 0;
n.insideCycle = false;
}
}
//step 6
private PlanarGraph CreateShrinkedGraph(Dictionary <int, List <long> > levels,
PlanarGraph pg, long srcNid)
{
Dictionary <long, PlanarNode> originalNodes
= new Dictionary <long, PlanarNode>(pg.planarNodes);
Dictionary <long, PlanarNode> shrNodes = new Dictionary <long, PlanarNode>();
foreach (int key in levels.Keys)
{
if (key >= lev0)// && key <= lev2)
{
foreach (long nid in levels[key])
{
PlanarNode n = pg.planarNodes[nid];
shrNodes.Add(n.nid, n);
}
}
}
PlanarNode src2 = originalNodes[srcNid];
shrNodes.Add(src2.nid, src2);
foreach (PlanarNode n in shrNodes.Values)
{
break;
List <int> newEdgesIds = new List <int>();
foreach (int eid in n.edgesIds)
{
PlanarEdge e = pg.planarEdges[eid];
PlanarNode neigh = e.GetNeigh(n);
if (shrNodes.ContainsKey(neigh.nid))
{
newEdgesIds.Add(eid);
}
}
n.edgesIds = newEdgesIds;
}
Dictionary <int, PlanarEdge> shrEdges = new Dictionary <int, PlanarEdge>();
foreach (PlanarEdge e in pg.planarEdges.Values)
{
break;
if (shrNodes.ContainsKey(
((PlanarNode)e.neighboursAdjEdges[0]).nid)
&&
shrNodes.ContainsKey(
((PlanarNode)e.neighboursAdjEdges[1]).nid))
{
shrEdges.Add(e.eid, e);
}
}
GoAroundBnfTree(pg.planarNodes, levels, src2);
return(new PlanarGraph(shrNodes, shrEdges));
}
private static void CheckNextEdges(PlanarGraph g, PlanarEdge e)
{
PlanarEdge ne = (PlanarEdge)e.neighboursAdjEdges[2];
if (!g.planarEdges.Keys.Contains(ne.eid))
{
e.neighboursAdjEdges[2] = FindAndSetNewNextEdge(g, (PlanarNode)e.neighboursAdjEdges[0], ne);
}
// ne = (PlanarEdge)e.neighboursAdjEdges[4];
// if (!g.planarEdges.Keys.Contains(ne.eid))
// e.neighboursAdjEdges[4] = FindAndSetNewNextEdge(g, (PlanarNode)e.neighboursAdjEdges[1], ne);
}
private static void CheckEdgesIds(PlanarGraph g, PlanarNode n)
{
List <int> tmp = new List <int>();
foreach (int eid in n.edgesIds)
{
if (g.planarEdges.ContainsKey(eid))
{
tmp.Add(eid);
}
}
n.edgesIds = tmp;
}
public static void GetDecompositionTree(PlanarGraph pg, Graph g)
{
nodesCount = g.nodes.Count();
List <PlanarNode> orderNodes = OrderBoundaryNodes(pg, g, srcId);
PlanarNode src = pg.planarNodes[srcId]; // .First().Value;
srcId = src.nid;
SeparatorCycle sepCycle = new SeparatorCycle();
RecursiveSeparation(pg, src, orderNodes, sepCycle);
Console.ReadKey();
}
private static int SetSumOfDescNodesIncludeItself(PlanarGraph g, PlanarNode pn,
Dictionary <long, List <PlanarNode> > children)
{
if (!children.Keys.Contains(pn.nid))
{
pn.cost = 1;
return(1);
}
int sum = 1;
foreach (PlanarNode n in children[pn.nid])
{
sum = sum + SetSumOfDescNodesIncludeItself(g, n, children);
}
pn.cost = sum;
return(sum);
}
private static PlanarEdge FindAndSetNewNextEdge(PlanarGraph g, PlanarNode n, PlanarEdge ne)
{
int ind = n.edgesIds.FindIndex(x => x == ne.eid);
int neid = ne.eid;
while (!g.planarEdges.ContainsKey(neid))
{
n.edgesIds.Remove(neid);
if (ind == n.edgesIds.Count)
{
ind = n.edgesIds.Count() - 1;
}
neid = n.edgesIds.ElementAt(ind);
}
ne = g.planarEdges[neid];
return(ne);
}
public bool GetBoundaryCycle(PlanarGraph graph, PlanarNode src,
PlanarEdge f) //step 8
{
g = graph;
allCostSum = g.planarNodes.Count; //cost=1
int index = allCostSum / 2;
SetCycleCost(f);
src.insideCycle = false;
Bfs.Src_all_bfs(src, g.planarNodes, g.planarEdges, true);
inC = new List <PlanarNode>();
outC = new List <PlanarNode>();
order++;
foreach (PlanarNode n in g.planarNodes.Values)
{
if (cycle.Contains(n.nid))
{
continue;
}
if (n.insideCycle)
{
inC.Add(n);
n.insideCycle = false;
}
else// if (!cycle.Contains(n.nid))
{
outC.Add(n);
}; //vc sep
}
List <PlanarNode> min;
if (inC.Count > outC.Count)
{
min = outC;
}
else
{
min = inC;
}
// if (!cyclesNodes.ContainsKey(f.eid))
// cyclesNodes.Add(f.eid, min);
return(min.Count > (g.planarNodes.Count) / 3);
}
private static void GetFacesAndTriangulation(PlanarGraph g)
{
foreach (PlanarNode n in g.planarNodes.Values)
{
Console.WriteLine(n.nid);
foreach (int i in n.edgesIds)
{
Console.WriteLine
(((PlanarNode)(g.planarEdges[i].neighboursAdjEdges[0])).nid + ", " +
((PlanarNode)(g.planarEdges[i].neighboursAdjEdges[1])).nid);
}
Console.WriteLine();
}
Console.ReadKey();
foreach (PlanarEdge e in g.planarEdges.Values)
{
e.state = 0;
}
foreach (PlanarNode n in g.planarNodes.Values)
{
PlanarEdge e;
List <int> eids = new List <int>(n.edgesIds);
foreach (int eid in eids)
{
try
{
e = g.planarEdges[eid];
if (e.state == 2 ||
!g.planarNodes.Keys.Contains(e.GetNeigh(n).nid))
{
continue;
}
}
catch
{
continue;
}
GetFaceAndTriangulate(g, e, true);
}
}
}
public void RecursiveSeparation(PlanarGraph graph, PlanarNode src,
int lev0)
{
List <long> c = new List <long>();
PlanarSeparator sep = new PlanarSeparator();
sep.Separate(ref graph, out c);
Console.WriteLine(graph.planarNodes.Count);
Console.ReadKey();
GetFirstCycle(graph, src, lev0);
List <PlanarNode> cycleNodes
= cycle.Select(x => graph.planarNodes[x]).ToList();
PlanarGraph g0 = new PlanarGraph(inC, cycleNodes, src,
new Dictionary <int, PlanarEdge> (graph.planarEdges));
// PlanarGraph g1 = new PlanarGraph(outC, cycleNodes, src, graph.planarEdges);
RecursiveSeparation(g0, g0.planarNodes.ElementAt(0).Value, 10000);
// RecursiveSeparation(g1, g1.planarNodes.ElementAt(0).Value, 10000);
}
public static void RemoveEdges(PlanarGraph g, PlanarNode src, int minLevel, int maxLevel) //jde udelat ryz=chleji primo v alg.sep.
{
foreach (PlanarNode n in g.planarNodes.Values)
{
if (n.parent != null && !g.planarNodes.ContainsKey(n.parent.nid))
{
n.parent = src;
}
}
List <int> keys = new List <int>(g.planarEdges.Keys);
foreach (int key in keys)
{
PlanarEdge e = g.planarEdges[key];
PlanarNode n0 = (PlanarNode)e.neighboursAdjEdges[0];
PlanarNode n1 = (PlanarNode)e.neighboursAdjEdges[1];
if (IsOutsideLevels(n0.dist, n1.dist, minLevel, maxLevel))
{
g.planarEdges.Remove(key);
}
else
{
if (!g.planarNodes.ContainsKey(n0.nid))
{
g.planarNodes.Add(n0.nid, n0);
}
if (!g.planarNodes.ContainsKey(n1.nid))
{
g.planarNodes.Add(n1.nid, n1);
}
}
}
foreach (PlanarEdge e in g.planarEdges.Values)
{
CheckNextEdges(g, e); //smazat
}
foreach (PlanarNode n in g.planarNodes.Values)
{
CheckEdgesIds(g, n);
}
}
public static void SetAllSumsOfDescNodesIncludeItself(PlanarGraph g, PlanarNode root,
int cost)
{
Dictionary <long, List <PlanarNode> > children = new Dictionary <long, List <PlanarNode> >();
foreach (PlanarNode pn in g.planarNodes.Values)
{
if (pn.parent != null)
{
if (!children.Keys.Contains(pn.parent.nid))
{
children[pn.parent.nid] = new List <PlanarNode>();
}
children[pn.parent.nid].Add(pn);
}
}
SetSumOfDescNodesIncludeItself(g, root, children);
}
private static List <PlanarNode> OrderBoundaryNodes(
PlanarGraph pg, Graph g, long srcId)
{
Dictionary <long, Node> boundaryNodes
= new Dictionary <long, Node>();
foreach (PlanarNode n in pg.planarNodes.Values.Where(x => !x.insideCR))
{
if (n.edgesIds.Count > 0)
{
boundaryNodes.Add(g.nodes[n.nid].id, g.nodes[n.nid]);
}
}
Graph boundaryGraph = new Graph();
boundaryGraph.nodes = boundaryNodes;
Node centre = new Node(-1);
centre.coordinates = g.nodes[srcId].coordinates;
foreach (Node n in boundaryNodes.Values)
{
Node.weightedEdge e = new Node.weightedEdge(n);
e.weight = 1;
centre.neighbourList.Add(e);
}
boundaryNodes.Add(centre.id, centre);
PlanarGraph boundaryPG = new PlanarGraph(boundaryGraph);
PlanarNode centrePG = boundaryPG.planarNodes[-1];
List <PlanarNode> result = new List <PlanarNode>();
foreach (int eid in centrePG.edgesIds)
{
result.Insert(0, boundaryPG.planarEdges[eid].GetNeigh(centrePG));
}
return(result);
}
public static void GetDecomposition(PlanarGraph g, PlanarNode src)
{
PlanarSeparator sep = new PlanarSeparator();
List <long> cycle;
// Bfs.Src_all_bfs(g.planarNodes.First().Value, g.planarEdges, true);
SeparatorCycle c = new SeparatorCycle();
c.GetCycle_U_V(g, g.planarNodes[3682132103], g.planarNodes[34073500]);
cycle = c.cycle;
Dictionary <long, PlanarNode> nodes
= new Dictionary <long, PlanarNode>(g.planarNodes);
List <long> nullKeys = new List <long>();
foreach (KeyValuePair <long, PlanarNode> pair in nodes)
{
PlanarNode n = pair.Value;
if (n == null || n.edgesIds.Count == 0)
{
nullKeys.Add(pair.Key);
continue;
}
n.state = 0;
n.dist = 0;
}
foreach (long nid in nullKeys)
{
nodes.Remove(nid);
}
foreach (long nid in cycle)
{
nodes.Remove(nid);
}
Dictionary <long, List <long> > components = new Dictionary <long, List <long> >();
foreach (PlanarNode x in nodes.Values)
{
if (x.state > 0)
{
continue;
}
// Bfs.Src_all_bfs(x, g.planarEdges, false);
List <long> comp = Bfs.part0;
components.Add(x.nid, comp);
}
int max = 0;
long maxKey = 0;
foreach (KeyValuePair <long, List <long> > pair in components)
{
if (nodes.ContainsKey(pair.Key) && pair.Value.Count > max)
{
max = pair.Value.Count;
maxKey = pair.Key;
}
}
PlanarNode s0 = nodes.Last().Value;
}
PlanarNode src; //, newSrc;
// public PlanarGraph shrGraph; //shrinked
// Dictionary<long, PlanarNode> shrNodes = new Dictionary<long, PlanarNode>();
/* public Dictionary<int, List<long>> Separate(PlanarGraph pg, out List<long> cycle)
* {
* return Separate(pg.planarNodes, pg.planarEdges, out cycle);
* }
*/
public Dictionary <int, List <long> > Separate(
ref PlanarGraph pg, out List <long> cycle)
{
planarNodes = pg.planarNodes;
planarEdges = pg.planarEdges;
src = planarNodes.First().Value;
Bfs.Src_all_bfs(src, pg.planarNodes, planarEdges);
// step 3, 4, 5
Dictionary <int, List <long> > levels = CreateMainLevels(src.nid);
//step 6
// PlanarGraph shrinkedGraph = pg;// CreateShrinkedGraph(levels, pg,src.nid);
// foreach (long nid in levels[int.MaxValue])
// shrinkedGraph.planarNodes.Remove(nid);
//step 7
// Bfs.Src_all_bfs(src, shrinkedGraph.planarEdges);
SeparatorUtils.SetAllSumsOfDescNodesIncludeItself(pg, src, 1);
if (Triangulation.triEdges == null || Triangulation.triEdges.Count == 0)
{
pg = Triangulation.GetTriangulation(pg);
}
// PlanarEdge xx = shrinkedGraph.planarEdges[1630674];
//step 8
// SeparatorCycle sepCycle = new SeparatorCycle();
// StreamWriter w = new StreamWriter("C:\\Users\\L\\Desktop\\triCycles2.txt");
try
{
// sepCycle.GetFirstCycle(shrinkedGraph, src, lev0);
}
catch { };
// foreach (string s in sepCycle.outputs)
// w.WriteLine(s);
// w.Close();
cycle = null;
return(new Dictionary <int, List <long> >());
/*
*
* PlanarGraph trg = Triangulation.GetTriangulation(
* new PlanarGraph(plNodes, plEdges));
* foreach (int eid in planarEdges.Keys.Reverse<int>())
* {
* break;
* PlanarEdge e = trg.planarEdges[eid];
* if (e.inTree)
* continue;
* PlanarNode u = (PlanarNode)e.neighboursAdjEdges[0];
* PlanarNode v = (PlanarNode)e.neighboursAdjEdges[1];
* List<long> pathU = new List<long>();
* List<long> pathV = new List<long>();
* PlanarNode x = u;
*
* while (x.parent != null)
* {
* x.state = -3;
* pathU.Add(x.nid);
* x = x.parent;
* }
* pathV = new List<long>();
* x = v;
*
* while (x.parent != null && x.parent.state != -3)
* {
* pathV.Add(x.nid);
* x = x.parent;
* }
* pathV.Add(x.nid);
* }
*
* /////////////////////////
*
* planarNodes = trg.planarNodes;
* planarEdges = trg.planarEdges;
*
* GoAroundBnfTree(levels);
*
* SeparatorUtils.UpdateNextEdges(newSrc, plEdges);
* SeparatorUtils.UpdateNextEdges(src, planarEdges);
* shrNodes.Add(newSrc.nid, newSrc);
* //shrGraph = new PlanarGraph(shrNodes, planarEdges);
*
* SeparatorUtils.RemoveEdges(shrGraph, newSrc, lev0, lev2);
* SeparatorUtils.SetAllSumsOfDescNodesIncludeItself(shrGraph, 1);
*
* SeparatorCycle sepCycle = new SeparatorCycle();
* sepCycle.GetFirstCycle(trg);
*
*
*
* src = newSrc;
* cycle = sepCycle.cycle;
* return levels;
*/
}
public SeparatorCycle(PlanarGraph graph)
{
g = graph;
}
public void GetFirstCycle(PlanarGraph graph, PlanarNode src,
int lev0) //step 8
{
g = graph;
allCostSum = g.planarNodes.Count; //cost=1
int index = allCostSum / 2; //od pol.
// bool found = false;
// PlanarEdge e = null;
// for (int i = index; i < g.planarNodes.Count; i++)
// {
// foreach (int eid in g.planarNodes.ElementAt(i).Value.edgesIds)
PlanarEdge f;
if (order <= 1)
{
f = g.planarEdges[1630674];
}
else
{
if (orderedTriE == null)
{
Init(lev0);
}
if (orderedTriE.Count == 0)
{
return;
}
f = orderedTriE[0];
orderedTriE.RemoveAt(0);
}
SetCycleCost(f);
src.insideCycle = false;
Bfs.Src_all_bfs(src, g.planarNodes, g.planarEdges, true);
inC = new List <PlanarNode>();
outC = new List <PlanarNode>();
order++;
foreach (PlanarNode n in g.planarNodes.Values)
{
if (cycle.Contains(n.nid))
{
continue;
}
if (n.insideCycle)
{
inC.Add(n);
n.insideCycle = false;
}
else// if (!cycle.Contains(n.nid))
{
outC.Add(n);
}; //vc sep
}
List <PlanarNode> min;
if (inC.Count > outC.Count)
{
min = outC;
}
else
{
min = inC;
}
// if (!cyclesNodes.ContainsKey(f.eid))
// cyclesNodes.Add(f.eid, min);
if (min.Count < g.planarNodes.Count / 13)
{
GetFirstCycle(g, src, lev0);
}
}
public void GetCycle_U_V(PlanarGraph graph, PlanarNode u, PlanarNode v)
{
g = graph;
// GetCycle(u, v);
}
private static void GetFaceAndTriangulate(PlanarGraph g, PlanarEdge e0, bool forward)
{
List <long> nids = new List <long>();
PlanarNode n0 = (PlanarNode)e0.neighboursAdjEdges[0];
PlanarNode n1 = (PlanarNode)e0.neighboursAdjEdges[1];
PlanarNode n2, n3;
int i0 = n1.edgesIds.IndexOf(e0.eid); //TODO: metoda
if (i0 == n1.edgesIds.Count - 1)
{
i0 = 0;
}
else
{
i0++;
}
PlanarEdge e1 = g.planarEdges[n1.edgesIds.ElementAt(i0)];
n2 = e1.GetNeigh(n1);
i0 = n2.edgesIds.IndexOf(e1.eid); //TODO: metoda
if (i0 == n2.edgesIds.Count - 1)
{
i0 = 0;
}
else
{
i0++;
}
PlanarEdge e2 = g.planarEdges[n2.edgesIds.ElementAt(i0)];
n3 = e2.GetNeigh(n2);
if (n3.nid == n0.nid)
{
return; //triangle
}
PlanarEdge ne;
if (n0 == n2 && n1 != n3)
{
ne = new PlanarEdge(n1, n3, e0); //n1.edgesIds==<n0>
ne.eid = g.planarEdges.Keys.Max() + 1;
n1.edgesIds.Insert(0, ne.eid);
n3.edgesIds.Insert(Math.Max(0, n3.edgesIds.IndexOf(e2.eid) - 1), ne.eid);
g.planarEdges.Add(ne.eid, ne);
return;
}
else if (n1 != n3)
{
ne = new PlanarEdge(n0, n2, e0);
}
else
{
throw new NotImplementedException();
}
//return;
ne.eid = g.planarEdges.Keys.Max() + 1;
if (n0.edgesIds[0] == e0.eid)
{
n0.edgesIds.Add(ne.eid);
}
else
{
int ind3 = n0.edgesIds.IndexOf(e0.eid) - 1;
n0.edgesIds.Insert(ind3 + 1, ne.eid);
}
n2.edgesIds.Insert(n2.edgesIds.IndexOf(e2.eid), ne.eid);
g.planarEdges.Add(ne.eid, ne);
/* if (e3.neighboursAdjEdges[0] == n0)
* e3.neighboursAdjEdges[2] = ne;
* else
* e3.neighboursAdjEdges[4] = ne;
*/
e0.state++;
e1.state++;
nids.Add(n0.nid);
nids.Add(n1.nid);
nids.Add(n2.nid);
nids.Add(n3.nid);
while (n3.nid != n0.nid)
{
nids.Add(n3.nid);
n2 = n3;
e2 = e2.GetNextEdge(n2, out n3);
e2.state++;
n3 = e2.GetNeigh(n2);
}
}
