postscript programming regular polygon with diagonals

Question

First of all, I would like to tell You, I have really limited time. So i would appricate every help with that task.

I have to draw a regular polygon with every diagonal.

( attached file: http://s30.postimg.org/5m6cvd7u9/polygon_with_all_diagonal.png )

Could someone help me with this?

Edit:

Please check scource code:

300 200 translate
/S 28 def
S S scale
4 S div setlinewidth
1 setlinecap
1 setlinejoin

/n 5 def
/r 5 def

newpath
r 0 moveto
1 1 n 1 sub
{
    /i exch def
    360 n div i mul cos r mul 
    360 n div i mul sin r mul lineto
} for
closepath
stroke

Thats all what i could do, i have no more idea, how to draw the diagonals.

Answer 1

Arguably a more fitting description of the problem is that you are trying to draw a fully connected graph.

The [Wikipedia-entry on PostScript][http://en.wikipedia.org/wiki/PostScript#Units_of_length] reveals a simple procedure that can be used to solve your problem:

For example, in order to draw a vertical line of 4 cm length, it is
sufficient to type:

0 0 moveto
0 113.385827 lineto stroke

Observe that the above sample can be easily adapted to draw any line; that is, it does not necessarily have to be a vertical line. Now, for each vertex of your polygon draw a line to every other vertex.

---

Knowing that the polar coordinates of the vertices of a n-polygon will be (rad,i(2π/n)) for i=0..n-1, you can generate the postscript code to describe a polygon path from another language, like C.

#include <math.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

void emitpoly (double x, double y, int n, double r, int up) {
    int i;
    double a;
    printf("%f %f moveto\n", x+r*cos(up?M_PI/2.0:0.0), y+r*sin(up?M_PI/2.0:0.0));
    for(i=1; i<n; i++){
        a=(double)i*(2*M_PI)/n;
        if (up) a += M_PI/2.0;
        printf("%f %f lineto\n", x+r*cos(a), y+r*sin(a));
    }
    printf("stroke\n");
}

void emitpolyweb (double x, double y, int n, double r, int up) {
    int i,j;
    double a,b;
    for(i=0; i<n; i++){
        a=(double)i*(2*M_PI)/n;
        if (up) a += M_PI/2.0;
        printf("%f %f moveto\n", x+r*cos(a), y+r*sin(a));
        for(j=0; j<n; j++){
            b=(double)j*(2*M_PI)/n;
            if (up) b += M_PI/2.0;
            printf("%f %f lineto\n", x+r*cos(b), y+r*sin(b));
            printf("closepath\n");
        }
    }
    printf("stroke\n");
}

int main(int argc, char**argv) {
    int up = 0, n = 3;
    double x = 0.0, y = 0.0, r = 1.0;
    if (argc>1) x = strtod(argv[1],NULL);    // set x from 1st arg, if present
    if (argc>2) y = strtod(argv[2],NULL);    // set y from 2nd arg, if present
    if (argc>3) n = strtol(argv[3],NULL,10); // set n from 3rd arg, if present
    if (argc>4) r = strtod(argv[4],NULL);    // set r from 4th arg, if present
    if (argc>5) up = strcmp(argv[5],"up") == 0;  // rotate 90-degrees if 5th arg is "up"

    //emitpoly(x,y,n,r,up);
    emitpolyweb(x,y,n,r,up);
    printf("showpage\n");
    return 0;
}

Answer 2

Cutting and pasting from my other graph drawing routines I get something like this (there is a bit of redundant code but that's because one may want to make the adjacency list on your own):

% routines

/ngon{ [ exch 360 exch div 
       0 exch 359.9 { 
       [ exch dup cos 40 mul exch sin 40 mul ]
       } for 
     ]
    } def

/fmtrx {[ 0 1 4 3 roll 1 sub  { [ 1 1 4 3 roll {pop 1} for ] } for ]} def


/drawnodelist { % nodes drawnodelist
  { 
    newpath aload pop 2.5 0 360 arc closepath fill 
  } forall 
} def

/drawedges { % adjacency_matrix nodes drawedges
  /drawnodes exch def
  dup
  /drawlist exch def
  /row 0 def
  { 
    /col 0 def
    {
        pop
        drawlist row get col get 1 eq 
        {
            newpath
            drawnodes row get aload pop moveto
            drawnodes col get aload pop lineto stroke
        } if
        /col col 1 add def
    } forall 
    /row row 1 add def
  } forall 
} def

/drawngon {
    dup /polygon exch ngon def
    polygon drawnodelist % remove this line if you do not want dots
    fmtrx polygon drawedges
} def

% call routines

90 rotate
6 drawngon

Here is a sample of different connected polygons produced:

Answer 3

Here is my take:

/n 7 def            % number of sides
/R 100 def          % radius of circumscribed circle

R 2 mul dup translate

/A 360 n div def

% point given index
/P {
    A mul dup
    cos R mul
    exch
    sin R mul
} bind def

0 1 n 1 sub {
    dup P 3 2 roll
    1 add 1 n 1 sub {
        P moveto 2 copy lineto stroke
    } for
    pop pop
} for
showpage

Answer 4

I came up with some results in this area while playing with venn diagrams, and further in geodesic flowers.

This code implements the polygon as a control structure which takes a radius and a repeat count (number of polygon points) and calls the user-defined procedure at each point (by scaling and rotating the CTM). So it's a loop, that makes the user point (1,0) map to successive points of the polygon for each iteration. Using this function, the figure itself is fairly simple. Being a control structure, it is not limited to drawing polygons but can also be used to position smaller drawings at the vertices of a polygon, or even to generate an array of vertex points.

Note also, that this code doesn't have to call sin or cos, because that is handled by rotating the coordinate system. The big trick here is using the scanner to produce an optimized loop body (procedure array).

After placing the init incr max control values on the stack for the for loop, it performs ({...}) token pop exch pop bind end exec which dynamically creates a procedure and executes the call to for. token called (successfully) on a string will yield several values on the stack: an empty string, the scanned-token itself (a ps object of the appropriate type), and the Boolean true. So the pop exch pop just trims the Boolean and the empty string. bind then replaces operator names with the operators themselves, so we perform fewer hash-lookups during the loop. Then end removes our temporary dictionary, before execing the procedure.

This works because all of the variables have been directly substituted by the token operator since they are written as //immediate-names and the temporary dictionary is available on the dict stack when token does this. Removing the dict makes this a true control structure that will not interfere with the meaning of any names used by the user-proc, even if it uses names like s, p, and m.

The generated procedure body {{//s setmatrix rotate //p exec} for //m setmatrix} has the user proc embedded //p and two matrices, //s a matrix pre-scaled by the rad argument and //m a matrix to restore at the end. The for loop body {//s setmatrix rotate //p exec} receives an angle argument as part of the loop control. It resets the CTM to our scaled, oriented matrix //s setmatrix, then rotates by the argument angle rotate, then executes the user-proc //p exec.

%rad n {proc}  atpoly  -
%call proc having rotated+scaled
%so (1,0) is each vertex of rad-radius n-polygon
/atpoly {
    4 dict begin /p exch def /n exch def % rad 
    /m matrix currentmatrix def 
    dup scale
    /s matrix currentmatrix def 
    0 360 n div 359.9 %0 dAng maxAng %{}for
    ({
        {
            //s setmatrix
            rotate
            //p exec
        } for 
        //m setmatrix
    }) token pop exch pop %instantiate code template
    bind
    end exec % run loop without dictionary
} bind def 

300 400 translate
/rad 100 def 
/n 9 def 

rad n { 
    1 0 moveto
    1 n { 
        1 0 lineto
        closepath
    } atpoly
} atpoly
stroke

To use atpoly, we have to translate to the desired center-point. Then the pseudo-code is:

for each point in poly
    moveto point
    for each point in poly
        lineto point
        line back to last moveto point (closepath)
stroke

The are at least two ways to draw just the polygon with atpoly. You can add a redundant moveto at the beginning and use lineto in the proc, or you can use a procedure which does moveto the first time and redefines itself to do lineto thereafter. Here's a variant of the script part that shows both ways, and the interconnected poly.

/rad 100 def 
/n 9 def 

gsave
    400 200 translate
    rad n { 
        1 0 moveto
        1 n { 
            1 0 lineto
            closepath
        } atpoly
    } atpoly
    stroke
grestore

gsave
    200 200 translate
    rad 0 moveto
    rad n { 
        1 0 lineto
    } atpoly
    closepath stroke
grestore

gsave
    200 400 translate
    /action { moveto /action { lineto } def } def 
    rad n { 
        1 0 action
    } atpoly
    closepath stroke
grestore

output:

I suppose these blocks could be wrapped up as procedures. These still require the atpoly function from above.

/drawpoly { % rad n x y
    gsave
        translate 
        1 index 0 moveto
        {
            1 0 lineto
        } atpoly
        closepath stroke
    grestore
} def

% rad and n are needed in the outer call to atpoly,
% then n is needed for each iteration.
% To avoid adding a dictionary, duplicate n n-times.
% Once for each iteration.
/drawpolyweb { % rad n x y
    gsave
        translate      % rad n
        dup            % rad n n
        { dup } repeat % rad n^(n+1)
        1 add          % rad n^n n+1
        -1 roll        % n^n rad
        %pstack() =
        1 index        % n^n rad n
        {
            1 0 moveto  % n^(n-i)
            1 exch      % n^(n-i-1)  1 n
            {
                1 0 lineto
                closepath
            } atpoly
        } atpoly
        stroke
    grestore
} def

Then the usage becomes simpler:

%rad n  x   y
 100 9 300 200 drawpoly

 100 9 300 500 drawpolyweb