bool CircleFlowAlgorithm::reflow(DirectedGraph& g,const Rectangle<int>& area,
ObjController& objController, float /*deltaTime*/)
{
const int offsetX = area.getX();
const int offsetY = area.getY();
const int width = area.getWidth();
const int height = area.getHeight();
float interval = 2 * M_PI / (float) g.size();
int cx = width/2;
int cy = height/2;
// float vl = cx - (2 * g->getNode(0)->r1) - 10;
float vl = cx - 100;
for (int a = 0; a < g.size(); ++a)
{
Point<int> nc = GraphUtils::rotateCoordinate(vl, 0, (float) a * interval);
nc.x += offsetX;
nc.y += offsetY;
if(ObjectComponent* oc = objController.getObjectForId(g.getNode(a)->getLabel()))
{
Point<int> p(cx + nc.x*0.8, cy + nc.y*0.8);
oc->setPosition(p, false);
}
}
return false;
}
size_t DirectedGraph<T, MASK>::scc(std::vector<size_t>* vertex_color) const {
const DirectedGraph<T, MASK> rev_graph = reversed();
std::vector<size_t> order(this->vertices_count_);
top_sort_rec(&order);
std::vector<bool> used(this->vertices_count_, false);
std::vector<size_t> color(this->vertices_count_);
Queue<size_t> queue(this->vertices_count_);
size_t components_count = 0;
for (const auto& v : order) {
if (!used[v]) {
queue.clear();
queue.push(v);
while (!queue.empty()) {
const size_t vertex = queue.pop_front();
color[vertex] = components_count;
used[vertex] = true;
for (const auto& it : rev_graph.edges(vertex)) {
const size_t to = it.to();
if (!used[to]) {
used[to] = true;
queue.push(to);
}
}
}
++components_count;
}
}
if (vertex_color != nullptr) {
vertex_color->swap(color);
}
return components_count;
}
bool ForceDirectedFlowAlgorithm::reflow(DirectedGraph& g,
const Rectangle<int>& area,
ObjController& objController,
float /*deltaTime*/)
{
// const Array<Node*>& nodes = g.getNodes();
// const Array<Array<bool>>& edges = g.edges;
Point<float> totalEnergy(0.0, 0.0);
for (tNodesAndEdges& group : g.getConnectedGroups())
{
applyForces(totalEnergy, group, area.getWidth(), area.getHeight(), objController);
}
float lenTotalEnergy = sqrt(totalEnergy.x * totalEnergy.x + totalEnergy.y * totalEnergy.y);
// DBG(lenTotalEnergy);
if (lenTotalEnergy < stopEnergy)
{
g.setPositions();
return false;
}
return true;
}
vector<Component> FindZeroIndegreeComponents(const DirectedGraph &graph) {
vector<Component> components = FindWeaklyConnectedComponents(graph);
vector<bool> top_component_flags(components.size(), true);
vector<int> vertices_components(graph.size());
for (int component_number = 0;
component_number < components.size(); ++component_number) {
for (int vertex : components[component_number]) {
vertices_components[vertex] = component_number;
}
}
for (int vertex = 0; vertex < graph.size(); ++vertex) {
for (int adj_vertex : graph.GetAdjacentVertices(vertex)) {
if (vertices_components[vertex] != vertices_components[adj_vertex]) {
top_component_flags[vertices_components[adj_vertex]] = false;
}
}
}
vector<Component> top_components;
for (int component_number = 0;
component_number < components.size(); ++component_number) {
if (top_component_flags[component_number]) {
top_components.push_back(components[component_number]);
}
}
return top_components;
}
/**
* randomly generate a graph, for test purpose
*/
DirectedGraph * randgraph(int nvertex)
{
DirectedGraph * g = new DirectedGraph;
int i;
for(i=0;i<nvertex;i++) {
g->add_vertex(i);
}
// random connect
for(i=0;i<nvertex;i++) {
int j;
for(j=0;j<nvertex;j++) {
if (i == j)
continue;
int dice = rand()%2;
if (dice == 0) {
int w = rand()%100;
g->add_edge(i, j, w);
}
}
}
return g;
}
int main()
{
using namespace alg;
srand(time(NULL));
DirectedGraph * g = new DirectedGraph;
// construct 3 islands
int32_t i;
for (i=0;i<9;i++) {
g->add_vertex(i);
}
g->add_edge(0,1,1);
g->add_edge(1,2,1);
g->add_edge(2,0,1);
g->add_edge(3,4,1);
g->add_edge(4,5,1);
g->add_edge(5,3,1);
g->add_edge(6,7,1);
g->add_edge(7,8,1);
g->add_edge(8,6,1);
// connect island
g->add_edge(0,3,1);
g->add_edge(3,8,1);
g->printdot();
printf("find strongly connected component\n");
SCC(*g);
delete g;
return 0;
}
int main(void)
{
using namespace alg;
srand(time(NULL));
int NVERTEX = 6;
DirectedGraph * g = randgraph(NVERTEX);
g->print();
printf("finding Maximal Flow from 0 to 5: \n");
EdmondsKarp ek(*g);
uint32_t maxflow = ek.run(0,5);
printf("Max Flow is %d\n", maxflow);
printf("the residual network\n");
printf("\t");
for(uint32_t i=0;i<g->vertex_count();i++) {
printf("%d\t", ek.rmap()[i]);
}
printf("\n");
for(uint32_t i=0;i<g->vertex_count();i++) {
printf("%d\t",ek.rmap()[i]);
for(uint32_t j=0;j<g->vertex_count();j++) {
printf("%d\t", ek.residual()(i,j));
}
printf("\n");
}
delete g;
return 0;
}
int GetMaxCompanySize(const DirectedGraph &graph) {
vector<Component> top_components = FindZeroIndegreeComponents(graph);
int min_size = graph.size() + 2;
for (const Component &top_component : top_components) {
min_size = std::min(min_size, static_cast<int>(top_component.size()));
}
return graph.size() + 1 - min_size;
};
DirectedGraph<T, MASK> DirectedGraph<T, MASK>::reversed() const {
DirectedGraph<T, MASK> result;
result.init(this->vertices_count_);
for (const auto& edge : this->edges()) {
result.add_directed_edge(edge.reversed());
}
return result;
}
DirectedGraph Transpose(const DirectedGraph &graph) {
DirectedGraph tr_graph = DirectedGraph(graph.size());
for (int vertex = 0; vertex < graph.size(); ++vertex) {
for (int adj_vertex : graph.GetAdjacentVertices(vertex)) {
tr_graph.AddEdge(Edge(adj_vertex, vertex));
}
}
return tr_graph;
}
bool canFinish(int numCourses, vector<pair<int, int>>& prerequisites) {
// 本质上，相当于判断有向图中是否有环
// 如果有环，则不能完成所有课程
// corner case
if (numCourses <= 0) return true;
// build the graph
DirectedGraph graph = buildGraph(numCourses, prerequisites);
// detect cycle
return !graph.detectCycle();
}
/*
* (0)________>(2)
* | / \
* | / \
* (5)----(3)-----(4)
*/
TEST(DirectedBreadthFirstPathSearch, pathTo) {
DirectedGraph graph {20};
graph.addEdge(0, 2);
graph.addEdge(2, 3);
graph.addEdge(2, 4);
graph.addEdge(3, 5);
graph.addEdge(0, 5);
const DirectedBreadthFirstPathSearch search (&graph, 0);
Iterator<int>* it = search.pathTo(5);
EXPECT_EQ(0, it->next());
EXPECT_EQ(5, it->next());
EXPECT_EQ(false, it->hasNext());
}
static ext::optional<std::vector<pbxspec::PBX::FileType::shared_ptr>>
SortedFileTypes(std::vector<pbxspec::PBX::FileType::shared_ptr> const &fileTypes)
{
DirectedGraph<pbxspec::PBX::FileType::shared_ptr> graph;
for (pbxspec::PBX::FileType::shared_ptr const &fileType : fileTypes) {
if (fileType->base() != nullptr) {
graph.insert(fileType->base(), { fileType });
}
graph.insert(fileType, { });
}
return graph.ordered();
}
cv::Mat GraphComparator::_paintGraph(shared_ptr<OsmMap> map, DirectedGraph& graph, ShortestPath& sp)
{
const WayMap& ways = map->getWays();
cv::Mat mat(cvSize(_width, _height), CV_32FC1);
for (int y = 0; y < _height; y++)
{
float* row = mat.ptr<float>(y);
for (int x = 0; x < _width; x++)
{
row[x] = -1.0;
}
}
for (WayMap::const_iterator it = ways.begin(); it != ways.end(); ++it)
{
shared_ptr<Way> w = it->second;
double cost = sp.getNodeCost(w->getNodeIds()[0]);
if (cost >= 0)
{
double friction = graph.determineCost(w);
if (friction >= 0)
{
double startCost = cost;
double endCost = sp.getNodeCost(w->getNodeIds()[w->getNodeCount() - 1]);
_paintWay(mat, map, w, friction, startCost, endCost);
_maxGraphCost = std::max(startCost, endCost);
}
}
}
return mat;
}
static void DumpEdgeList(DirectedGraph<Layer*>& aGraph)
{
nsTArray<DirectedGraph<Layer*>::Edge> edges = aGraph.GetEdgeList();
for (PRUint32 i = 0; i < edges.Length(); i++) {
fprintf(stderr, "From: %p, To: %p\n", edges.ElementAt(i).mFrom, edges.ElementAt(i).mTo);
}
}
/*
Method:
1. calculate the topological order of the directed graph, t[]
2. calculate the ealiest event time of each vertice, ee[]
3. return ee[t[N-1]], N is the number of vertices
*/
int AOEnetwork::minCost(const DirectedGraph & g)const
{
Topologic obj;
size_t * t = obj.order(g);
int * ee = ealiestEventTime(g, t);
int cost = ee[t[g.numberOfVertices() - 1]];
delete[]t;
delete[]ee;
return cost;
}
void DepthFirstSearch(const DirectedGraph &graph, vector<int> &order,
vector<bool> &visited, int vertex) {
visited[vertex] = true;
for (int outgoing_vertex : graph.GetAdjacentVertices(vertex)) {
if (!visited[outgoing_vertex]) {
DepthFirstSearch(graph, order, visited, outgoing_vertex);
}
}
order.push_back(vertex);
}
static void DumpEdgeList(DirectedGraph<Layer*>& aGraph)
{
const nsTArray<DirectedGraph<Layer*>::Edge>& edges = aGraph.GetEdgeList();
for (uint32_t i = 0; i < edges.Length(); i++) {
fprintf(stderr, "From: ");
print_layer(stderr, edges.ElementAt(i).mFrom);
fprintf(stderr, ", To: ");
print_layer(stderr, edges.ElementAt(i).mTo);
fprintf(stderr, "\n");
}
}
int main()
{
srand(time(NULL));
int NVERTEX = 20;
DirectedGraph * g = randgraph(NVERTEX);
g->print();
printf("Random Delete Vertex:\n");
// random delete vertex
int i;
for(i=0;i<NVERTEX;i++) {
int n = rand()%NVERTEX;
printf("delete: %d\n", n);
g->delete_vertex(n);
}
g->print();
printf("Delete All Edges: \n");
for(i=0;i<NVERTEX;i++) {
int j;
for(j=i+1;j<NVERTEX;j++) {
g->delete_edge(i, j);
}
}
g->print();
return 0;
}
vector<Component> FindWeaklyConnectedComponents(const DirectedGraph &graph) {
const DirectedGraph tr_graph = Transpose(graph);
vector<bool> visited(graph.size(), false);
vector<int> order;
Component current_component;
vector<Component> components;
for (int vertex = 0; vertex < graph.size(); ++vertex) {
if (!visited[vertex])
DepthFirstSearch(graph, order, visited, vertex);
if (order.size() == graph.size())
break;
}
visited.assign(graph.size(), false);
for (auto it = order.rbegin(); it != order.rend(); ++it) {
if (!visited[*it]) {
DepthFirstSearch(tr_graph, current_component, visited, *it);
components.push_back(current_component);
current_component.clear();
}
}
return components;
}
int main(void)
{
using namespace alg;
srand(time(NULL));
int NVERTEX = 300;
clock_t ek_start, ek_end, pr_start, pr_end;
DirectedGraph * g = randgraph(NVERTEX);
// g->print();
printf("finding Maximal Flow from 0 to %d: \n", NVERTEX-1);
printf("The graph containing %d edges.\n", g->edge_count());
ek_start = clock();
EdmondsKarp ek(*g);
uint32_t maxflow = ek.run(0, NVERTEX-1);
ek_end = clock();
printf("Max Flow calculated by edmonds-karp algorithm is %d\n", maxflow);
// printf("the residual network\n");
// printf("\t");
// for(uint32_t i=0;i<g->vertex_count();i++) {
// printf("%d\t", ek2.rmap()[i]);
// }
// printf("\n");
// for(uint32_t i=0;i<g->vertex_count();i++) {
// printf("%d\t",ek2.rmap()[i]);
// for(uint32_t j=0;j<g->vertex_count();j++) {
// printf("%d\t", ek2.residual()(i,j));
// }
// printf("\n");
// }
pr_start = clock();
RelabelToFront pr2(*g);
uint32_t maxflow_pr = pr2.run(0, NVERTEX-1);
pr_end = clock();
printf("Max Flow calculated by push-relabel is %d\n", maxflow_pr);
// printf("the residual and preflow network\n");
// printf("\t");
// for(uint32_t i=0; i<g->vertex_count(); i++) {
// printf("%d\t", pr2.rmap()[i]);
// }
// printf("\n");
// for (uint32_t i=0; i<g->vertex_count(); i++){
// printf("%d\t", pr2.rmap()[i]);
// for (uint32_t j=0; j<g->vertex_count(); j++){
// printf("%d\t", pr2.residual()(i,j));
// }
// printf("\n");
// }
// printf("\n");
long ek_time = ek_end - ek_start;
long pr_time = pr_end - pr_start;
printf("The number of clock tick consumed by edmonds-karp is %ld\n", ek_time);
printf("--------------------------------- by push-relabel is %ld\n", pr_time);
delete g;
return 0;
}
int main(){
DirectedGraph<int> g;
g.addEdge(0, 1);
g.addEdge(0, 2);
g.addEdge(1, 2);
g.addEdge(2, 0);
g.addEdge(2, 3);
g.addEdge(3, 3);
if(cycleCheck(&g))cout<<"cyclic graph"<<endl;
else cout<<"acyclic graph"<<endl;
/*Create minimum spanning tree of unweighted graph
Graph<int> g;
g.addEdge(1, 0);
g.addEdge(0, 2);
g.addEdge(2, 1);
g.addEdge(0, 3);
g.addEdge(3, 4);
minimumSpanningTree(&g);*/
/* Find shortest path between two vertices
Graph<int> g;
g.addEdge(1, 0);
g.addEdge(0, 2);
g.addEdge(2, 1);
g.addEdge(0, 3);
g.addEdge(3, 4);
shortestPath(&g, 1, 3);
*/
/* Check if graph is bipartite
Graph<int> g;
g.addEdge(0,1);
g.addEdge(1,2);
g.addEdge(0,2);
if(isBipartiteBFS(&g))cout<<"Bipartite"<<endl;
else cout<<"Not bipartite"<<endl;
if(isBipartiteDFS(&g))cout<<"Bipartite"<<endl;
else cout<<"Not bipartite"<<endl;*/
/* Print reverse topological order
DirectedGraph<int> g;
g.addEdge(5, 2);
g.addEdge(5, 0);
g.addEdge(4, 0);
g.addEdge(4, 1);
g.addEdge(2, 3);
g.addEdge(3, 1);
g.print();
topologicalSort(&g);
*/
/* Find path between two vertices
Graph<int> g1;
g1.addEdge(1, 0);
g1.addEdge(0, 2);
g1.addEdge(2, 0);
g1.addEdge(0, 3);
g1.addEdge(3, 4);
Graph<int> g2;
g2.addEdge(0, 1);
g2.addEdge(1, 2);
findPathDFS(&g1, 0, 4);
*/
//check cycle in graph using DFS
/*if(cycleCheckBFS(&g1))cout<<"Cycle is present"<<endl;
else cout<<"Cycle is not present"<<endl;*/
/*if(cycleCheckBFS(&g2))cout<<"Cycle is present"<<endl;
else cout<<"Cycle is not present"<<endl;*/
//check cycle in graph using DFS
/*if(cycleCheckDFS(&g1))cout<<"Cycle is present"<<endl;
else cout<<"Cycle is not present"<<endl;
if(cycleCheckDFS(&g2))cout<<"Cycle is present"<<endl;
else cout<<"Cycle is not present"<<endl;*/
/*
Graph<int> g;
g.addEdge( 0, 1);
g.addEdge( 0, 4);
g.addEdge( 1, 2);
g.addEdge( 1, 3);
g.addEdge( 1, 4);
g.addEdge( 2, 3);
g.addEdge( 3, 4);
*/
//Depth First Search
//depthFirstSearch(&g);
//cout<<endl;
//Breadth First Search
//breadthFirstSearch(&g);
//cout<<endl;
// Print graph line by line such that each line contains node and all of its neighbours
//g.print();
return 0;
}
void SortLayersBy3DZOrder(nsTArray<Layer*>& aLayers)
{
uint32_t nodeCount = aLayers.Length();
if (nodeCount > MAX_SORTABLE_LAYERS) {
return;
}
DirectedGraph<Layer*> graph;
#ifdef DEBUG
if (gDumpLayerSortList) {
for (uint32_t i = 0; i < nodeCount; i++) {
if (aLayers.ElementAt(i)->GetDebugColorIndex() == 0) {
aLayers.ElementAt(i)->SetDebugColorIndex(gColorIndex++);
if (gColorIndex > 7) {
gColorIndex = 1;
}
}
}
fprintf(stderr, " --- Layers before sorting: --- \n");
DumpLayerList(aLayers);
}
#endif
// Iterate layers and determine edges.
for (uint32_t i = 0; i < nodeCount; i++) {
for (uint32_t j = i + 1; j < nodeCount; j++) {
Layer* a = aLayers.ElementAt(i);
Layer* b = aLayers.ElementAt(j);
LayerSortOrder order = CompareDepth(a, b);
if (order == ABeforeB) {
graph.AddEdge(a, b);
} else if (order == BBeforeA) {
graph.AddEdge(b, a);
}
}
}
#ifdef DEBUG
if (gDumpLayerSortList) {
fprintf(stderr, " --- Edge List: --- \n");
DumpEdgeList(graph);
}
#endif
// Build a new array using the graph.
nsTArray<Layer*> noIncoming;
nsTArray<Layer*> sortedList;
// Make a list of all layers with no incoming edges.
noIncoming.AppendElements(aLayers);
const nsTArray<DirectedGraph<Layer*>::Edge>& edges = graph.GetEdgeList();
for (uint32_t i = 0; i < edges.Length(); i++) {
noIncoming.RemoveElement(edges.ElementAt(i).mTo);
}
// Move each item without incoming edges into the sorted list,
// and remove edges from it.
do {
if (!noIncoming.IsEmpty()) {
uint32_t last = noIncoming.Length() - 1;
Layer* layer = noIncoming.ElementAt(last);
MOZ_ASSERT(layer); // don't let null layer pointers sneak into sortedList
noIncoming.RemoveElementAt(last);
sortedList.AppendElement(layer);
nsTArray<DirectedGraph<Layer*>::Edge> outgoing;
graph.GetEdgesFrom(layer, outgoing);
for (uint32_t i = 0; i < outgoing.Length(); i++) {
DirectedGraph<Layer*>::Edge edge = outgoing.ElementAt(i);
graph.RemoveEdge(edge);
if (!graph.NumEdgesTo(edge.mTo)) {
// If this node also has no edges now, add it to the list
noIncoming.AppendElement(edge.mTo);
}
}
}
// If there are no nodes without incoming edges, but there
// are still edges, then we have a cycle.
if (noIncoming.IsEmpty() && graph.GetEdgeCount()) {
// Find the node with the least incoming edges.
uint32_t minEdges = UINT_MAX;
Layer* minNode = nullptr;
for (uint32_t i = 0; i < aLayers.Length(); i++) {
uint32_t edgeCount = graph.NumEdgesTo(aLayers.ElementAt(i));
if (edgeCount && edgeCount < minEdges) {
minEdges = edgeCount;
minNode = aLayers.ElementAt(i);
if (minEdges == 1) {
break;
}
}
}
if (minNode) {
// Remove all of them!
graph.RemoveEdgesTo(minNode);
noIncoming.AppendElement(minNode);
}
}
} while (!noIncoming.IsEmpty());
NS_ASSERTION(!graph.GetEdgeCount(), "Cycles detected!");
#ifdef DEBUG
if (gDumpLayerSortList) {
fprintf(stderr, " --- Layers after sorting: --- \n");
DumpLayerList(sortedList);
}
#endif
aLayers.Clear();
aLayers.AppendElements(sortedList);
}
