void FruchtermanReingold :: calculate_exact_repulsive_forces(const Graph &G, NodeArray
                            <NodeAttributes> &A, NodeArray<DPoint>& F_rep)
{
	//naive algorithm by Fruchterman & Reingold
	mathExtension M;
	numexcept N;
	node v,u;
	DPoint f_rep_u_on_v;
	DPoint vector_v_minus_u;
	DPoint pos_u,pos_v;
	DPoint nullpoint (0,0);
	double norm_v_minus_u;
	long node_number = G.numberOfNodes();
	Array<node> array_of_the_nodes (node_number+1);
	long counter = 1;
	long i,j; 
	double scalar;

	forall_nodes(v,G)
		F_rep[v]= nullpoint;

	forall_nodes(v,G)
	{
		array_of_the_nodes[counter]=v;
		counter++;   
	}    
Beispiel #2
0
void FruchtermanReingold::calculate_exact_repulsive_forces(
	const Graph &G,
	NodeArray<NodeAttributes> &A,
	NodeArray<DPoint>& F_rep)
{
	//naive algorithm by Fruchterman & Reingold
	numexcept N;
	DPoint f_rep_u_on_v;
	DPoint vector_v_minus_u;
	DPoint pos_u, pos_v;
	DPoint nullpoint(0, 0);
	double norm_v_minus_u;
	int node_number = G.numberOfNodes();
	Array<node> array_of_the_nodes(node_number + 1);
	double scalar;

	for (node v : G.nodes)
		F_rep[v] = nullpoint;

	int counter = 1;
	for (node v : G.nodes)
	{
		array_of_the_nodes[counter] = v;
		counter++;
	}

	for (int i = 1; i < node_number; i++) {
		for (int j = i + 1; j <= node_number; j++)
		{
			node u = array_of_the_nodes[i];
			node v = array_of_the_nodes[j];
			pos_u = A[u].get_position();
			pos_v = A[v].get_position();
			if (pos_u == pos_v)
			{//if2  (Exception handling if two nodes have the same position)
				pos_u = N.choose_distinct_random_point_in_radius_epsilon(pos_u);
			}//if2
			vector_v_minus_u = pos_v - pos_u;
			norm_v_minus_u = vector_v_minus_u.norm();
			if (!N.f_rep_near_machine_precision(norm_v_minus_u, f_rep_u_on_v))
			{
				scalar = f_rep_scalar(norm_v_minus_u) / norm_v_minus_u;
				f_rep_u_on_v.m_x = scalar * vector_v_minus_u.m_x;
				f_rep_u_on_v.m_y = scalar * vector_v_minus_u.m_y;
			}
			F_rep[v] = F_rep[v] + f_rep_u_on_v;
			F_rep[u] = F_rep[u] - f_rep_u_on_v;
		}
	}
}