I'm working on a sketch to implement frieze groups as a class, with the class containing methods for each of the frieze transformations.  This would allow me to easily generate many, many variations of freeze patterns based off of the seven simple transformations.

(For more information about Frieze Groups, check out the wikipedia page -- http://en.wikipedia.org/wiki/Frieze_group)

I wrote up a version using the code below, and it works -- except for the last transformation, spin_sidle().



spin_sidle() is the last line. 

It should look like: \/ /\ \/ /\ \/ /\ \/ /\ \/ /\ \/ /\ \/ /\

but, as you can see, the spacing isn't quite right.  The rotations get very tricky around here, because when you rotate by PI, translating forwards actually moves the image *backwards* down the line -- and I believe this is the root of my problem.  However, I haven't found a neat, elegant solution to it yet.

Anyone have suggestions for how to implement spin_sidle elegantly?  (I'll also take suggestions for implementing the others!)

code below:

1. //-----------------Globals
2. Frieze freeze = new Frieze(25.0, 50.0);
3. float ycounter = 0;
4. //-----------------Setup
5. void setup() {
6.   size(1000, 800, P2D);
7.   background(0);
8.   stroke(255);
9.   noFill();
10.   smooth();
11.   strokeWeight(3);
12.   translate(0,freeze.cell_height);
13.   for (int i = 0; i < 40; i++) {
14.     freeze.hop();
15.   }
16.   translate(0, 2.0*freeze.cell_height);
17.   freeze.current_pos = 0;
18.   for (int i = 0; i <= 40; i++) {
19.     freeze.step();
20.   }
21.   translate(0, 2.0*freeze.cell_height);
22.   freeze.current_pos = 0;
23.   for (int i = 0; i <= 40; i++) {
24.     freeze.jump();
25.   }
26.   translate(0, 2.0*freeze.cell_height);
27.   freeze.current_pos = 0;
28.   for (int i = 0; i <= 40; i++) {
29.     freeze.sidle();
30.   }
31.   translate(0, 2.0*freeze.cell_height);
32.   freeze.current_pos = 0;
33.   for (int i = 0; i <= 40; i++) {
34.     freeze.spin_hop();
35.   }
36.   translate(0, 2.0*freeze.cell_height);
37.   freeze.current_pos = 0;
38.   for (int i = 0; i <= 40; i++) {
39.     freeze.spin_jump();
40.   }
41.   translate(0, 2.0*freeze.cell_height);
42.   freeze.current_pos = 0;
43.   for (int i = 0; i <= 40; i++) {
44.     freeze.spin_sidle();
45.   }
46. }
47. //-----------------Defined Classes
48. class Frieze {
49.   float cell_height;
50.   float cell_width;
51.   float current_pos;
52.   int current_scale = 1;
53.   float current_angle;
54.   Frieze(float cell_width, float cell_height) {
55.     this.cell_height = cell_height;
56.     this.cell_width = cell_width;
57.   }
58.   void primitive() {
59.     /*This is the primitive cell and should be added by extending this class*/
60.     line(-this.cell_width/2, -this.cell_height/2, this.cell_width/2, this.cell_height/2);
61.     //line(0, 0, -this.cell_width/2, this.cell_height/2);
62.     ellipse(-this.cell_width/2,-this.cell_height/2,cell_height/2,cell_height/2);
63.   }
64.   void hop() {
65.     pushMatrix();
66.     translate(this.cell_width/2, this.cell_height/2);
67.     /*Just a translation along the x-axis*/
68.     this.current_pos += this.cell_width;
69.     //move over to next cell
70.     translate(this.current_pos, 0);
71.     //draw primitive shape
72.     primitive();
73.     popMatrix();
74.   }
75.   void step() {
76.     pushMatrix();
77.     translate(this.cell_width/2, this.cell_height/2);
78.     /*Translation + reflection across horizontal axis (glide)*/
79.     this.current_pos += this.cell_width;
80.     this.current_scale *= -1;
81.     //move over to next cell
82.     translate(this.current_pos, 0);
83.     //mirror from previous step
84.     scale(1, this.current_scale);
85.     //draw primitive shape
86.     primitive();
87.     popMatrix();
88.   }
89.   void jump() {
90.     pushMatrix();
91.     translate(this.cell_width/2, this.cell_height/2);
92.     /*Horizontal Reflection + Translation*/
93.     this.current_pos += this.cell_width;
94.     translate(this.current_pos, 0);
95.     primitive();
96.     scale(1, -1);
97.     primitive();
98.     popMatrix();
99.   }
100.   void sidle() {
101.     pushMatrix();
102.     translate(this.cell_width/2, this.cell_height/2);
103.     /*Vertical Reflection + Translation*/
104.     this.current_pos += this.cell_width;
105.     translate(this.current_pos, 0);
106.     primitive();
107.     this.current_pos += this.cell_width;
108.     translate(this.cell_width, 0);
109.     scale(-1, 1);
110.     primitive();
111.     popMatrix();
112.   }
113.   void spin_hop() {
114.     pushMatrix();
115.     translate(this.cell_width/2, this.cell_height/2);
116.     /*Just a translation along the x-axis*/
117.     this.current_pos += this.cell_width;
118.     this.current_angle += PI;
119.     //move over to next cell
120.     translate(this.current_pos, 0);
121.     rotate(this.current_angle);
122.     //draw primitive shape
123.     primitive();
124.     popMatrix();
125.   }
126.   void spin_jump() {
127.     pushMatrix();
128.     translate(this.cell_width/2, this.cell_height/2);
129.     /*Horizontal Reflection + Translation*/
130.     this.current_pos += this.cell_width;
131.     this.current_angle += PI;
132.     translate(this.current_pos, 0);
133.     rotate(this.current_angle);
134.     primitive();
135.     scale(1, -1);
136.     primitive();
137.     popMatrix();
138.   }
139.   void spin_sidle() {
140.     pushMatrix();
141.     translate(this.cell_width/2, this.cell_height/2);
142.     /*Vertical Reflection + Translation*/
143.     this.current_pos += this.cell_width;
144.     this.current_angle += PI;
145.     if(this.current_angle % TWO_PI != 0) {
146.       translate(this.current_pos + this.cell_width, 0);
147.     }
148.     else {
149.       translate(this.current_pos,0);
150.     }
151.     rotate(this.current_angle);
152.     primitive();
153.     this.current_pos += this.cell_width;
154.     translate(this.cell_width, 0);
155.     scale(-1, 1);
156.     primitive();
157.     popMatrix();
158.   }
159. }