/* op --- Op-art generator 1999-08-04 */

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

/* Inspired by an article in Personal Computer World magazine,

* volume 5 number 4 April 1982, page 134. An article called

* "Patterns" by Alan Sutcliffe. Originally in FORTRAN, the

* program was converted to BASIC for the magazine.

*/

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

#include <time.h>

/* Takes about 28 minutes to plot on DPX-3300 at A1 */

#define A3

#define YES (1)

#define NO (0)

int Devxmin, Devymin;

int Devxmax, Devymax;

static enum {GR_PS, GR_HPGL, GR_BMC} GraphDev = GR_HPGL;

struct pt {

int x;

int y;

};

struct CoOrd {

double x;

double y;

};

void drawbox(const int row, const int col, const struct CoOrd param[4], const double step, const double width);

void drawtri(const int row, const int col, const int ineg, struct CoOrd nbox[5], const double zd);

void drawpoly(const struct CoOrd *const box, const int nsides);

int shrink(const struct CoOrd *box, struct CoOrd *nbox, const double zd, const int nsides, int *const ineg);

double rnd(void);

int OpenGraph(void);

void CloseGraph(void);

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

{

#ifdef A1

int nrows = 12;

int ncols = 18;

#else

int nrows = 6; /* A4: 9, A3: 12 */

int ncols = 8; /* A4: 9, A3: 18 */

#endif

double step = 2.0;

int maxx = ncols + 1;

int maxy = nrows + 1;

int size = 40; /* Size of boxes, in mm */

struct CoOrd grid[30][30];

struct CoOrd box[4];

double x, y;

double r;

int row, col;

int ix, iy;

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

if (OpenGraph() == NO) {

fprintf(stderr, "Could not start up graphics\n");

exit(EXIT_FAILURE);

}

printf("SP1;PU;PA%d,%d\n", Devxmin + (10 * 40), Devymin + (10 * 40));

printf("DR0,1;\n");

// printf("LBhttp://www.dorkbot.org/dorkbotbristol%c;\n", 3);

printf("LBBristol Hackspace%c;\n", 3);

/* Build the regular grid */

for (ix = 0; ix < maxx; ix++) {

for (iy = 0; iy < 2; iy++) {

x = (double)(ix + 1);

y = (double)iy;

grid[ix][iy].x = x * size;

grid[ix][iy].y = y * size;

}

}

/* Build the randomised grid */

for (ix = 0; ix < maxx; ix++) {

for (iy = 2; iy < maxy; iy++) {

x = (double)(ix + 1);

y = (double)iy;

r = (y / (double)maxy) * size;

grid[ix][iy].x = (x * size) - ((rnd () - 0.5) * r);

grid[ix][iy].y = (y * size) - ((rnd () - 0.5) * r);

}

}

/* Loop over the grid, drawing the boxes */

for (row = 0; row < nrows; row++) {

for (col = 0; col < ncols; col++) {

box[0] = grid[col][row];

box[1] = grid[col][row+1];

box[2] = grid[col+1][row+1];

box[3] = grid[col+1][row];

drawbox(row, col, box, step, 2.0 - ((double)row / (double)nrows));

}

}

CloseGraph();

return (0);

}

/* drawbox --- draw a single four-sided box */

void drawbox(const int row, const int col, const struct CoOrd param[4], const double step, const double width)

{

int i;

struct CoOrd box[6], nbox[5];

int nneg;

int ineg;

double zd;

if (GraphDev == GR_PS)

printf("%f setlinewidth\n", width);

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

box[i] = param[i];

}

box[4] = box[0];

box[5] = box[1];

drawpoly(box, 4); /* Draw boxes */

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

zd = (i + 1) * step;

nneg = shrink(box, nbox, zd, 4, &ineg);

if (nneg > 0)

break;

drawpoly(nbox, 4); /* Draw smaller boxes */

}

if (nneg == 1)

drawtri(row, col, ineg, nbox, step);

}

/* drawtri --- draw boxes when reduced to three sides */

void drawtri(const int row, const int col, const int ineg, struct CoOrd nbox[5], const double zd)

{

int i, j;

double m1, c1, m2, c2;

struct CoOrd box[6];

int nneg, junk;

/* Copy co-ords of "good" side */

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

j = (ineg + 2 + i) % 4;

box[i] = nbox[j];

}

/* Avoid division-by-zero */

if (box[1].y == box[2].y) {

box[1].y += 0.001;

#ifdef DB

fputs("Tilt 1\n", stderr);

#endif

}

/* Find equation of line [2] - [1] */

m1 = (box[2].x - box[1].x) / (box[1].y - box[2].y);

c1 = -box[1].x - (m1 * box[1].y);

/* Avoid division-by-zero */

if (box[0].y == box[3].y) {

box[0].y += 0.001;

#ifdef DB

fputs("Tilt 2\n", stderr);

#endif

}

/* Find equation of line [0] - [3] */

m2 = (box[0].x - box[3].x) / (box[3].y - box[0].y);

c2 = -box[0].x - (m2 * box[0].y);

/* If gradients are equal, lines are parallel */

if (fabs(m2 - m1) < 0.00001)

return;

/* Find point of intersection */

nbox[2].y = (c1 - c2) / (m2 - m1);

nbox[2].x = (-m1 * nbox[2].y) - c1;

nbox[0] = box[0];

nbox[1] = box[1];

#ifdef DB

fprintf(stderr, "(%d,%d): tri%d: (%.1f,%.1f) (%.1f,%.1f) (%.1f,%.1f)\n", row, col, ineg, nbox[0].x, nbox[0].y, nbox[1].x, nbox[1].y, nbox[2].x, nbox[2].y);

printf("SP2;PU;PA%d,%d;PD;PA%d,%d,%d,%d,%d,%d;SP1;\n", (int)(nbox[0].x * 40.0), (int)(nbox[0].y * 40.0), (int)(nbox[1].x * 40.0), (int)(nbox[1].y * 40.0), (int)(nbox[2].x * 40.0), (int)(nbox[2].y * 40.0), (int)(nbox[0].x * 40.0), (int)(nbox[0].y * 40.0));

#endif

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

box[i] = nbox[i];

}

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

box[3] = box[0];

box[4] = box[1];

drawpoly(box, 3); /* Draw triangles */

nneg = shrink(box, nbox, zd, 3, &junk);

if (nneg > 0) {

#ifdef DB

fprintf(stderr, "tri: row %d, col %d, %d neg sides\n", row, col, nneg);

#endif

return;

}

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

box[j] = nbox[j];

}

}

}

/* drawpoly --- draw a polygon, given corner co-ords */

void drawpoly(const struct CoOrd *const box, const int nsides)

{

int i;

int ix, iy;

switch (GraphDev) {

case GR_PS:

printf("newpath %.2f %.2f moveto\n", box[0].x, box[0].y);

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

printf("%.2f %.2f lineto\n", box[i].x, box[i].y);

printf("closepath stroke\n");

break;

case GR_HPGL:

ix = Devxmin + (int)(box[0].x * 40.0);

iy = Devymin + (int)(box[0].y * 40.0);

printf("PU;PA%d,%d;PD;PA", ix, iy);

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

ix = Devxmin + (int)(box[i].x * 40.0);

iy = Devymin + (int)(box[i].y * 40.0);

printf("%d,%d", ix, iy);

if (i < nsides)

printf(",");

}

printf(";\n");

break;

case GR_BMC:

break;

}

}

/* shrink --- make a smaller polygon inside a larger one */

int shrink(const struct CoOrd *box, struct CoOrd *nbox, const double zd, const int nsides, int *const ineg)

{

struct CoOrd d[5];

double len[5];

double tst, xyd;

double t1, t2;

int nneg = 0;

int i;

/* Calculate side lengths */

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

d[i].x = box[i].x - box[i+1].x;

d[i].y = box[i].y - box[i+1].y;

len[i] = sqrt ((d[i].x * d[i].x) + (d[i].y * d[i].y));

}

/* Allow for wrap-around */

d[nsides] = d[0];

len[nsides] = len[0];

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

do {

tst = (d[i].x * d[i+1].y) - (d[i+1].x * d[i].y);

if (tst == 0.0) {

d[i].x += 0.001;

d[i].y += 0.001;

d[i+1].x += 0.001;

d[i+1].y += 0.001;

#ifdef DB

fprintf(stderr, "(%d,%d): tst = %f, d[%d].x=%f, d[i+1].y=%f, d[i].y=%f\n", row, col, tst, i, d[i].x, d[i+1].y, d[i].y);

#endif

}

} while (tst == 0.0);

xyd = zd / tst;

nbox[i].x = box[i+1].x -

(d[i].x * len[i+1] - d[i+1].x * len[i]) * xyd;

nbox[i].y = box[i+1].y -

(d[i].y * len[i+1] - d[i+1].y * len[i]) * xyd;

}

/* Allow for wrap-around again */

nbox[nsides] = nbox[0];

/* Count negative sides */

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

t1 = (nbox[i+1].x - nbox[i].x);

t2 = (box[i+2].x - box[i+1].x);

if ((fabs(t1) < 0.00001) || (fabs(t2) < 0.00001)) {

t1 = (nbox[i+1].y - nbox[i].y);

t2 = (box[i+2].y - box[i+1].y);

}

tst = t1 / t2;

if (tst < 0.0) {

#ifdef DB

fprintf(stdout, "t1=%f, t2=%f, tst=%f\n", t1, t2, tst);

#endif

nneg++;

*ineg = i;

}

}

#ifdef DB

if (nneg > 0)

fprintf(stdout, "%d neg sides\n", nneg);

#endif

return (nneg);

}

/* rnd --- simulate BASIC's rnd */

double rnd(void)

{

return ((double)rand() / (double)RAND_MAX);

}

int OpenGraph(void)

{

switch (GraphDev) {

case GR_PS:

Devxmin = 0;

Devymin = 0;

Devxmax = 639;

Devymax = 479;

printf("%%!PS-Adobe2.0\n");

printf("%%%%Creator: op\n");

printf("%%%%EndComments\n");

printf("%%%%EndProlog\n");

printf("%% begin page\n");

printf("0 setgray\n");

break;

case GR_HPGL:

#ifdef A1

Devxmin = -15970; /* A1 in DPX-3300 */

Devymin = -10870;

Devxmax = 15970;

Devymax = 10870;

#else

Devxmin = 0;

Devymin = 0;

/* Devxmax = 10870; * A4 in HP7550A */

/* Devymax = 7600; */

Devxmax = 15970; /* A3 in HP7550A */

Devymax = 10870;

#endif

printf("IN;\n");

printf("SP1;\n");

/* printf("VS10;\n"); */

printf("PU;PA%d,%d;PD;\n", Devxmin, Devymin);

printf("PA%d,%d;\n", Devxmin, Devymax);

printf("PA%d,%d;\n", Devxmax, Devymax);

printf("PA%d,%d;\n", Devxmax, Devymin);

printf("PA%d,%d;\n", Devxmin, Devymin);

break;

case GR_BMC:

Devxmin = 0;

Devymin = 0;

Devxmax = 3799 / 2;

Devymax = 2549 / 2;

printf("IP1;\n"); /* GDU mode */

printf("MA%d,%d;PS1;\n", Devxmin, Devymin);

printf("DA%d,%d;\n", Devxmin, Devymax);

printf("DA%d,%d;\n", Devxmax, Devymax);

printf("DA%d,%d;\n", Devxmax, Devymin);

printf("DA%d,%d;\n", Devxmin, Devymin);

break;

default:

return (NO);

break;

}

return (YES);

}

void CloseGraph(void)

{

switch (GraphDev) {

case GR_PS:

printf("showpage\n");

printf("%%%%Trailer\n");

break;

case GR_HPGL:

printf("PU;PA%d,%d;\n", Devxmin, Devymin);

printf("SP0;\n");

break;

case GR_BMC:

printf("MA%d,%d;CH;\n", Devxmin, Devymin);

break;

}

}