I don't know what's going wrong, but I find it helpful to use the PeasyCam library to see what's going on in 3D space (located at http://mrfeinberg.com/peasycam/).

yeah, thank you.

Well, the result is so bad, you can see it without peasycam...

Greetings, Chisir

I've found that making animations / controlled movements with Spherical Positioning is generally a complete pain in the ass because it is not that intuitive to work with. You may want to use Matrices instead if you want to practice working with 3D angles. Unfortunately there is probably going to be a little while where you hate them because making sense of them originally really sucks as well, but the advantage is that once you do you can control them with "normal" 3D rotations. For example, rotate x-axis 'a' amount, then rotate y-axis 'b' amount, ect.

thank you very much for your replies everybody.

@ allonestring: Thank you for clarify yaw and pitch.
You wrote

I'd like to stay with the two angles (rotation in a plane and pitch) because that is the way to develop LOGO further.

@ asimes:
how can I use matrices?
Are we talking about quaternions like in

It seems the spherical co-ordinate system is not implemented correctly. As pointed out by  allonestring, in the cartesian co-ordinate system, x = 0, y = 0, and z = 0 all represent plane surfaces. But in the standard spherical co-ordinate system,  r = 0 represents a sphere, theta = 0 represents a plane and phi = 0 represents a cone. You've not used 'r' in the sketch. (It seems you've interchanged theta and phi too from the standard definition). When you've used forward(130), you've updated the position vector correctly, which is in cartesian. But when you've used RI(), you've only updated theta, and not phi. Similarly in noseDown() only phi is updated, not theta. I believe this is the main bug in your sketch.

No, I don't understand Quaternions in the slightest, maybe some day I'll work on learning them. The matrices I mean are 4x4 arrays of numbers set up like this (there also are 2x2 and 3x3 for other purposes):

I am overwhelmed by all your wonderful replies - thank you all so much.

I need some time now to figure it out.

@ Manindra
you wrote:

when you've used RI(), you've only updated theta, and not phi. Similarly in noseDown() only phi is updated, not theta. I
believe this is the main bug in your sketch.

do you happen to know the formulas to do so?

@ amnon.owed

that seems to be a very practical approach for me being not a mathematician...


Thank you all!

Greetings, Chrisir

I disagree with some of the posts given. Your turtle IS moving in Cartesian space; the posTurtle PVector gives the turtle's current X/Y/Z coordinates in Cartesian space, and NOT in spherical coordinates. The turtle's heading and orientation - that is, the direction in which its head is facing - is what's being described in spherical coordinates. When you do a "forward" call, you now have a fully specified 3D vector in spherical form using radius, theta and phi. You now want to convert that vector into Cartesian coordinates in order to add it to posTurtle. This is all fine and good. 

@ hellochar:

[edited: ah, the formula seems correct but it is not stable when I have other initial values than 0 for theta - marked red in the Code ]

that was very helpful

I made Turtle into a class now.

I swapped theta and phi in the formula.

But there's still an error in your formula (marked bold): The cube comes out with weird angles.

Thank you so much!

1. // Turtle from LOGO but in 3D
2. // approach:
3. // reset canvas and all values at beginning from draw, paint a rect and then a cube.
4. //
5. // issue:
6. // works only 2D, not 3D
7. //
8. // to do:
9. // use another approach and push to an arrayList and paint this instead
10. // make Turtle a real class
11. //
12. import peasy.org.apache.commons.math.*;
13. import peasy.*;
14. import peasy.org.apache.commons.math.geometry.*;
15. // Camera
16. PeasyCam cam;
17. Turtle turtle;
18. //
19. void setup() {
20.   size(1444, 1000, P3D);
21.   turtle = new Turtle ();
22.   cam = new PeasyCam(this, 1400);
23. }
24. //
25. void draw() {
26.   // Init
27.   background(255);
28.   turtle.theta = 22;
29.   turtle.phi = 0;
30.   turtle.numMoves=0;
31.   turtle.posTurtle.set( width/2, height/2, 0 );
32.   //
33.   quadRight() ;
34.   turtle.forward (130);
35.   turtle.noseDown(90);
36.   quadRight() ;
37.   turtle.forward (130);
38.   turtle.noseDown(90);
39.   quadRight() ;
40.   turtle.forward (130);
41.   turtle.noseDown(90);
42.   quadRight() ;
43. }
44. // --------------------------------------------------------------------------
45. void quadRight() {
46.   turtle.showTurtle ();
47.   for (int i = 0 ; i<4; i++) {
48.     turtle.forward (130);
49.     turtle.RI (90);
50.     //
51.   } // for
52. } // func
53. void quadLeft() {
54.   turtle.showTurtle ();
55.   for (int i = 0 ; i<4; i++) {
56.     turtle.forward (130);
57.     turtle.LE (90);
58.     //
59.   } // for
60. } // func
61. // ==========================================================================
62. // the Turtle class
63. class Turtle {
64.   //
65.   float theta = 0; // degree / 2D angle of Turtle (left / right)
66.   float phi = 0;   // degree / 3D angle of Turtle (up / down)
67.   boolean penUp = false; // turtle pulls a pen; when the pen moved up, it's not drawing (pen not on the canvas then)
68.   //
69.   int numMoves=0; // just to debug and show, where turtle was going
70.   //
71.   PVector posTurtle = new PVector ();
72.   // constructor
73.   Turtle() {
74.     print ("constructor with width = ");
75.     println(width);
76.     posTurtle.set( width/2, height/2, 0 );
77.   } // constructor
78.   void RI (float angle1) {
79.     // turn RIGHT
80.     theta-=angle1;
81.   } // method
82.   //
83.   void LE (float angle1) {
84.     // turn left
85.     theta+=angle1;
86.   }  // method
87.   //
88.   void noseDown (float angle1) {
89.     phi-=angle1;
90.   }  // method
91.   //
92.   void nosUp (float angle1) {
93.     phi+=angle1;
94.   }  // method
95.   //
96.   void forward (float rad) {
97.     // that's drawing with line
98.     float x;
99.     float y;    
100.     float z;
101.     /*
102.     x = cos(radians(phi))*sin(radians(theta))*(rad);
103.      y = cos(radians(theta))*(rad);
104.      z = sin(radians(phi))*sin(radians(theta))*(rad);
105.      */
106.     //
107.     /*
108.     x = rad*cos(radians(phi))*cos(radians(theta));
109.      y = rad*sin(radians(phi))*cos(radians(theta));
110.      z = rad*sin(radians(theta));*/
111.     x = rad*cos(radians(phi))*cos(radians(theta));
112.     y = rad*sin(radians(phi))*cos(radians(theta));
113.     z = rad*sin(radians(theta));
114.     if (penUp==false) {
115.       stroke(0);
116.       line (posTurtle.x, posTurtle.y, posTurtle.z,
117.       posTurtle.x+x, posTurtle.y+y, posTurtle.z+z );
118.     }
119.     posTurtle.x = posTurtle.x+x ;
120.     posTurtle.y = posTurtle.y+y ;
121.     posTurtle.z = posTurtle.z+z ;
122.     numMoves++;
123.     showTurtle () ;
124.   } // method
125.   //
126.   void showTurtle () {
127.     // small sphere
128.     pushMatrix();
129.     translate ( posTurtle.x, posTurtle.y, posTurtle.z );
130.     fill(255, 0, 0);
131.     noStroke();
132.     sphere(11);
133.     text( numMoves, 20, 0 );
134.     popMatrix();
135.   } // method
136. } // class
137. //

You have turtle.theta = 22 at the beginning of the draw; change that to turtle.theta = 0.

I really wish we could discuss this in a chat or so.

Let me explain:

When I have phi initiated with a increasing Value the cube is drawn perfectly and rotating.

1. void draw() {
2.   // Init
3.   background(255);
4.   turtle.theta = 0;
5.   turtle.phi = increasingValue ;
6.   turtle.numMoves=0;
7.   turtle.posTurtle.set( 100, 100, 0 );
8.   //
9.   cube() ;
10.   increasingValue++;
11. }

When I try the same with theta

1. void draw() {
2.   // Init
3.   background(255);
4.   turtle.theta = increasingValue;
5.   turtle.phi = 0 ;
6.   turtle.numMoves=0;
7.   turtle.posTurtle.set( 100, 100, 0 );
8.   //
9.   cube() ;
10.   increasingValue++;
11. }

the cube gets changed from frame to frame (when theta = 0 or when theta = 180 it's perfect).

it takes all initial values for phi
but not for theta.

Why is that?

please take a moment to run this code:

Thank you so much!

1. //
2. // Turtle from LOGO but in 3D
3. // approach:
4. // reset canvas and all values at beginning of draw, paint a rect and then a cube.
5. //
6. // issue:
7. // works only 2D, not 3D
8. //
9. // to do:
10. // use another approach and push to an arrayList and paint this instead
11. //
12. import peasy.org.apache.commons.math.*;
13. import peasy.*;
14. import peasy.org.apache.commons.math.geometry.*;
15. // Camera
16. PeasyCam cam;
17. float increasingValue = 0;
18. Turtle turtle;
19. //
20. void setup() {
21.   size(900, 900, P3D);
22.   turtle = new Turtle ();
23.   cam = new PeasyCam(this, 1200);
24. }
25. //
26. void draw() {
27.   // Init
28.   background(255);
29.   turtle.theta = increasingValue ;  // works not
    
30.   turtle.phi = 0 ;
31.   turtle.numMoves=0;
32.   turtle.posTurtle.set( -110, 100, 20 );
33.   textMode(SCREEN);
34.   text ("values (theta, phi): " + turtle.theta + " " +   turtle.phi, 50, 20);
35.   cube() ;
36.   //
37.   //
38.   turtle.theta = 0 ;
39.   turtle.phi = increasingValue;   // works
    
40.   turtle.numMoves=0;
41.   turtle.posTurtle.set( 460, 100, 20 );
42.   textMode(SCREEN);
43.   text (turtle.theta + ", " +   turtle.phi, 560, 20);
44.   cube() ;
45.   //
46.   increasingValue++;
47.   if (increasingValue>=359) {
48.     increasingValue=0;
49.   } // if
50.   //
51. } // func
52. // --------------------------------------------------------------------------
53. void cube() {
54.   // a cube from 4 rects in 90° degree angle
55.   quadRight() ; // 1st rect
56.   //
57.   turtle.forward (130); // go to corner
58.   turtle.noseDown(90);  // pitch down
59.   quadRight() ;         // 2nd rect
60.   //
61.   turtle.forward (130);
62.   turtle.noseDown(90);
63.   quadRight() ;
64.   //
65.   turtle.forward (130);
66.   turtle.noseDown(90);
67.   quadRight() ;
68. }
69. void quadRight() {
70.   turtle.showTurtle ();
71.   for (int i = 0 ; i<4; i++) {
72.     turtle.forward (130);
73.     turtle.RI (90);
74.     //
75.   } // for
76. } // func
77. void quadLeft() {
78.   turtle.showTurtle ();
79.   for (int i = 0 ; i<4; i++) {
80.     turtle.forward (130);
81.     turtle.LE (90);
82.     //
83.   } // for
84. } // func
85. // ==========================================================================
86. // the Turtle class
87. class Turtle {
88.   //
89.   float theta = 0; // degree / 2D angle of Turtle (left / right)
90.   float phi = 0;   // degree / 3D angle of Turtle (up / down)
91.   boolean penUp = false; // turtle pulls a pen; when the pen moved up, it's not drawing (pen not on the canvas then)
92.   //
93.   int numMoves=0; // just to debug and show, where turtle was going
94.   //
95.   PVector posTurtle = new PVector ();
96.   //
97.   // constructor
98.   Turtle() {
99.     print ("constructor with width = ");
100.     println(width);
101.     posTurtle.set( width/2, height/2, 0 );
102.   } // constructor
103.   void jumpTo(float x, float y, float z) {
104.     posTurtle.set( x, y, z );
105.   }
106.   void RI (float angle1) {
107.     // turn RIGHT
108.     theta-=angle1;
109.   } // method
110.   //
111.   void LE (float angle1) {
112.     // turn left
113.     theta+=angle1;
114.   }  // method
115.   //
116.   void noseDown (float angle1) {
117.     phi-=angle1;
118.   }  // method
119.   //
120.   void nosUp (float angle1) {
121.     phi+=angle1;
122.   }  // method
123.   //
124.   void forward (float rad) {
125.     // that's drawing with line
126.     float x;
127.     float y;    
128.     float z;
129.     /*  // the original from asimes
130.      x = cos(radians(phi))*sin(radians(theta))*(rad);
131.      y = cos(radians(theta))*(rad);
132.      z = sin(radians(phi))*sin(radians(theta))*(rad);
133.      */
134.     //
135.     /*
136.      x = rad*cos(radians(phi))*cos(radians(theta));
137.      y = rad*sin(radians(phi))*cos(radians(theta));
138.      z = rad*sin(radians(theta));*/
139.     // best
140.     x = rad* cos(radians(phi)) *cos(radians(theta));
141.     y = rad* sin(radians(phi))*cos(radians(theta));
142.     // y = cos(radians(theta))*(rad);
143.     z = rad*sin(radians(theta));
144.     /*
145.     // the original from hellochar
146.      x = rad*cos(radians(theta))*cos(radians(phi));
147.      y = rad*sin(radians(theta))*cos(radians(phi));
148.      z = rad*sin(radians(phi));
149.      */
150.     if (penUp==false) {
151.       stroke(0);
152.       line (posTurtle.x, posTurtle.y, posTurtle.z,
153.       posTurtle.x+x, posTurtle.y+y, posTurtle.z+z );
154.     }
155.     posTurtle.x += x ;
156.     posTurtle.y += y ;
157.     posTurtle.z += z ;
158.     numMoves++;
159.     showTurtle () ;
160.   } // method
161.   //
162.   void showTurtle () {
163.     // small sphere
164.     pushMatrix();
165.     translate ( posTurtle.x, posTurtle.y, posTurtle.z );
166.     fill(255, 0, 0);
167.     noStroke();
168.     sphere(11);
169.     if (!keyPressed) {
170.       text( numMoves, 20, 0 );
171.     }
172.     popMatrix();
173.   } // method
174. } // class
175. //

I don't have the peasy library you used so I didn't try your code, but it sounds like you are experiencing this problem:

Here's the Code witout peasycam

I want to have it as a universal 3D-Turtle, the Cube is just an example

1. //
2. // Turtle from LOGO but in 3D
3. // approach:
4. // reset canvas and all values at beginning of draw, paint a rect and then a cube.
5. //
6. // issue:
7. // works only 2D, not 3D
8. //
9. // to do:
10. // use another approach and push to an arrayList and paint this instead
11. //
12. /*
13. import peasy.org.apache.commons.math.*;
14.  import peasy.*;
15.  import peasy.org.apache.commons.math.geometry.*;
16.  
17.  // Camera
18.  PeasyCam cam;
19.  */
20. float increasingValue = 0;
21. Turtle turtle;
22. //
23. void setup() {
24.   size(900, 900, P3D);
25.   turtle = new Turtle ();
26.   //cam = new PeasyCam(this, 1200);
27. }
28. //
29. void draw() {
30.   // Init
31.   background(255);
32.   turtle.theta = increasingValue ;
33.   turtle.phi = 0 ;
34.   turtle.numMoves=0;
35.   turtle.posTurtle.set( 290, 300, 20 );
36.   textMode(SCREEN);
37.   text ("values (theta, phi): " + turtle.theta + " " +   turtle.phi, 50, 20);
38.   cube() ;
39.   //
40.   //
41.   //turtle.phi = increasingValue;
42.   turtle.numMoves=0;
43.   textMode(SCREEN);
44.   text (turtle.theta + ", " +   turtle.phi, 560, 20);
45.   //for (int i=0; i < 360; i+=40) {
46.   turtle.posTurtle.set( 670, 300, 20 );
47.   turtle.theta = 0 ;
48.   turtle.phi = increasingValue;   
49.   turtle.penUp=true;
50.   //turtle.forward(140);
51.   turtle.penUp=false;
52.   cube() ;   // works
53.   //} // for
54.   //
55.   //
56.   increasingValue++;
57.   if (increasingValue>=359) {
58.     increasingValue=0;
59.   } // if
60.   //
61. } // func
62. // --------------------------------------------------------------------------
63. void cube() {
64.   // a cube from 4 rects in 90° degree angle
65.   quadRight() ; // 1st rect
66.   //
67.   turtle.forward (130); // go to corner
68.   turtle.noseDown(90);  // pitch down
69.   quadRight() ;         // 2nd rect
70.   //
71.   turtle.forward (130);
72.   turtle.noseDown(90);
73.   quadRight() ;
74.   //
75.   turtle.forward (130);
76.   turtle.noseDown(90);
77.   quadRight() ;
78. }
79. void quadRight() {
80.   turtle.showTurtle ();
81.   for (int i = 0 ; i<4; i++) {
82.     turtle.forward (130);
83.     turtle.RI (90);
84.     //
85.   } // for
86. } // func
87. void quadLeft() {
88.   turtle.showTurtle ();
89.   for (int i = 0 ; i<4; i++) {
90.     turtle.forward (130);
91.     turtle.LE (90);
92.     //
93.   } // for
94. } // func
95. // ==========================================================================
96. // the Turtle class
97. class Turtle {
98.   //
99.   float theta = 0; // degree / 2D angle of Turtle (left / right)
100.   float phi = 0;   // degree / 3D angle of Turtle (up / down)
101.   boolean penUp = false; // turtle pulls a pen; when the pen moved up, it's not drawing (pen not on the canvas then)
102.   //
103.   int numMoves=0; // just to debug and show, where turtle was going
104.   //
105.   PVector posTurtle = new PVector ();
106.   //
107.   // constructor
108.   Turtle() {
109.     print ("constructor with width = ");
110.     println(width);
111.     posTurtle.set( width/2, height/2, 0 );
112.   } // constructor
113.   void jumpTo(float x, float y, float z) {
114.     posTurtle.set( x, y, z );
115.   }
116.   void RI (float angle1) {
117.     // turn RIGHT
118.     theta-=angle1;
119.   } // method
120.   //
121.   void LE (float angle1) {
122.     // turn left
123.     theta+=angle1;
124.   }  // method
125.   //
126.   void noseDown (float angle1) {
127.     phi-=angle1;
128.   }  // method
129.   //
130.   void nosUp (float angle1) {
131.     phi+=angle1;
132.   }  // method
133.   //
134.   void forward (float rad) {
135.     // that's drawing with line
136.     float x;
137.     float y;    
138.     float z;
139.     /*  // the original from asimes
140.      x = cos(radians(phi))*sin(radians(theta))*(rad);
141.      y = cos(radians(theta))*(rad);
142.      z = sin(radians(phi))*sin(radians(theta))*(rad);
143.      */
144.     //
145.     /*
146.      x = rad*cos(radians(phi))*cos(radians(theta));
147.      y = rad*sin(radians(phi))*cos(radians(theta));
148.      z = rad*sin(radians(theta));*/
149.     // best
150.     x = rad* cos(radians(phi)) *cos(radians(theta));
151.     y = rad* sin(radians(phi))*cos(radians(theta));
152.     // y = cos(radians(theta))*(rad);
153.     z = rad*sin(radians(theta));
154.     /*
155.     // the original from hellochar
156.      x = rad*cos(radians(theta))*cos(radians(phi));
157.      y = rad*sin(radians(theta))*cos(radians(phi));
158.      z = rad*sin(radians(phi));
159.      */
160.     if (penUp==false) {
161.       stroke(0);
162.       line (posTurtle.x, posTurtle.y, posTurtle.z,
163.       posTurtle.x+x, posTurtle.y+y, posTurtle.z+z );
164.     }
165.     posTurtle.x += x ;
166.     posTurtle.y += y ;
167.     posTurtle.z += z ;
168.     numMoves++;
169.     showTurtle () ;
170.   } // method
171.   //
172.   void showTurtle () {
173.     // small sphere
174.     pushMatrix();
175.     translate ( posTurtle.x, posTurtle.y, posTurtle.z );
176.     fill(255, 0, 0);
177.     noStroke();
178.     sphere(11);
179.     if (!keyPressed) {
180.       text( numMoves, 20, 0 );
181.     }
182.     popMatrix();
183.   } // method
184. } // class
185. //

hello all,

following the advice from amnon.owed
I now try using Class Vec3D from toxi.geom in my method forward...
all help appreciated...

1. //
2. // Turtle from LOGO but in 3D
3. // approach:
4. // reset canvas and all values at beginning of draw, paint a rect and then a cube.
5. //
6. // issues:
7. // works only 2D, not 3D
8. //
9. // to do:
10. // use another approach and push to an arrayList and paint this instead
11. // solve issues
12. // look up table for sin & cos
13. // ---------------------------------------------------------
14. import toxi.util.datatypes.*;
15. import toxi.math.noise.*;
16. import toxi.math.waves.*;
17. import toxi.geom.*;
18. import toxi.math.*;
19. import toxi.math.conversion.*;
20. import toxi.geom.util.*;
21. import toxi.doap.*;
22. /*
23. // Camera
24.  import peasy.org.apache.commons.math.*;
25.  import peasy.*;
26.  import peasy.org.apache.commons.math.geometry.*;
27.  // Camera
28.  PeasyCam cam;
29.  */
30. // testing with a increasing Value for phi or theta
31. float increasingValue = 0;
32. //
33. // based on class Turtle comes a turtle
34. Turtle turtle;
35. //
36. void setup() {
37.   size(900, 900, P3D);
38.   turtle = new Turtle ();
39.   //cam = new PeasyCam(this, 1200);
40. }
41. //
42. void draw() {
43.   // Init
44.   background(255);
45.   turtle.numMoves=0;
46.   turtle.phi=0;
47.   turtle.theta=0;
48.   turtle.posTurtle.set( 290, 300, 20 );
49.   //
50.   quadRight() ; // 1st rect
51.   //
52.   //
53.   increasingValue++;
54.   if (increasingValue>=359) {
55.     increasingValue=0;
56.   } // if
57.   //
58. } // func
59. // --------------------------------------------------------------------------
60. void quadRight() {
61.   turtle.showTurtle ();
62.   for (int i = 0 ; i<4; i++) {
63.     turtle.forward (13);
64.     turtle.RI (90);
65.     //
66.   } // for
67. } // func
68. // ==========================================================================
69. // the Turtle class
70. class Turtle {
71.   //
72.   //float dirTurtle.x = 0; // degree / 2D angle of Turtle (left / right)
73.   //float dirTurtle.y = 0;   // degree / 3D angle of Turtle (up / down)
74.   float phi=0;
75.   float theta=0;
76.   boolean penUp = false; // turtle pulls a pen; when the pen moved up, it's not drawing (pen not on the canvas then)
77.   //
78.   int numMoves=0; // just to debug and show, where turtle was going
79.   // two vectors define the beast
80.   PVector posTurtle = new PVector ();  // pos - in 3D cartesian system
81.   //Vec3D dirTurtle = new Vec3D ();      // dir in spherical co-ordinate system, see
82.   // http://en.wikipedia.org/wiki/Spherical_coordinate_system
83.   //
84.   boolean visible = true; // turtle itself - at the moment a sphere
85.   //
86.   // constructor
87.   Turtle() {
88.     posTurtle.set( width/2, height/2, 0 );
89.     //dirTurtle.set (0, 0, 0);
90.   } // constructor
91.   //
92.   void RI (float angle1) {
93.     // turn RIGHT
94.     phi+=angle1;
95.   } // method
96.   //
97.   void LE (float angle1) {
98.     // turn left
99.     phi-=angle1;
100.   }  // method
101.   //
102.   void noseDown (float angle1) {
103.     phi-=angle1;
104.   }  // method
105.   //
106.   void noseUp (float angle1) {
107.     phi+=angle1;
108.   }  // method
109.   //
110.   //
111.   void forward (float rad) {
112.     // that's drawing with line.
113.     // Length of line = rad = radius in spherical co-ordinate system
114.     //
115.     Vec3D helpVec3D = new Vec3D (posTurtle.x, posTurtle.y, posTurtle.z);
116.     helpVec3D.rotateZ(phi);
117.     // helpVec3D.rotateX(theta);
118.     helpVec3D.scaleSelf(rad);
119.     //
120.     stroke(0);
121.     line (posTurtle.x, posTurtle.y, posTurtle.z,
122.     helpVec3D.x, helpVec3D.y, helpVec3D.z);
123.     posTurtle.set(helpVec3D.x, helpVec3D.y, helpVec3D.z);
124.     //
125.     numMoves++;
126.     showTurtle () ;
127.   } // method
128.   //
129.   void showTurtle () {
130.     // small sphere
131.     if (visible) {
132.       pushMatrix();
133.       translate ( posTurtle.x, posTurtle.y, posTurtle.z );
134.       fill(255, 0, 0);
135.       noStroke();
136.       sphere(11);
137.       if (!keyPressed) {
138.         text( numMoves, 20, 0 );
139.       }
140.       popMatrix();
141.     } // if
142.   } // method
143.   //
144. } // class
145. //

I was thinking more along these lines. Hope you don't mind I gave it a shot, there are always more ways to Rome. This Turtle first follows the given instructions, then it just walks randomly. Press any key to restart.

Code Example

1. import processing.opengl.*;
2. import toxi.processing.*;
3. import toxi.geom.*;
4.  
5. ToxiclibsSupport gfx;
6. Turtle t;
7. int zoom = -500;
8.  
9. String[] instructions = {
10.   "M10", "RZ90", "M10", "RZ90", "M10", "RZ90", "M10", // one square
11.   "RX-90", "M10",
12.   "RY90", "M10", "RZ90", "M10", "RZ90", "M10", "RZ90", "M10"
13. };
14.  
15. void setup() {
16.   size(500, 500, OPENGL);
17.   gfx = new ToxiclibsSupport(this);
18.   t = new Turtle(0, 0, 0, 30);
19.   t.giveInstructions(instructions);
20. }
21.  
22. void draw() {
23.   background(255);
24.   perspective(PI/3.0, (float) width/height, 1, 1000000);
25.   translate(width/2, height/2, zoom);
26.   rotateX(frameCount*0.01);
27.   rotateY(frameCount*0.01);
28.   t.update();
29.   t.display();
30. }
31.  
32. void keyPressed() {
33.   t = new Turtle(0, 0, 0, 30);
34.   t.giveInstructions(instructions);
35.   zoom = -500;
36. }
37.  
38. class Turtle {
39.   Vec3D pos, dir;
40.   ArrayList <Vec3D> history = new ArrayList <Vec3D> ();
41.   ArrayList <String> instructions = new ArrayList <String> ();
42.   float stepSize;
43.  
44.   Turtle(int x, int y, int z, float stepSize) {
45.     pos = new Vec3D(x, y, z);
46.     this.stepSize = stepSize;
47.     dir = new Vec3D(1, 0, 0);
48.     history.add(pos.copy());
49.   }
50.  
51.   void giveInstructions(String[] strings) {
52.     for (int i=0; i<strings.length; i++) {
53.       String s = strings[i];
54.       if (s.startsWith("M")) {
55.         int steps = int(s.substring(1));
56.         for (int j=0; j<steps; j++) {
57.           instructions.add("M1");
58.         }
59.       } else {
60.         instructions.add(s);
61.       }
62.     }
63.   }
64.  
65.   void processInstructions(String s) {
66.     if (s.startsWith("M")) {
67.       int m = int(s.substring(1));
68.       move(m);
69.     } else if (s.startsWith("R")) {
70.       int r = int(s.substring(2));
71.       if (s.charAt(1) == 'X') {
72.         rotateX(r);
73.       } else if (s.charAt(1) == 'Y') {
74.         rotateY(r);
75.       } else if (s.charAt(1) == 'Z') {
76.         rotateZ(r);
77.       } else {
78.         println("Rotation not recognised: " + s);
79.       }
80.     } else {
81.       println("Instruction not recognised: " + s);
82.     }
83.   }
84.  
85.   void update() {
86.     if (instructions.size() > 0) {
87.       String s = instructions.get(0);
88.       processInstructions(s);
89.       instructions.remove(0);
90.     } else {
91.       randomWalk();
92.       zoom--;
93.     }
94.   }
95.  
96.   void randomWalk() {
97.     float r = random(1);
98.     if (r < 0.7) {
99.       move(1);
100.     } else if (r < 0.8) {
101.       if (r < 0.75) { rotateX(90); } else { rotateX(-90); }
102.     } else if (r < 0.9) {
103.       if (r < 0.85) { rotateY(90); } else { rotateY(-90); }
104.     } else if (r < 1.0) {
105.       if (r < 0.95) { rotateZ(90); } else { rotateZ(-90); }
106.     }
107.   }
108.  
109.   void move(int steps) {
110.     for (int i=0; i<steps; i++) {
111.       pos.addSelf(dir.scale(stepSize));
112.       history.add(pos.copy());
113.     }
114.   }
115.  
116.   void display() {
117.     for (int i=1; i<history.size(); i++) {
118.       Vec3D p = history.get(i-1);
119.       Vec3D c = history.get(i);
120.       strokeWeight(4);
121.       gfx.point(p);
122.       strokeWeight(1);
123.       gfx.line(p,c);
124.     }
125.    
126.     strokeWeight(8);
127.     gfx.point(pos);
128.   }
129.  
130.   void rotateX(int degrees) {
131.     dir.rotateX(radians(degrees));
132.   }
133.  
134.   void rotateY(int degrees) {
135.     dir.rotateY(radians(degrees));
136.   }
137.  
138.   void rotateZ(int degrees) {
139.     dir.rotateZ(radians(degrees));
140.   }
141. }

That is so cool! Thank you!

But bear with me...

I can run your code, but my Cube idea still doesn't work.

I want to draw a rect (in the plane), then move the turtle nose upwards 90° and draw the same rect again with exactly the same commands (because seen locally from the turtle (and that's the way Logo works) the turtle is doing exactly the same: turn right 90°, go forward a bit, turn right 90° again.... only difference is that it starts off in a 90° different plane).

When I try with your code, it doesn't work for two rects in 90° to each other:
 

1.   "M10", "RZ90", "M10", "RZ90", "M10", "RZ90", "M10", "RZ90", // one square
2.   "M10", "RY90", // move to the edge and turn upwards
3.   "M10", "RZ90", "M10", "RZ90", "M10", "RZ90", "M10", "RZ90"  // next square
4. 
   

I am so insistent since the cube or the two rects are just as an example.

The whole code:

1. import processing.opengl.*;
2. import toxi.processing.*;
3. import toxi.geom.*;
4. ToxiclibsSupport gfx;
5. Turtle t;
6. int zoom = -500;
7. String[] instructions = {
8.   "M10", "RZ90", "M10", "RZ90", "M10", "RZ90", "M10", "RZ90", // one square
9.   "M10", "RY90", // move to the edge and turn upwards
10.   "M10", "RZ90", "M10", "RZ90", "M10", "RZ90", "M10", "RZ90"  // next square
11. };
12. /*
13. String[] instructionsSquare = {
14.  "M10", "RZ90", "M10", "RZ90", "M10", "RZ90", "M10" // one square
15.  };
16.  
17.  String[] instructions2 = {
18.  "M10", "RZ90", "M10", "RZ90", "M10", "RZ90", "M10", // one square
19.  "RX-90", "M10",
20.  "RY90", "M10", "RZ90", "M10", "RZ90", "M10", "RZ90", "M10"
21.  };
22.  */
23. void setup() {
24.   size(500, 500, OPENGL);
25.   gfx = new ToxiclibsSupport(this);
26.   t = new Turtle(0, 0, 0, 30);
27.   t.giveInstructions(instructions);
28. }
29. void draw() {
30.   background(255);
31.   perspective(PI/3.0, (float) width/height, 1, 1000000);
32.   translate(width/2, height/2, zoom);
33.   rotateX(frameCount*0.01);
34.   rotateY(frameCount*0.01);
35.   t.update();
36.   t.display();
37. }
38. void keyPressed() {
39.   t = new Turtle(0, 0, 0, 30);
40.   t.giveInstructions(instructions);
41.   zoom = -500;
42. }
43. // ===========================================================
44. class Turtle {
45.   Vec3D pos, dir;
46.   ArrayList <Vec3D> history = new ArrayList <Vec3D> ();
47.   ArrayList <String> instructions = new ArrayList <String> ();
48.   float stepSize;
49.   Turtle(int x, int y, int z, float stepSize) {
50.     pos = new Vec3D(x, y, z);
51.     this.stepSize = stepSize;
52.     dir = new Vec3D(1, 0, 0);
53.     history.add(pos.copy());
54.   }
55.   void giveInstructions(String[] strings) {
56.     for (int i=0; i<strings.length; i++) {
57.       String s = strings[i];
58.       if (s.startsWith("M")) {
59.         int steps = int(s.substring(1));
60.         for (int j=0; j<steps; j++) {
61.           instructions.add("M1");
62.         }
63.       }
64.       else {
65.         instructions.add(s);
66.       }
67.     }
68.   }
69.   void processInstructions(String s) {
70.     if (s.startsWith("M")) {
71.       int m = int(s.substring(1));
72.       move(m);
73.     }
74.     else if (s.startsWith("R")) {
75.       int r = int(s.substring(2));
76.       if (s.charAt(1) == 'X') {
77.         rotateX(r);
78.       }
79.       else if (s.charAt(1) == 'Y') {
80.         rotateY(r);
81.       }
82.       else if (s.charAt(1) == 'Z') {
83.         rotateZ(r);
84.       }
85.       else {
86.         println("Rotation not recognised: " + s);
87.       }
88.     }
89.     else {
90.       println("Instruction not recognised: " + s);
91.     }
92.   }
93.   void update() {
94.     if (instructions.size() > 0) {
95.       String s = instructions.get(0);
96.       processInstructions(s);
97.       instructions.remove(0);
98.     }
99.     else {
100.       // randomWalk();
101.       zoom--;
102.     }
103.   }
104.   void randomWalk() {
105.     float r = random(1);
106.     if (r < 0.7) {
107.       move(1);
108.     }
109.     else if (r < 0.8) {
110.       if (r < 0.75) {
111.         rotateX(90);
112.       }
113.       else {
114.         rotateX(-90);
115.       }
116.     }
117.     else if (r < 0.9) {
118.       if (r < 0.85) {
119.         rotateY(90);
120.       }
121.       else {
122.         rotateY(-90);
123.       }
124.     }
125.     else if (r < 1.0) {
126.       if (r < 0.95) {
127.         rotateZ(90);
128.       }
129.       else {
130.         rotateZ(-90);
131.       }
132.     }
133.   }
134.   void move(int steps) {
135.     for (int i=0; i<steps; i++) {
136.       pos.addSelf(dir.scale(stepSize));
137.       history.add(pos.copy());
138.     }
139.   }
140.   void display() {
141.     for (int i=1; i<history.size(); i++) {
142.       Vec3D p = history.get(i-1);
143.       Vec3D c = history.get(i);
144.       strokeWeight(4);
145.       gfx.point(p);
146.       strokeWeight(1);
147.       gfx.line(p, c);
148.     }
149.     strokeWeight(8);
150.     gfx.point(pos);
151.   }
152.   void rotateX(int degrees) {
153.     dir.rotateX(radians(degrees));
154.   }
155.   void rotateY(int degrees) {
156.     dir.rotateY(radians(degrees));
157.   }
158.   void rotateZ(int degrees) {
159.     dir.rotateZ(radians(degrees));
160.   }
161. } // class
162. //

Thank you so much!

Greetings, Chrisir

All right, I understand your goal better now. The crucial point being that both movement AND rotation are local to the turtle. In my code the movement is local to the turtle, but the rotation is still based on the world.

Instead of RY, RZ etc. it would be better to give instructions like UP, DOWN, RIGHT and LEFT (like a first-person shooter, only assuming 90 degree steps in this case). Because based on the direction the turtle is pointing, UP would mean something 'different' each time. When pointing here it might mean rotate 90 degrees around the Y axis, when pointing there it might mean rotate 90 degrees around the Z axis. Since in this case the direction is limited 6 ways (up, down, right, left, forward, back), a solution could be to determine the closest axis (x, y, z) and sign (+ or -), then carry out the instructions based on which direction the turtle is pointing.

Perhaps an alternative way to implement this -that may be shorter to code- is to determine the axis you want to rotate around, and instead of using rotateX() etc. use rotateAroundAxis().

Finally, as mentioned before quaternations and 4x4 matrices may come in handy here.

So there are some ideas, unfortunately I have little time the coming days to work any of them out further.

Thank you so much!

yeah, I had RI for Right and LE for left and noseUp and noseDown in my program.

It's meant to be locally.

It should work not only for 90° but for all degrees (to also paint octaeders or what whatever and combine them in 3D space).

see here for a 2D turtle program:
http://www.openprocessing.org/visuals/?visualID=774

so the direction is not limited 6 ways (as you wrote).

This approach

1.     // best
2.     x = rad* cos(radians(phi)) *cos(radians(theta));
3.     y = rad* sin(radians(phi))*cos(radians(theta));
4.     // y = cos(radians(theta))*(rad);
5.     z = rad*sin(radians(theta));

Good info to take into account.

The general idea of finding the right axis to rotate around is still something that I think is worth exploring.

To be continued...