36 float **rgb_r,
float **rgb_g,
float **rgb_b){
48 double *colors =
NULL;
49 int n = A0->
m, i, cdim;
52 bool weightedQ =
true;
66 int lightness[] = {0, 100};
70 const double accuracy = 0.01;
86 for (i = 0; i < n; i++){
87 (*rgb_r)[i+1] = (float) colors[cdim*i];
88 (*rgb_g)[i+1] = (float) colors[cdim*i + 1];
89 (*rgb_b)[i+1] = (float) colors[cdim*i + 2];
102 rgb_r++; rgb_b++; rgb_g++;
104 for (i = 0; i < n; i++) rgb_r[i] = u[i];
106 for (i = 0; i < n; i++) rgb_g[i] = u[i];
108 for (i = 0; i < n; i++) rgb_b[i] = u[i];
113 return point_poly_map->
ja[point_poly_map->
ia[ip]];
122 int i, j, *ia, *ja, u, v;
130 assert(
graph->m == n);
131 ia =
D->ia; ja =
D->ja;
137 for (i = 0; i < n; i++){
139 for (j = ia[i]; j < ia[i+1]; j++){
142 if (grouping[u] != grouping[v]){
154 GV_INFO(
"ratio (edges among discontiguous regions vs total edges)=%f", (
double)nbad / ia[n]);
192 double xy[2], yz[2], nxy[2], nyz[2], ymx[2], ymz[2], beta, bot;
195 for (i = 0; i < 2; i++) ymx[i] = y[i] - x[i];
196 for (i = 0; i < 2; i++) ymz[i] = y[i] -
z[i];
197 for (i = 0; i < 2; i++) xy[i] = 0.5*(x[i] + y[i]);
198 for (i = 0; i < 2; i++) yz[i] = 0.5*(y[i] +
z[i]);
203 bot = nyz[0]*(x[0]-y[0])+nyz[1]*(x[1]-y[1]);
205 c[0] = xy[0]; c[1] = xy[1];
208 beta = ((x[0] - y[0])*(xy[0] - yz[0])+(x[1] - y[1])*(xy[1] - yz[1]))/bot;
209 c[0] = yz[0] + beta*nyz[0];
210 c[1] = yz[1] + beta*nyz[1];
229 for (i = 0; i < n; i++){
230 for (j = ia[i]; j < ia[i+1]; j++){
231 if (ja[j] == i)
continue;
232 fprintf(f,
"%d -- %d;\n",i,ja[j]);
240 for (i = 0; i < n; i++){
242 fprintf(f,
"%d [label=\"%s\", pos=\"%lf,%lf\", fontsize=%f];\n",i, labels[i], x[i*
dim], x[i*
dim+1], fsz[i]);
244 fprintf(f,
"%d [label=\"%s\", pos=\"%lf,%lf\"];\n",i, labels[i], x[i*
dim], x[i*
dim+1]);
253 double line_width,
bool fill, const
char *cstring) {
255 assert(doubles_size(&xp) == doubles_size(&yp));
256 if (!doubles_is_empty(&xp)){
260 strlen(cstring), cstring, strlen(cstring), cstring,
264 size_t len_swidth = (size_t)snprintf(
NULL, 0,
"%f", line_width);
266 " -setlinewidth(%f) L %" PRISIZE_T " ", strlen(cstring), cstring,
267 len_swidth + 14, line_width, doubles_size(&xp));
270 cstring, doubles_size(&xp));
273 for (
size_t i = 0; i < doubles_size(&xp); i++) {
274 agxbprint(sbuff,
" %f %f", doubles_get(&xp, i), doubles_get(&yp, i));
281 double *x_poly,
int *polys_groups,
float *r,
282 float *g,
float *b,
const char *opacity) {
283 int i, j, *ia = polys->
ia, *ja = polys->
ja, *a = polys->
a, npolys = polys->
m, nverts = polys->
n, ipoly,first;
284 const bool fill =
false;
285 const bool use_line = line_width >= 0;
287 agxbuf cstring_buffer = {0};
288 agxbput(&cstring_buffer,
"#aaaaaaff");
289 char *cstring =
agxbuse(&cstring_buffer);
294 GV_INFO(
"npolys = %d", npolys);
295 first = abs(a[0]); ipoly = first + 1;
296 for (i = 0; i < npolys; i++){
297 for (j = ia[i]; j < ia[i+1]; j++){
298 assert(ja[j] < nverts && ja[j] >= 0);
300 if (abs(a[j]) != ipoly){
303 rgb2hex(r[polys_groups[i]], g[polys_groups[i]], b[polys_groups[i]],
304 &cstring_buffer, opacity);
305 cstring =
agxbuse(&cstring_buffer);
307 dot_polygon(sbuff, xp, yp, line_width, fill, cstring);
312 doubles_append(&xp, x_poly[2 * ja[j]]);
313 doubles_append(&yp, x_poly[2 * ja[j] + 1]);
316 dot_polygon(sbuff, xp, yp, line_width, fill, line_color);
329 const char *line_color,
double *x_poly,
int *polys_groups,
330 char **labels,
float *fsz,
float *r,
float *g,
float *b,
333 bool plot_polyQ =
true;
336 if (!r || !g || !b) plot_polyQ =
false;
339 fprintf(f,
"graph map {\n node [margin = 0 width=0.0001 height=0.00001 shape=plaintext];\n graph [outputorder=edgesfirst, bgcolor=\"#dae2ff\"]\n edge [color=\"#55555515\",fontname=\"Helvetica-Bold\"]\n");
354 if (!gr) fprintf(f,
"_background = \"");
359 if (line_width >= 0){
363 fprintf(f,
"%s",
agxbuse(&sbuff));
377 if (!gr) fprintf(f,
"}\n");
398 int i, j, i0, i1, i2, ntri;
402 if (trilist ==
NULL) {
409 for (i = 0; i < ntri; i++) {
410 for (j = 0; j < 3; j++) {
411 (*T)[i].vertices[j] = trilist[i * 3 + j];
413 i0 = (*T)[i].vertices[0]; i1 = (*T)[i].vertices[1]; i2 = (*T)[i].vertices[2];
436 int one = 1, jj, i, j, ig1, ig2;
438 int min_grp, max_grp;
440 min_grp = max_grp = groups[0];
441 for (i = 0; i < n; i++) {
442 max_grp =
MAX(groups[i], max_grp);
443 min_grp =
MIN(groups[i], min_grp);
445 if (min_grp <= 0)
return NULL;
449 for (i = 0; i < n; i++){
452 for (j = ia[i]; j < ia[i+1]; j++){
454 if (i != jj && groups[i] != groups[jj] && groups[jj] != GRP_RANDOM && groups[jj] != GRP_BBOX){
455 ig1 = groups[i]-1; ig2 = groups[jj]-1;
468 int one = 1, jj, i, j;
470 int ncomps, *comps =
NULL;
475 for (i = 0; i < n; i++){
476 for (j = ia[i]; j < ia[i+1]; j++){
478 if (i != jj && groups[i] == groups[jj]){
489 free((*poly_point_map)->ia);
490 free((*poly_point_map)->ja);
491 (*poly_point_map)->ia = comps_ptr;
492 (*poly_point_map)->ja = comps;
493 (*poly_point_map)->nz = n;
499 int **polys_groups,
int GRP_RANDOM,
int GRP_BBOX) {
505 int i, *tlist, nz, ipoly, nnt, ii, jj, t1, t2, t, cur, next, nn, j, nlink, sta;
506 int *
elist, edim = 3;
509 int *ie =
E->ia, *je =
E->ja, *e =
E->a;
513 for (i = 0; i < nt; i++) mask[i] = -1;
518 *polys_groups =
gv_calloc(ncomps,
sizeof(
int));
520 for (i = 0; i < nt; i++)
elist[i*edim + 2] = 0;
521 nz = ie[
E->m] - ie[0];
525 for (i = 0; i < ncomps; i++){
527 for (j = comps_ptr[i]; j < comps_ptr[i+1]; j++){
530 (*polys_groups)[i] = groups[ii];
533 if (groups[ii] == GRP_RANDOM || groups[ii] == GRP_BBOX)
continue;
535 for (jj = ie[ii]; jj < ie[ii+1]; jj++){
536 if (groups[je[jj]] != groups[ii] && jj < nz - 1 && je[jj] == je[jj+1]){
540 nlink =
elist[t1*edim + 2]%2;
541 elist[t1*edim + nlink] = t2;
542 elist[t1*edim + 2]++;
544 nlink =
elist[t2*edim + 2]%2;
545 elist[t2*edim + nlink] = t1;
546 elist[t2*edim + 2]++;
548 tlist[nnt++] = t1; tlist[nnt++] = t2;
555 for (j = 0; j < nnt; j++){
558 cur = sta = t; mask[cur] = i;
597 fprintf(stderr,
"cycle (edges): {");
599 fprintf(stderr,
"%d,",cur);
602 fprintf(stderr,
"%d}\n",cur);
605 fprintf(stderr,
"cycle (vertices): ");
613static int same_edge(
int ecur,
int elast,
int *edge_table){
635 int n =
E->
m, *ie =
E->ia, *je =
E->ja, *e =
E->a, ne, i, j, t1, t2, jj, ii;
636 int *cycle, cycle_head = 0;
639 int *edge_cycle_map, NOT_ON_CYCLE = -1;
641 enum {NO_DUPLICATE = -1};
642 int *
elist, edim = 3;
646 int k, duplicate, ee = 0, ecur, enext, eprev, cur, next, nn, nlink,
head, elast = 0, etail, tail, ehead, efirst;
652 edge_table =
gv_calloc(ne * 2,
sizeof(
int));
657 for (i = 0; i < n; i++){
658 for (j = ie[i]; j < ie[i+1]; j++){
659 if (j < ie[n] - ie[0] - 1 && i > je[j] && je[j] == je[j+1]){
664 edge_table[ne*2] = t1;
665 edge_table[ne*2+1] = t2;
670 edge_table[ne*2] = t2;
671 edge_table[ne*2+1] = t1;
687 edge_cycle_map =
gv_calloc(ne,
sizeof(
int));
689 for (i = 0; i < ne; i++) edge_cycle_map[i] = NOT_ON_CYCLE;
690 for (i = 0; i < ne; i++) emask[i] = -1;
696 for (i = 0; i < nt; i++)
elist[i*edim + 2] = 0;
700 for (i = 0; i < ncomps; i++){
701 if (DEBUG_CYCLE) fprintf(stderr,
"\n ============ comp %d has %d members\n",i, comps_ptr[i+1]-comps_ptr[i]);
702 for (k = comps_ptr[i]; k < comps_ptr[i+1]; k++){
704 duplicate = NO_DUPLICATE;
705 if (DEBUG_CYCLE) fprintf(stderr,
"member = %d has %d neighbors\n",ii, ie[ii+1]-ie[ii]);
706 for (j = ie[ii]; j < ie[ii+1]; j++){
710 if (DEBUG_CYCLE) fprintf(stderr,
" linked with %d using half-edge %d, {head,tail} of the edge = {%d, %d}\n",jj, ee, t1,
edge_tail(ee));
711 nlink =
elist[t1*edim + 2]%2;
712 elist[t1*edim + nlink] = ee;
713 elist[t1*edim + 2]++;
715 if (edge_cycle_map[ee] != NOT_ON_CYCLE) duplicate = ee;
719 if (duplicate == NO_DUPLICATE){
725 edge_cycle_map[ecur] = 1;
728 if (DEBUG_CYCLE) fprintf(stderr,
"NEW CYCLE\n starting with edge %d, {head,tail}={%d,%d}\n", ee,
head, next);
729 while (next !=
head){
735 if (DEBUG_CYCLE) fprintf(stderr,
"cur edge = %d, next edge %d, {head,tail}={%d,%d},\n",ecur, enext,
edge_head(enext),
edge_tail(enext));
742 edge_cycle_map[enext] = 1;
748 if (DEBUG_CYCLE)
cycle_print(ee, cycle,edge_table);
752 ecur = ee = duplicate;
753 while (emask[ecur] == ii){
760 if (DEBUG_CYCLE) fprintf(stderr,
" duplicating edge = %d, starting from the a non-duplicating edge %d, search backwards\n",ee, ecur);
764 while (emask[ecur] == ii){
765 if (DEBUG_CYCLE) fprintf(stderr,
" remove edge %d (%d--%d)\n",ecur,
edge_head(ecur),
edge_tail(ecur));
767 edge_cycle_map[ecur] = NOT_ON_CYCLE;
779 fprintf(stderr,
"remaining (broken) cycle = ");
799 if (DEBUG_CYCLE) fprintf(stderr,
"forwarding now from edge %d = {%d, %d}, try to reach vtx %d, first edge from voro = %d\n",
807 if (
same_edge(ecur, efirst, edge_table)){
808 if (DEBUG_CYCLE) fprintf(stderr,
"this voro cell fill in a hole completely!!!!\n");
811 edge_cycle_map[ecur] = 1;
814 if (DEBUG_CYCLE) fprintf(stderr,
"starting with edge %d, {head,tail}={%d,%d}\n", ecur,
head, next);
815 while (next != tail){
821 if (DEBUG_CYCLE) fprintf(stderr,
"cur edge = %d, next edge %d, {head,tail}={%d,%d},\n",ecur, enext,
edge_head(enext),
edge_tail(enext));
830 edge_cycle_map[enext] = 1;
843 while ((enext =
cycle_next(ecur)) != cycle_head){
844 edge_cycle_map[ecur] = NOT_ON_CYCLE;
849 edge_cycle_map[ecur] = NOT_ON_CYCLE;
864 free(edge_cycle_map);
879 int *comps =
NULL, *comps_ptr =
NULL, ncomps;
880 int GRP_RANDOM, GRP_BBOX;
885 groups =
gv_calloc(n + nrandom,
sizeof(
int));
886 maxgrp = grouping[0];
887 for (i = 0; i < n; i++) {
888 maxgrp =
MAX(maxgrp, grouping[i]);
889 groups[i] = grouping[i];
892 GRP_RANDOM = maxgrp + 1; GRP_BBOX = maxgrp + 2;
893 for (i = n; i < n + nrandom - 4; i++) {
894 groups[i] = GRP_RANDOM;
896 for (i = n + nrandom - 4; i < n + nrandom; i++) {
897 groups[i] = GRP_BBOX;
901 conn_comp(n + nrandom,
E, groups, poly_point_map);
903 ncomps = (*poly_point_map)->m;
904 comps = (*poly_point_map)->ja;
905 comps_ptr = (*poly_point_map)->ia;
909 for (i = ncomps - 1; i >= 0; i--) {
910 if (groups[comps[comps_ptr[i]]] != GRP_RANDOM &&
911 groups[comps[comps_ptr[i]]] != GRP_BBOX)
break;
914 GV_INFO(
"ncomps = %d", ncomps);
917 for (i = 0; i < nt; i++){
918 for (j = 0; j <
dim; j++){
929 polys_groups, GRP_RANDOM, GRP_BBOX);
945 double bounding_box_margin,
int nrandom,
946 int nedgep,
double shore_depth_tol,
int *nverts,
953 double xmax[2],
xmin[2], area, *x = x0;
956 int dim2 = 2, nn = 0;
957 int max_qtree_level = 10;
959 int imin, nzok = 0, nzok0 = 0, nt;
960 double *xran,
point[2];
964 bool INCLUDE_OK_POINTS = include_OK_points;
966 int *grouping = grouping0;
968 int HIGHLIGHT_SET = highlight_cluster;
970 for (j = 0; j < dim2; j++) {
975 for (i = 0; i < n; i++){
976 for (j = 0; j < dim2; j++) {
983 area = boxsize[0]*boxsize[1];
987 }
else if (nrandom < 0){
988 nrandom = -nrandom * n;
989 }
else if (nrandom < 4) {
995 if (shore_depth_tol < 0) shore_depth_tol = sqrt(area/(
double) n);
996 GV_INFO(
"nrandom=%d shore_depth_tol=%.08f", nrandom, shore_depth_tol);
1004 int k, t, np=nedgep;
1006 fprintf(stderr,
"add art np = %d\n",np);
1009 for (i = 0; i < n*
dim; i++) y[i] = x[i];
1010 grouping =
gv_calloc(n + nz * np,
sizeof(
int));
1011 for (i = 0; i < n; i++) grouping[i] = grouping0[i];
1013 for (i = 0; i <
graph->m; i++){
1015 for (j =
graph->ia[i]; j <
graph->ia[i+1]; j++){
1016 if (!HIGHLIGHT_SET || (grouping[i] == grouping[
graph->ja[j]] && grouping[i] == HIGHLIGHT_SET)){
1017 for (t = 0; t < np; t++){
1018 for (k = 0; k <
dim; k++){
1019 y[nz*
dim+k] = t/((double) np)*x[i*
dim+k] + (1-t/((double) np))*x[(
graph->ja[j])*
dim + k];
1021 assert(n + (nz-n)*np + t < n + nz*np && n + (nz-n)*np + t >= 0);
1022 if (t/((
double) np) > 0.5){
1023 grouping[nz] = grouping[i];
1025 grouping[nz] = grouping[
graph->ja[j]];
1032 fprintf(stderr,
"after adding edge points, n:%d->%d\n",n, nz);
1043 for (i = 0; i < dim2; i++) {
1044 if (bounding_box_margin > 0){
1045 xmin[i] -= bounding_box_margin;
1046 xmax[i] += bounding_box_margin;
1047 }
else if (bounding_box_margin < 0) {
1048 xmin[i] -= boxsize[i]*(-bounding_box_margin);
1049 xmax[i] += boxsize[i]*(-bounding_box_margin);
1051 xmin[i] -= fmax(boxsize[i] * 0.2, 2.* shore_depth_tol);
1052 xmax[i] += fmax(boxsize[i] * 0.2, 2 * shore_depth_tol);
1056 double bbm = bounding_box_margin;
1058 fprintf (stderr,
"bounding box margin: %.06f", bbm);
1060 fprintf (stderr,
"bounding box margin: (%.06f * %.06f)", boxsize[0], -bbm);
1062 fprintf(stderr,
"bounding box margin: %.06f",
1063 fmax(boxsize[0] * 0.2, 2 * shore_depth_tol));
1067 const double n1 = floor(
area2 / (shore_depth_tol * shore_depth_tol));
1068 const double n2 = n * floor(
area2 / area);
1069 nrandom = fmax(n1, n2);
1072 xran =
gv_calloc((nrandom + 4) * dim2,
sizeof(
double));
1074 if (INCLUDE_OK_POINTS){
1075 nzok0 = nzok = nrandom - 1;
1076 if (grouping == grouping0) {
1077 int *grouping2 =
gv_calloc(n + nrandom,
sizeof(
int));
1078 memcpy(grouping2, grouping,
sizeof(
int)*n);
1079 grouping = grouping2;
1081 grouping =
gv_recalloc(grouping, n, n + nrandom,
sizeof(
int));
1086 for (i = 0; i < nrandom; i++){
1088 for (j = 0; j < dim2; j++){
1094 if (min > shore_depth_tol){
1095 for (j = 0; j < dim2; j++){
1096 xran[nz*dim2+j] =
point[j];
1099 }
else if (INCLUDE_OK_POINTS && min > shore_depth_tol/10){
1100 for (j = 0; j < dim2; j++){
1101 xran[nzok*dim2+j] =
point[j];
1103 grouping[nn++] = grouping[
imin];
1110 if (
Verbose) fprintf(stderr,
"nn nrandom=%d\n", nrandom);
1112 xran =
gv_calloc(4 * dim2,
sizeof(
double));
1118 for (i = 0; i < dim2; i++)
xmin[i] -= 0.2*(
xmax[i]-
xmin[i]);
1119 for (i = 0; i < dim2; i++)
xmax[i] += 0.2*(
xmax[i]-
xmin[i]);
1121 for (j = 0; j < dim2; j++) xran[i*dim2+j] =
xmin[j];
1123 for (j = 0; j < dim2; j++) xran[i*dim2+j] =
xmax[j];
1125 xran[i*dim2] =
xmin[0]; xran[i*dim2+1] =
xmax[1];
1127 xran[i*dim2] =
xmax[0]; xran[i*dim2+1] =
xmin[1];
1132 if (INCLUDE_OK_POINTS){
1133 xcombined =
gv_calloc((nn + nrandom) * dim2,
sizeof(
double));
1135 xcombined =
gv_calloc((n + nrandom) * dim2,
sizeof(
double));
1137 for (i = 0; i < n; i++) {
1138 for (j = 0; j < dim2; j++) xcombined[i*dim2+j] = x[i*
dim+j];
1140 for (i = 0; i < nrandom; i++) {
1141 for (j = 0; j < dim2; j++) xcombined[(i + nn)*dim2+j] = xran[i*
dim+j];
1144 if (INCLUDE_OK_POINTS){
1145 for (i = 0; i < nn - n; i++) {
1146 for (j = 0; j < dim2; j++) xcombined[(i + n)*dim2+j] = xran[(nzok0 - i)*
dim+j];
1155 if (
Verbose) fprintf(stderr,
" highlight cluster %d, n = %d\n",HIGHLIGHT_SET, n);
1158 for (i = 0; i < n; i++){
1159 if (grouping[i] == HIGHLIGHT_SET){
1161 for (j = 0; j <
dim; j++){
1162 xcombined[nz++] = x[i*
dim+j];
1166 for (i = 0; i < n; i++){
1167 if (grouping[i] != HIGHLIGHT_SET){
1168 for (j = 0; j <
dim; j++){
1169 xcombined[nz++] = x[i*
dim+j];
1173 assert(nz == n*
dim);
1174 for (i = 0; i < nh; i++){
1177 for (i = nh; i < n; i++){
1182 if (
Verbose) fprintf(stderr,
"nh = %d\n",nh);
1187 if (
get_tri(n + nrandom, dim2, xcombined, &nt, &Tp, &
E) != 0) {
1191 get_polygons(n, nrandom, dim2, grouping, nt, Tp,
E, nverts, x_poly,
1192 poly_lines, polys, polys_groups, poly_point_map, country_graph);
1199 if (grouping != grouping0)
free(grouping);
1200 if (x != x0)
free(x);
1204static void add_point(
int *n,
int igrp,
double **x,
int *nmax,
double point[],
int **groups){
1207 int old_nmax = *nmax;
1209 *x =
gv_recalloc(*x, 2 * old_nmax, 2 * *nmax,
sizeof(
double));
1210 *groups =
gv_recalloc(*groups, old_nmax, *nmax,
sizeof(
int));
1213 (*x)[(*n)*2] =
point[0];
1214 (*x)[(*n)*2+1] =
point[1];
1215 (*groups)[*n] = igrp;
1224 for (i = 0; i < n; i++){
1233 int n,
int dim,
double *x,
double *sizes,
1234 int *grouping,
SparseMatrix graph,
double bounding_box_margin,
int nrandom,
int *nart,
int nedgep,
1235 double shore_depth_tol,
1236 int *nverts,
double **x_poly,
1294 int N, nmax, i, j, k, igrp;
1295 int *groups, K = *nart;
1297 double avgsize[2], avgsz, h[2], p1, p0;
1304 K = (int) 10/(1+n/400.);
1308 int maxgp = grouping[0];
1309 int mingp = grouping[0];
1310 for (i = 0; i < n; i++) {
1311 maxgp =
MAX(maxgp, grouping[i]);
1312 mingp =
MIN(mingp, grouping[i]);
1314 fprintf(stderr,
"max grouping - min grouping + 1 = %d\n",maxgp - mingp + 1);
1320 bounding_box_margin, nrandom, nedgep,
1321 shore_depth_tol, nverts, x_poly, poly_lines, polys,
1322 polys_groups, poly_point_map, country_graph,
1329 for (i = 0; i < n; i++){
1330 for (j = 0; j < 2; j++) {
1331 avgsize[j] += sizes[i*
dim+j];
1334 for (i = 0; i < 2; i++) avgsize[i] /= n;
1335 avgsz = 0.5*(avgsize[0] + avgsize[1]);
1336 GV_INFO(
"avgsize = {%f, %f}", avgsize[0], avgsize[1]);
1340 groups =
gv_calloc(n + nmax,
sizeof(
int));
1341 for (i = 0; i < n; i++) {
1342 groups[i] = grouping[i];
1343 for (j = 0; j < 2; j++){
1344 X[i*2+j] = x[i*
dim+j];
1349 if (shore_depth_tol < 0) {
1350 shore_depth_tol = -(shore_depth_tol)*avgsz;
1351 }
else if (shore_depth_tol == 0){
1354 shore_depth_tol = sqrt(area / n);
1355 GV_INFO(
"setting shore length ======%f", shore_depth_tol);
1362 delta[0] = .5*avgsize[0]/K;
delta[1] = .5*avgsize[1]/K;
1366 for (i = 0; i < n; i++){
1368 for (j = 0; j < 2; j++) {
1372 nadded[j] = (int) K*sizes[i*
dim+j]/avgsz;
1378 h[0] = sizes[i*
dim]/nadded[0];
1382 for (k = 0; k < nadded[0] - 1; k++){
1392 for (k = 0; k < nadded[0] - 1; k++){
1401 h[1] = sizes[i*
dim + 1]/nadded[1];
1405 for (k = 0; k < nadded[1] - 1; k++){
1415 for (k = 0; k < nadded[1] - 1; k++){
1426 bounding_box_margin, nrandom, nedgep,
1427 shore_depth_tol, nverts, x_poly, poly_lines, polys,
1428 polys_groups, poly_point_map, country_graph,
void QuadTree_get_nearest(QuadTree qt, double *x, double *ymin, int *imin, double *min)
QuadTree QuadTree_new_from_point_list(int dim, int n, int max_level, double *coord)
void SparseMatrix_distance_matrix(SparseMatrix D0, double **dist0)
SparseMatrix SparseMatrix_from_coordinate_format(SparseMatrix A)
SparseMatrix SparseMatrix_transpose(SparseMatrix A)
SparseMatrix SparseMatrix_symmetrize(SparseMatrix A, bool pattern_symmetric_only)
SparseMatrix SparseMatrix_coordinate_form_add_entry(SparseMatrix A, int irn, int jcn, const void *val)
void SparseMatrix_export(FILE *f, SparseMatrix A)
void SparseMatrix_delete(SparseMatrix A)
SparseMatrix SparseMatrix_get_real_adjacency_matrix_symmetrized(SparseMatrix A)
SparseMatrix SparseMatrix_sort(SparseMatrix A)
int * SparseMatrix_weakly_connected_components(SparseMatrix A0, int *ncomp, int **comps)
SparseMatrix SparseMatrix_from_coordinate_format_not_compacted(SparseMatrix A)
SparseMatrix SparseMatrix_remove_diagonal(SparseMatrix A)
SparseMatrix SparseMatrix_new(int m, int n, int nz, int type, int format)
SparseMatrix SparseMatrix_from_dense(int m, int n, double *x)
static void agxbfree(agxbuf *xb)
free any malloced resources
static int agxbprint(agxbuf *xb, const char *fmt,...)
Printf-style output to an agxbuf.
static WUR char * agxbuse(agxbuf *xb)
Memory allocation wrappers that exit on failure.
static void * gv_recalloc(void *ptr, size_t old_nmemb, size_t new_nmemb, size_t size)
static void * gv_calloc(size_t nmemb, size_t size)
abstract graph C library, Cgraph API
void rgb2hex(float r, float g, float b, agxbuf *cstring, const char *opacity)
void country_graph_coloring(int seed, SparseMatrix A, int **p)
helpers for verbose/debug printing
int * get_triangles(double *x, int n, int *tris)
static double dist(int dim, double *x, double *y)
#define X(prefix, name, str, type, subtype,...)
void vector_float_take(int n, float *v, int m, int *p, float **u)
double distance_cropped(double *x, int dim, int i, int j)
Agsym_t * agattr_text(Agraph_t *g, int kind, char *name, const char *value)
creates or looks up text attributes of a graph
int agwrite(Agraph_t *g, void *chan)
Return 0 on success, EOF on failure.
Agraph_t * graph(char *name)
static int imin(int a, int b)
minimum of two integers
#define DEFINE_LIST(name, type)
static int make_map_internal(bool include_OK_points, int n, int dim, double *x0, int *grouping0, SparseMatrix graph, double bounding_box_margin, int nrandom, int nedgep, double shore_depth_tol, int *nverts, double **x_poly, SparseMatrix *poly_lines, SparseMatrix *polys, int **polys_groups, SparseMatrix *poly_point_map, SparseMatrix *country_graph, int highlight_cluster)
static void triangle_center(double x[], double y[], double z[], double c[])
void map_palette_optimal_coloring(char *color_scheme, SparseMatrix A0, float **rgb_r, float **rgb_g, float **rgb_b)
static void plot_dot_edges(FILE *f, SparseMatrix A)
static void get_polygons(int n, int nrandom, int dim, int *grouping, int nt, struct Triangle *Tp, SparseMatrix E, int *nverts, double **x_poly, SparseMatrix *poly_lines, SparseMatrix *polys, int **polys_groups, SparseMatrix *poly_point_map, SparseMatrix *country_graph)
static void add_point(int *n, int igrp, double **x, int *nmax, double point[], int **groups)
static SparseMatrix get_country_graph(int n, SparseMatrix A, int *groups, int GRP_RANDOM, int GRP_BBOX)
static int same_edge(int ecur, int elast, int *edge_table)
static void get_boundingbox(int n, int dim, double *x, double *width, double *bbox)
int make_map_from_rectangle_groups(bool include_OK_points, int n, int dim, double *x, double *sizes, int *grouping, SparseMatrix graph, double bounding_box_margin, int nrandom, int *nart, int nedgep, double shore_depth_tol, int *nverts, double **x_poly, SparseMatrix *poly_lines, SparseMatrix *polys, int **polys_groups, SparseMatrix *poly_point_map, SparseMatrix *country_graph, int highlight_cluster)
static void get_poly_lines(int nt, SparseMatrix E, int ncomps, int *comps_ptr, int *comps, int *groups, SparseMatrix *poly_lines, int **polys_groups, int GRP_RANDOM, int GRP_BBOX)
static int get_tri(int n, int dim, double *x, int *nt, struct Triangle **T, SparseMatrix *E)
static SparseMatrix matrix_add_entry(SparseMatrix A, int i, int j, int val)
static void normal(double v[], double normal[])
static void cycle_print(int head, int *cycle, int *edge_table)
void map_optimal_coloring(int seed, SparseMatrix A, float *rgb_r, float *rgb_g, float *rgb_b)
static void plot_dot_labels(FILE *f, int n, int dim, double *x, char **labels, float *fsz)
static void dot_polygon(agxbuf *sbuff, doubles_t xp, doubles_t yp, double line_width, bool fill, const char *cstring)
static int get_poly_id(int ip, SparseMatrix point_poly_map)
static void get_polygon_solids(int nt, SparseMatrix E, int ncomps, int *comps_ptr, int *comps, SparseMatrix *polys)
static void plot_dot_polygons(agxbuf *sbuff, double line_width, const char *line_color, SparseMatrix polys, double *x_poly, int *polys_groups, float *r, float *g, float *b, const char *opacity)
void plot_dot_map(Agraph_t *gr, int n, int dim, double *x, SparseMatrix polys, SparseMatrix poly_lines, double line_width, const char *line_color, double *x_poly, int *polys_groups, char **labels, float *fsz, float *r, float *g, float *b, const char *opacity, SparseMatrix A, FILE *f)
void improve_contiguity(int n, int dim, int *grouping, SparseMatrix poly_point_map, double *x, SparseMatrix graph)
static void conn_comp(int n, SparseMatrix A, int *groups, SparseMatrix *poly_point_map)
#define neighbor(t, i, edim, elist)
static boxf bbox(Ppoly_t **obsp, int npoly, int *np)
int node_distinct_coloring(const char *color_scheme, int *lightness, bool weightedQ, SparseMatrix A0, double accuracy, int seed, int *cdim0, double **colors)
PATHUTIL_API COORD area2(Ppoint_t, Ppoint_t, Ppoint_t)
void stress_model(int dim, SparseMatrix B, double **x, int maxit_sm, int *flag)
static point center(point vertex[], size_t n)