Multilevel Multilevel_new(SparseMatrix A0, real *node_weights, Multilevel_control ctrl){
Multilevel grid;
SparseMatrix A = A0;
if (!SparseMatrix_is_symmetric(A, FALSE) || A->type != MATRIX_TYPE_REAL){
A = SparseMatrix_get_real_adjacency_matrix_symmetrized(A);
}
grid = Multilevel_init(A, node_weights);
grid = Multilevel_establish(grid, ctrl);
if (A != A0) grid->delete_top_level_A = TRUE;/* be sure to clean up later */
return grid;
}
void stress_model_core(int dim, SparseMatrix B, real **x, int edge_len_weighted, int maxit_sm, real tol, int *flag){
int m;
SparseStressMajorizationSmoother sm;
real lambda = 0;
/*int maxit_sm = 1000, i; tol = 0.001*/
int i;
SparseMatrix A = B;
if (!SparseMatrix_is_symmetric(A, FALSE) || A->type != MATRIX_TYPE_REAL){
if (A->type == MATRIX_TYPE_REAL){
A = SparseMatrix_symmetrize(A, FALSE);
A = SparseMatrix_remove_diagonal(A);
} else {
A = SparseMatrix_get_real_adjacency_matrix_symmetrized(A);
}
}
A = SparseMatrix_remove_diagonal(A);
*flag = 0;
m = A->m;
if (!x) {
*x = MALLOC(sizeof(real)*m*dim);
srand(123);
for (i = 0; i < dim*m; i++) (*x)[i] = drand();
}
if (edge_len_weighted){
sm = SparseStressMajorizationSmoother_new(A, dim, lambda, *x, WEIGHTING_SCHEME_SQR_DIST, TRUE);/* do not under weight the long distances */
//sm = SparseStressMajorizationSmoother_new(A, dim, lambda, *x, WEIGHTING_SCHEME_INV_DIST, TRUE);/* do not under weight the long distances */
} else {
sm = SparseStressMajorizationSmoother_new(A, dim, lambda, *x, WEIGHTING_SCHEME_NONE, TRUE);/* weight the long distances */
}
if (!sm) {
*flag = -1;
goto RETURN;
}
sm->tol_cg = 0.1; /* we found that there is no need to solve the Laplacian accurately */
sm->scheme = SM_SCHEME_STRESS;
SparseStressMajorizationSmoother_smooth(sm, dim, *x, maxit_sm, tol);
for (i = 0; i < dim*m; i++) {
(*x)[i] /= sm->scaling;
}
SparseStressMajorizationSmoother_delete(sm);
RETURN:
if (A != B) SparseMatrix_delete(A);
}
Multilevel Multilevel_new(SparseMatrix A0, SparseMatrix D0, real *node_weights, Multilevel_control ctrl){
/* A: the weighting matrix. D: the distance matrix, could be NULL. If not null, the two matrices must have the same sparsity pattern */
Multilevel grid;
SparseMatrix A = A0, D = D0;
if (!SparseMatrix_is_symmetric(A, FALSE) || A->type != MATRIX_TYPE_REAL){
A = SparseMatrix_get_real_adjacency_matrix_symmetrized(A);
}
if (D && (!SparseMatrix_is_symmetric(D, FALSE) || D->type != MATRIX_TYPE_REAL)){
D = SparseMatrix_symmetrize_nodiag(D, FALSE);
}
grid = Multilevel_init(A, D, node_weights);
grid = Multilevel_establish(grid, ctrl);
if (A != A0) grid->delete_top_level_A = TRUE;/* be sure to clean up later */
return grid;
}
SparseMatrix get_distance_matrix(SparseMatrix A, real scaling){
/* get a distance matrix from a graph, at the moment we just symmetrize the matrix. At the moment if the matrix is not real,
we just assume distance of 1 among edges. Then we apply scaling to the entire matrix */
SparseMatrix B;
real *val;
int i;
if (A->type == MATRIX_TYPE_REAL){
B = SparseMatrix_symmetrize(A, FALSE);
} else {
B = SparseMatrix_get_real_adjacency_matrix_symmetrized(A);
}
val = (real*) B->a;
if (scaling != 1) for (i = 0; i < B->nz; i++) val[i] *= scaling;
return B;
}
Multilevel_MQ_Clustering Multilevel_MQ_Clustering_new(SparseMatrix A0, int maxcluster) {
/* maxcluster is used to specify the maximum number of cluster desired, e.g., maxcluster=10 means that a maximum of 10 clusters
is desired. this may not always be realized, and mq may be low when this is specified. Default: maxcluster = 0 */
Multilevel_MQ_Clustering grid;
SparseMatrix A = A0;
if (maxcluster <= 0) maxcluster = A->m;
if (!SparseMatrix_is_symmetric(A, FALSE) || A->type != MATRIX_TYPE_REAL) {
A = SparseMatrix_get_real_adjacency_matrix_symmetrized(A);
}
grid = Multilevel_MQ_Clustering_init(A, 0);
grid = Multilevel_MQ_Clustering_establish(grid, maxcluster);
if (A != A0) grid->delete_top_level_A = TRUE;/* be sure to clean up later */
return grid;
}
void stress_model(int dim, SparseMatrix B, real **x, int maxit_sm, real tol, int *flag){
int m;
SparseStressMajorizationSmoother sm;
real lambda = 0;
/*int maxit_sm = 1000, i; tol = 0.001*/
int i;
SparseMatrix A = B;
if (!SparseMatrix_is_symmetric(A, FALSE) || A->type != MATRIX_TYPE_REAL){
if (A->type == MATRIX_TYPE_REAL){
A = SparseMatrix_symmetrize(A, FALSE);
A = SparseMatrix_remove_diagonal(A);
} else {
A = SparseMatrix_get_real_adjacency_matrix_symmetrized(A);
}
}
A = SparseMatrix_remove_diagonal(A);
*flag = 0;
m = A->m;
if (!x) {
*x = MALLOC(sizeof(real)*m*dim);
srand(123);
for (i = 0; i < dim*m; i++) (*x)[i] = drand();
}
sm = SparseStressMajorizationSmoother_new(A, dim, lambda, *x, WEIGHTING_SCHEME_NONE);/* do not under weight the long distances */
if (!sm) {
*flag = -1;
goto RETURN;
}
SparseStressMajorizationSmoother_smooth(sm, dim, *x, maxit_sm, 0.001);
for (i = 0; i < dim*m; i++) {
(*x)[i] /= sm->scaling;
}
SparseStressMajorizationSmoother_delete(sm);
RETURN:
if (A != B) SparseMatrix_delete(A);
}
static void
makeMap (SparseMatrix graph, int n, real* x, real* width, int* grouping,
char** labels, float* fsz, float* rgb_r, float* rgb_g, float* rgb_b, params_t* pm, Agraph_t* g )
{
int dim = pm->dim;
int i, flag = 0;
SparseMatrix poly_lines, polys, poly_point_map;
real edge_bridge_tol = 0.;
int npolys, nverts, *polys_groups, exclude_random;
real *x_poly, *xcombined;
enum {max_string_length = 1000};
enum {MAX_GRPS = 10000};
SparseMatrix country_graph;
int improve_contiguity_n = pm->improve_contiguity_n;
#ifdef TIME
clock_t cpu;
#endif
int nr0, nart0;
int nart, nrandom;
exclude_random = TRUE;
#if 0
if (argc >= 2) {
fp = fopen(argv[1],"r");
graph = SparseMatrix_import_matrix_market(fp, FORMAT_CSR);
}
if (whatout == OUT_M){
printf("Show[{");
}
#endif
#ifdef TIME
cpu = clock();
#endif
nr0 = nrandom = pm->nrandom; nart0 = nart = pm->nart;
make_map_from_rectangle_groups(exclude_random, pm->include_OK_points,
n, dim, x, width, grouping, graph, pm->bbox_margin, &nrandom, &nart, pm->nedgep,
pm->shore_depth_tol, edge_bridge_tol, &xcombined, &nverts, &x_poly, &npolys, &poly_lines,
&polys, &polys_groups, &poly_point_map, &country_graph, pm->highlight_cluster, &flag);
/* compute a good color permutation */
if (pm->color_optimize && country_graph && rgb_r && rgb_g && rgb_b)
map_optimal_coloring(pm->seed, country_graph, rgb_r, rgb_g, rgb_b);
#ifdef TIME
fprintf(stderr, "map making time = %f\n",((real) (clock() - cpu)) / CLOCKS_PER_SEC);
#endif
/* now we check to see if all points in the same group are also in the same polygon, if not, the map is not very
contiguous so we move point positions to improve contiguity */
if (graph && improve_contiguity_n) {
for (i = 0; i < improve_contiguity_n; i++){
improve_contiguity(n, dim, grouping, poly_point_map, x, graph, width);
nart = nart0;
nrandom = nr0;
make_map_from_rectangle_groups(exclude_random, pm->include_OK_points,
n, dim, x, width, grouping, graph, pm->bbox_margin, &nrandom, &nart, pm->nedgep,
pm->shore_depth_tol, edge_bridge_tol, &xcombined, &nverts, &x_poly, &npolys, &poly_lines,
&polys, &polys_groups, &poly_point_map, &country_graph, pm->highlight_cluster, &flag);
}
assert(!flag);
{
SparseMatrix D;
D = SparseMatrix_get_real_adjacency_matrix_symmetrized(graph);
remove_overlap(dim, D, x, width, 1000, 5000.,
ELSCHEME_NONE, 0, NULL, NULL, &flag);
nart = nart0;
nrandom = nr0;
make_map_from_rectangle_groups(exclude_random, pm->include_OK_points,
n, dim, x, width, grouping, graph, pm->bbox_margin, &nrandom, &nart, pm->nedgep,
pm->shore_depth_tol, edge_bridge_tol, &xcombined, &nverts, &x_poly, &npolys, &poly_lines,
&polys, &polys_groups, &poly_point_map, &country_graph, pm->highlight_cluster, &flag);
}
assert(!flag);
}
#if 0
if (whatout == OUT_DOT){
#endif
Dot_SetClusterColor(g, rgb_r, rgb_g, rgb_b, grouping);
plot_dot_map(g, n, dim, x, polys, poly_lines, pm->line_width, pm->line_color, x_poly, polys_groups, labels, width, fsz, rgb_r, rgb_g, rgb_b, pm->plot_label, pm->bg_color, (pm->plotedges?graph:NULL), pm->outfile);
#if 0
}
goto RETURN;
}
static void sfdpLayout(graph_t * g, spring_electrical_control ctrl,
int hops, pointf pad)
{
real *sizes;
real *pos;
Agnode_t *n;
int flag, i;
int n_edge_label_nodes = 0, *edge_label_nodes = NULL;
SparseMatrix D = NULL;
SparseMatrix A;
if (ctrl->method == METHOD_SPRING_MAXENT) /* maxent can work with distance matrix */
A = makeMatrix(g, Ndim, &D);
else
A = makeMatrix(g, Ndim, NULL);
if (ctrl->overlap >= 0) {
if (ctrl->edge_labeling_scheme > 0)
sizes = getSizes(g, pad, &n_edge_label_nodes, &edge_label_nodes);
else
sizes = getSizes(g, pad, NULL, NULL);
}
else
sizes = NULL;
pos = getPos(g, ctrl);
switch (ctrl->method) {
case METHOD_SPRING_ELECTRICAL:
case METHOD_SPRING_MAXENT:
multilevel_spring_electrical_embedding(Ndim, A, D, ctrl, NULL, sizes, pos, n_edge_label_nodes, edge_label_nodes, &flag);
break;
case METHOD_UNIFORM_STRESS:
uniform_stress(Ndim, A, pos, &flag);
break;
case METHOD_STRESS:{
int maxit = 200;
real tol = 0.001;
int weighted = TRUE;
if (!D){
D = SparseMatrix_get_real_adjacency_matrix_symmetrized(A);/* all distance 1 */
weighted = FALSE;
} else {
D = SparseMatrix_symmetrize_nodiag(D, FALSE);
weighted = TRUE;
}
if (hops > 0){
SparseMatrix DD;
DD = SparseMatrix_distance_matrix_khops(hops, D, weighted);
if (Verbose){
fprintf(stderr,"extracted a %d-neighborhood graph of %d edges from a graph of %d edges\n",
hops, (DD->nz)/2, (D->nz/2));
}
SparseMatrix_delete(D);
D = DD;
}
stress_model(Ndim, A, D, &pos, TRUE, maxit, tol, &flag);
}
break;
}
for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
real *npos = pos + (Ndim * ND_id(n));
for (i = 0; i < Ndim; i++) {
ND_pos(n)[i] = npos[i];
}
}
free(sizes);
free(pos);
SparseMatrix_delete (A);
if (D) SparseMatrix_delete (D);
if (edge_label_nodes) FREE(edge_label_nodes);
}
