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); } }