/* morphpoly --- plot a morphed polygon 2016-11-03 */

/* Copyright (c) 2016 John Honniball, Froods Software Development */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <math.h>

#include <unistd.h>

#include <time.h>

#include "hpgllib.h"

/* Inspired by Manfred Mohr's "Lady Quark" of 1972, seen in */

/* figure 1.3 of "Generative Art" by Matt Pearson, ISBN 1935182625 */

// #define LADY_QUARK

struct Vertex {

double x;

double y;

};

int generate2polygons(const double radius, const double angle, const int nsides, const int nsubdiv, struct Vertex outer[], struct Vertex inner[]);

void splitside(const struct Vertex v1, const struct Vertex v2, const int nsubdiv, struct Vertex *result);

void morphpolygon(const double xc, const double yc, const int nsides, const struct Vertex inner[], const struct Vertex outer[], const int nsteps);

void drawpoly(const int nsides, const double xc, const double yc, const struct Vertex vertex[]);

int main(int argc, char * const argv[])

{

int opt;

int nsides;

double radius;

#ifdef LADY_QUARK

int x, y;

double xc, yc;

double w3, h3;

#else

double w4, h4;

#endif

double maxx, maxy;

struct Vertex inner[64], outer[64];

while ((opt = getopt(argc, argv, "no:p:s:t:v:")) != -1) {

switch (opt) {

case 's':

case 'n':

case 'o':

case 'p':

case 't':

case 'v':

plotopt(opt, optarg);

break;

default: /* '?' */

fprintf(stderr, "Usage: %s [-p pen] [-s <size>] [-t title]\n", argv[0]);

fprintf(stderr, " <size> ::= A1 | A2 | A3 | A4 | A5\n");

exit(EXIT_FAILURE);

}

}

srand((unsigned int)time(NULL));

if (plotbegin(1) < 0) {

fputs("Failed to initialise HPGL library\n", stderr);

exit(EXIT_FAILURE);

}

getplotsize(&maxx, &maxy);

#ifdef LADY_QUARK

radius = (maxy / 3.0) / sqrt(2.0);

w3 = maxx / 3.0;

h3 = maxy / 3.0;

for (y = 0; y < 3; y++) {

yc = (h3 / 2.0) + (h3 * y);

for (x = 0; x < 3; x++) {

xc = (h3 / 2.0) + (h3 * x) + ((maxx - maxy) / 2.0);

nsides = generate2polygons(radius, M_PI / 4.0, 4, 4, outer, inner);

morphpolygon(xc, yc, nsides, outer, inner, 20);

}

}

#else

radius = maxy / 4.0;

w4 = maxx / 4.0;

h4 = maxy / 4.0;

nsides = generate2polygons(radius, 0.0, 4, 4, outer, inner);

morphpolygon(w4 * 3.0, h4 * 3.0, nsides, outer, inner, 12);

nsides = generate2polygons(radius, 0.0, 5, 4, outer, inner);

morphpolygon(w4, h4 * 3.0, nsides, outer, inner, 12);

nsides = generate2polygons(radius, 0.0, 6, 4, outer, inner);

morphpolygon(w4 * 3.0, h4, nsides, outer, inner, 12);

nsides = generate2polygons(radius, 0.0, 7, 4, outer, inner);

morphpolygon(w4, h4, nsides, outer, inner, 12);

#endif

plotend();

return (0);

}

int generate2polygons(const double radius, const double angle, const int nsides,

const int nsubdiv, struct Vertex outer[],

struct Vertex inner[])

{

const double rad = radius * 0.2;

int i;

const double delta = (2.0 * M_PI) / (double)nsides;

struct Vertex vertex[64];

struct Vertex jiggle;

for (i = 0; i < nsides; i++) {

const double theta = (double)i * delta;

vertex[i].x = cos(theta + angle) * radius;

vertex[i].y = sin(theta + angle) * radius;

}

for (i = 0; i < nsides; i++) {

const int i1 = (i + 1) % nsides;

splitside(vertex[i1], vertex[i], nsubdiv, &outer[i * (nsubdiv + 1)]);

}

for (i = 0; i < (nsides * (nsubdiv + 1)); i++) {

jiggle.x = (((double)rand() / (double)RAND_MAX) * rad) - (rad / 2.0);

jiggle.y = (((double)rand() / (double)RAND_MAX) * rad) - (rad / 2.0);

inner[i].x = (outer[i].x / 3.0) + jiggle.x;

inner[i].y = (outer[i].y / 3.0) + jiggle.y;

}

return (nsides * (nsubdiv + 1));

}

void splitside(const struct Vertex v1, const struct Vertex v2, const int nsubdiv, struct Vertex *result)

{

int i;

for (i = 0; i <= nsubdiv; i++) {

const double p1 = i / (double)nsubdiv;

const double p2 = 1.0 - p1;

result[i].x = (v1.x * p1) + (v2.x * p2);

result[i].y = (v1.y * p1) + (v2.y * p2);

}

}

void morphpolygon(const double xc, const double yc, const int nsides, const struct Vertex outer[], const struct Vertex inner[], const int nsteps)

{

int i, j;

const double delta = 1.0 / nsteps;

struct Vertex vertex[64];

drawpoly(nsides, xc, yc, outer);

for (i = 1; i < nsteps; i++) {

const double innerportion = delta * i;

const double outerportion = delta * (nsteps - i);

for (j = 0; j < nsides; j++) {

vertex[j].x = (outer[j].x * outerportion) + (inner[j].x * innerportion);

vertex[j].y = (outer[j].y * outerportion) + (inner[j].y * innerportion);

}

drawpoly(nsides, xc, yc, vertex);

}

drawpoly(nsides, xc, yc, inner);

}

void drawpoly(const int nsides, const double xc, const double yc, const struct Vertex vertex[])

{

int i;

moveto(xc + vertex[0].x, yc + vertex[0].y);

for (i = 1; i < nsides; i++) {

lineto(xc + vertex[i].x, yc + vertex[i].y);

// circle(xc + vertex[i].x, yc + vertex[i].y, 20.0);

}

lineto(xc + vertex[0].x, yc + vertex[0].y);

}