ref: f749a33c5eeb67b19305085feebfe35b0ccaffd0
dir: /auxiliary/spectre-help.c/
/*
* Common code between spectre-test and spectre-gen, since both of
* them want to output SVG graphics.
*/
#include <assert.h>
#include <errno.h>
#include <math.h>
#include <stdio.h>
#include <string.h>
#include "puzzles.h"
#include "tree234.h"
#include "spectre-internal.h"
#include "spectre-tables-extra.h"
#include "spectre-help.h"
struct HexData {
const int *edges;
};
static const struct HexData hexdata[] = {
#define HEXDATA_ENTRY(x) { edges_##x },
HEX_LETTERS(HEXDATA_ENTRY)
#undef HEXDATA_ENTRY
};
const char *hex_names[10] = {
"G", "D", "J", "L", "X", "P", "S", "F", "Y",
"" /* NO_HEX */
};
Graphics *gr_new(const char *filename, double xmin, double xmax,
double ymin, double ymax, double scale)
{
Graphics *gr = snew(Graphics);
if (!strcmp(filename, "-")) {
gr->fp = stdout;
gr->close_file = false;
} else {
gr->fp = fopen(filename, "w");
if (!gr->fp) {
fprintf(stderr, "%s: open: %s\n", filename, strerror(errno));
exit(1);
}
gr->close_file = true;
}
fprintf(gr->fp, "<?xml version=\"1.0\" encoding=\"UTF-8\" "
"standalone=\"no\"?>\n");
fprintf(gr->fp, "<svg xmlns=\"http://www.w3.org/2000/svg\" "
"version=\"1.1\" width=\"%f\" height=\"%f\">\n",
(xmax - xmin) * scale, (ymax - ymin) * scale);
gr->absscale = fabs(scale);
gr->xoff = -xmin * scale;
gr->xscale = scale;
/* invert y axis for SVG top-down coordinate system */
gr->yoff = ymax * scale;
gr->yscale = -scale;
/* Defaults, which can be overridden by the caller immediately
* after this constructor returns */
gr->jigsaw_mode = false;
gr->vertex_blobs = true;
gr->number_cells = true;
gr->four_colour = false;
gr->arcs = false;
gr->linewidth = 1.5;
gr->started = false;
return gr;
}
void gr_free(Graphics *gr)
{
if (!gr)
return;
fprintf(gr->fp, "</svg>\n");
if (gr->close_file)
fclose(gr->fp);
sfree(gr);
}
static void gr_ensure_started(Graphics *gr)
{
if (gr->started)
return;
fprintf(gr->fp, "<style type=\"text/css\">\n");
fprintf(gr->fp, "path { fill: none; stroke: black; stroke-width: %f; "
"stroke-linejoin: round; stroke-linecap: round; }\n",
gr->linewidth);
fprintf(gr->fp, "text { fill: black; font-family: Sans; "
"text-anchor: middle; text-align: center; }\n");
if (gr->four_colour) {
fprintf(gr->fp, ".c0 { fill: rgb(255, 178, 178); }\n");
fprintf(gr->fp, ".c1 { fill: rgb(255, 255, 178); }\n");
fprintf(gr->fp, ".c2 { fill: rgb(178, 255, 178); }\n");
fprintf(gr->fp, ".c3 { fill: rgb(153, 153, 255); }\n");
} else {
fprintf(gr->fp, ".G { fill: rgb(255, 128, 128); }\n");
fprintf(gr->fp, ".G1 { fill: rgb(255, 64, 64); }\n");
fprintf(gr->fp, ".F { fill: rgb(255, 192, 128); }\n");
fprintf(gr->fp, ".Y { fill: rgb(255, 255, 128); }\n");
fprintf(gr->fp, ".S { fill: rgb(128, 255, 128); }\n");
fprintf(gr->fp, ".D { fill: rgb(128, 255, 255); }\n");
fprintf(gr->fp, ".P { fill: rgb(128, 128, 255); }\n");
fprintf(gr->fp, ".X { fill: rgb(192, 128, 255); }\n");
fprintf(gr->fp, ".J { fill: rgb(255, 128, 255); }\n");
fprintf(gr->fp, ".L { fill: rgb(128, 128, 128); }\n");
fprintf(gr->fp, ".optional { stroke-dasharray: 5; }\n");
fprintf(gr->fp, ".arrow { fill: rgba(0, 0, 0, 0.2); "
"stroke: none; }\n");
}
fprintf(gr->fp, "</style>\n");
gr->started = true;
}
/* Logical coordinates in our mathematical space */
GrCoords gr_logcoords(Point p)
{
double rt3o2 = sqrt(3) / 2;
GrCoords r = {
p.coeffs[0] + rt3o2 * p.coeffs[1] + 0.5 * p.coeffs[2],
p.coeffs[3] + rt3o2 * p.coeffs[2] + 0.5 * p.coeffs[1],
};
return r;
}
/* Physical coordinates in the output image */
GrCoords gr_log2phys(Graphics *gr, GrCoords c)
{
c.x = gr->xoff + gr->xscale * c.x;
c.y = gr->yoff + gr->yscale * c.y;
return c;
}
GrCoords gr_physcoords(Graphics *gr, Point p)
{
return gr_log2phys(gr, gr_logcoords(p));
}
void gr_draw_text(Graphics *gr, GrCoords logpos, double logheight,
const char *text)
{
GrCoords pos;
double height;
if (!gr)
return;
gr_ensure_started(gr);
pos = gr_log2phys(gr, logpos);
height = gr->absscale * logheight;
fprintf(gr->fp, "<text style=\"font-size: %fpx\" x=\"%f\" y=\"%f\">"
"%s</text>\n", height, pos.x, pos.y + 0.35 * height, text);
}
void gr_draw_path(Graphics *gr, const char *classes, const GrCoords *phys,
size_t n, bool closed)
{
size_t i;
if (!gr)
return;
gr_ensure_started(gr);
fprintf(gr->fp, "<path class=\"%s\" d=\"", classes);
for (i = 0; i < n; i++) {
GrCoords c = phys[i];
if (i == 0)
fprintf(gr->fp, "M %f %f", c.x, c.y);
else if (gr->arcs)
fprintf(gr->fp, "A %f %f 10 0 %zu %f %f",
gr->absscale, gr->absscale, i&1, c.x, c.y);
else
fprintf(gr->fp, "L %f %f", c.x, c.y);
}
if (gr->arcs) {
/* Explicitly return to the starting point so as to curve the
* final edge */
fprintf(gr->fp, "A %f %f 10 0 0 %f %f",
gr->absscale, gr->absscale, phys[0].x, phys[0].y);
}
if (closed)
fprintf(gr->fp, " z");
fprintf(gr->fp, "\"/>\n");
}
void gr_draw_blob(Graphics *gr, const char *classes, GrCoords log,
double logradius)
{
GrCoords centre;
if (!gr)
return;
gr_ensure_started(gr);
centre = gr_log2phys(gr, log);
fprintf(gr->fp, "<circle class=\"%s\" cx=\"%f\" cy=\"%f\" r=\"%f\"/>\n",
classes, centre.x, centre.y, gr->absscale * logradius);
}
void gr_draw_hex(Graphics *gr, unsigned index, Hex htype,
const Point *vertices)
{
size_t i;
Point centre;
if (!gr)
return;
gr_ensure_started(gr);
/* Draw the actual hexagon, in its own colour */
if (!gr->jigsaw_mode) {
GrCoords phys[6];
for (i = 0; i < 6; i++)
phys[i] = gr_physcoords(gr, vertices[i]);
gr_draw_path(gr, (index == 7 && htype == NO_HEX ?
"optional" : hex_names[htype]), phys, 6, true);
} else {
GrCoords phys[66];
size_t pos = 0;
const struct HexData *hd = &hexdata[htype];
for (i = 0; i < 6; i++) {
int edge_type = hd->edges[i];
int sign = edge_type < 0 ? -1 : +1;
int edge_abs = abs(edge_type);
int left_sign = (edge_abs & 4) ? sign : edge_type == 0 ? +1 : 0;
int mid_sign = (edge_abs & 2) ? sign : 0;
int right_sign = (edge_abs & 1) ? sign : edge_type == 0 ? -1 : 0;
GrCoords start = gr_physcoords(gr, vertices[i]);
GrCoords end = gr_physcoords(gr, vertices[(i+1) % 6]);
GrCoords x = { (end.x - start.x) / 7, (end.y - start.y) / 7 };
GrCoords y = { -x.y, +x.x };
#define addpoint(X, Y) do { \
GrCoords p = { \
start.x + (X) * x.x + (Y) * y.x, \
start.y + (X) * x.y + (Y) * y.y, \
}; \
phys[pos++] = p; \
} while (0)
if (sign < 0) {
int tmp = right_sign;
right_sign = left_sign;
left_sign = tmp;
}
addpoint(0, 0);
if (left_sign) {
addpoint(1, 0);
addpoint(2, left_sign);
addpoint(2, 0);
}
if (mid_sign) {
addpoint(3, 0);
addpoint(3, mid_sign);
addpoint(4, mid_sign);
addpoint(4, 0);
}
if (right_sign) {
addpoint(5, 0);
addpoint(5, right_sign);
addpoint(6, 0);
}
#undef addpoint
}
gr_draw_path(gr, hex_names[htype], phys, pos, true);
}
/* Find the centre of the hex */
for (i = 0; i < 4; i++)
centre.coeffs[i] = 0;
for (i = 0; i < 6; i++)
centre = point_add(centre, vertices[i]);
for (i = 0; i < 4; i++)
centre.coeffs[i] /= 6;
/* Draw an arrow towards vertex 0 of the hex */
if (gr->hex_arrows) {
double ext = 0.6;
double headlen = 0.3, thick = 0.08, headwid = 0.25;
GrCoords top = gr_physcoords(gr, vertices[0]);
GrCoords bot = gr_physcoords(gr, vertices[3]);
GrCoords mid = gr_physcoords(gr, centre);
GrCoords base = { mid.x + ext * (bot.x - mid.x),
mid.y + ext * (bot.y - mid.y) };
GrCoords tip = { mid.x + ext * (top.x - mid.x),
mid.y + ext * (top.y - mid.y) };
GrCoords len = { tip.x - base.x, tip.y - base.y };
GrCoords perp = { -len.y, +len.x };
GrCoords basep = { base.x+perp.x*thick, base.y+perp.y*thick };
GrCoords basen = { base.x-perp.x*thick, base.y-perp.y*thick };
GrCoords hbase = { tip.x-len.x*headlen, tip.y-len.y*headlen };
GrCoords headp = { hbase.x+perp.x*thick, hbase.y+perp.y*thick };
GrCoords headn = { hbase.x-perp.x*thick, hbase.y-perp.y*thick };
GrCoords headP = { hbase.x+perp.x*headwid, hbase.y+perp.y*headwid };
GrCoords headN = { hbase.x-perp.x*headwid, hbase.y-perp.y*headwid };
GrCoords phys[] = {
basep, headp, headP, tip, headN, headn, basen
};
gr_draw_path(gr, "arrow", phys, lenof(phys), true);
}
/*
* Label the hex with its index and type.
*/
if (gr->number_cells) {
char buf[64];
if (index == (unsigned)-1) {
if (htype == NO_HEX)
buf[0] = '\0';
else
strcpy(buf, hex_names[htype]);
} else {
if (htype == NO_HEX)
sprintf(buf, "%u", index);
else
sprintf(buf, "%u (%s)", index, hex_names[htype]);
}
if (buf[0])
gr_draw_text(gr, gr_logcoords(centre), 1.2, buf);
}
}
void gr_draw_spectre(Graphics *gr, Hex container, unsigned index,
const Point *vertices)
{
size_t i;
GrCoords log[14];
GrCoords centre;
if (!gr)
return;
gr_ensure_started(gr);
for (i = 0; i < 14; i++)
log[i] = gr_logcoords(vertices[i]);
/* Draw the actual Spectre */
{
GrCoords phys[14];
char class[16];
for (i = 0; i < 14; i++)
phys[i] = gr_log2phys(gr, log[i]);
if (gr->four_colour) {
sprintf(class, "c%u", index);
} else if (index == 1 && container == NO_HEX) {
sprintf(class, "optional");
} else {
sprintf(class, "%s%.0u", hex_names[container], index);
}
gr_draw_path(gr, class, phys, 14, true);
}
/* Pick a point to use as the centre of the Spectre for labelling */
centre.x = (log[5].x + log[6].x + log[11].x + log[12].x) / 4;
centre.y = (log[5].y + log[6].y + log[11].y + log[12].y) / 4;
/*
* Label the hex with its index and type.
*/
if (gr->number_cells && index != (unsigned)-1) {
char buf[64];
sprintf(buf, "%u", index);
gr_draw_text(gr, centre, 1.2, buf);
}
}
void gr_draw_spectre_from_coords(Graphics *gr, SpectreCoords *sc,
const Point *vertices)
{
Hex h;
unsigned index;
if (!gr)
return;
gr_ensure_started(gr);
if (gr->four_colour) {
h = NO_HEX;
if (sc->index == 1)
index = 3; /* special colour for odd G1 Spectres */
else
index = sc->hex_colour;
} else if (sc) {
h = sc->c[0].type;
index = sc->index;
} else {
h = NO_HEX;
index = -1;
}
gr_draw_spectre(gr, h, index, vertices);
}
void gr_draw_extra_edge(Graphics *gr, Point a, Point b)
{
GrCoords phys[2];
if (!gr)
return;
gr_ensure_started(gr);
phys[0] = gr_physcoords(gr, a);
phys[1] = gr_physcoords(gr, b);
gr_draw_path(gr, "extraedge", phys, 2, false);
}