I am on it.

here we go...

the idea is simple
Instead of programming a picture for each letter, I defined a list for you.
In this list all letters of the alphabet occur.
Each letter in this list has a set of characters attached to it to determine how the circles are painted.
The character a means big circle, b means small circle. (You could choose any you like really).
You have to complete the list.


Usage

• the initial word is abca
• you can use backspace to delete it
• or type any letter to add a letter

how it works
It's all done in the function showTheWordAsBaudot() at the end of the code.
The word you typed is gone through letter by letter.
The letter is searched in the list and the set of characters is found out.
This set of characters is used like a Control set for a small robot which can make small or big circles:

• Thus this set of characters is looked through letter by letter. If it is an a, paint a big circle, if it is b, paint a small circle.

Greetings, Chrisir  

1. // what you enter (use backspace and type)
2. String myText="abca";
3. // the data for the whole alphabet (see below)
4. HashMap baudotAlphabet = new HashMap();
5. // the data for writing one letter in Baudot
6. String currentBaudotCode = "";
7. // some positioning stuff
8. final int fx = 20; // your size to the right
9. final int fy = 30; // your size between circles of one letter (to y)
10. // -------------------------------------------------------
11. void setup() {
12.   size (1000, 600);
13.   background (255);
14.   // the data: you have to fill that in
15.   baudotAlphabet.put("a", "aaabbbaa");
16.   baudotAlphabet.put("b", "baabbbaa");
17.   baudotAlphabet.put("c", "aaabbbab");
18.   baudotAlphabet.put("d", "aaabbbab");
19.   baudotAlphabet.put("e", "baabbbaa");
20.   baudotAlphabet.put("f", "aaabbbab");
21.   baudotAlphabet.put("g", "aaabbbab");
22. }
23. void draw() {
24.   // delete screen
25.   background (255);
26.   // show current word
27.   fill(0);
28.   text (myText, 20, 260);
29.   // show current word as Baudot
30.   showTheWordAsBaudot();
31. }
32. // -------------------------------------------------------
33. void keyPressed() {
34.   // here you enter the word
35.   if (key != CODED) {
36.     if (key == BACKSPACE)
37.     {
38.       // delete last letter
39.       if (myText.length()>0) {
40.         myText = myText.substring ( 0, myText.length()-1);
41.       }
42.     }
43.     else
44.     {
45.       // add letter to the word
46.       myText += key;
47.       fill(0);
48.       noStroke();
49.     }
50.   } // if (key != CODED) {
51. }
52. // ------------------------------------------------------------
53. void showTheWordAsBaudot() {
54.   // here Baudot circles are made
55.   // go through the word you entered letter by letter
56.   for (int i = 0 ; i < myText.length() ; i++) {
57.     // get the Baudot Code for the letter 
58.     currentBaudotCode = (String) baudotAlphabet.get(myText.charAt(i) + "");
59.     // if not found
60.     if (currentBaudotCode == null)
61.     {
62.       // not found: show ? sign
63.       println(myText.charAt(i)
64.         + " not found in baudotAlphabet.");
65.       fill(0);
66.       text ("?", 20+i*fx, 20+3*fy );
67.     }
68.     else
69.     {
70.       // found
71.       // interpret the  Baudot Code again letter by letter as saying: big or small cirlce
72.       for (int j = 0 ; j < currentBaudotCode.length() ; j++) {
73.         // if a
74.         if (currentBaudotCode.charAt(j) == 'a')
75.         {
76.           // big cirlce
77.           ellipse (20+i*fx, 20+j*fy, 18, 18);
78.         }
79.         // if b
80.         else if  (currentBaudotCode.charAt(j) == 'b')
81.         {
82.           // small cirlce
83.           ellipse (20+i*fx, 20+j*fy, 12, 12);
84.         }
85.         else
86.         {
87.           // error
88.           fill(0);
89.           text ("?", 20+i*fx, 20+j*fy );
90.           println ("error in "
91.             + currentBaudotCode
92.             + " for "
93.             + currentBaudotCode.charAt(j)
94.             + " with "
95.             + myText.charAt(i));
96.         }
97.       }
98.     }
99.   }
100. } // func
101. //

Oh wow, thank you so much!

here is a new version that can do two lines
for longer text

sorry, I don't know about rhino etc.

1. // what you enter (use backspace and type)
2. String myText="abca";
3. // the data for the whole alphabet (see below)
4. HashMap baudotAlphabet = new HashMap();
5. // the data for writing one letter in Baudot
6. String currentBaudotCode = "";
7. // some positioning stuff
8. final int fx = 20; // your size to the right
9. final int fy = 30; // your size between circles of one letter (to y)
10. int x, y;
11. // -------------------------------------------------------
12. void setup() {
13.   size (1000, 600);
14.   background (255);
15.   // the data: you have to fill that in
16.   baudotAlphabet.put("a", "aaabbbaa");
17.   baudotAlphabet.put("b", "baabbbaa");
18.   baudotAlphabet.put("c", "aaabbbab");
19.   baudotAlphabet.put("d", "amabbbab");
20.   baudotAlphabet.put("e", "baabbbaa");
21.   baudotAlphabet.put("f", "aaabbbab");
22.   baudotAlphabet.put("g", "aaabbbab");
23. }
24. void draw() {
25.   // delete screen
26.   background (255);
27.   // show current word
28.   fill(0);
29.   text (myText, 20, 260);
30.   // show current word as Baudot
31.   showTheWordAsBaudot();
32. }
33. // -------------------------------------------------------
34. void keyPressed() {
35.   // here you enter the word
36.   if (key != CODED) {
37.     if (key == BACKSPACE)
38.     {
39.       // delete last letter
40.       if (myText.length()>0) {
41.         myText = myText.substring ( 0, myText.length()-1);
42.       }
43.     }
44.     else
45.     {
46.       // add letter to the word
47.       myText += key;
48.       fill(0);
49.       noStroke();
50.     }
51.   } // if (key != CODED) {
52. }
53. // ------------------------------------------------------------
54. void showTheWordAsBaudot() {
55.   // here Baudot circles are made
56.   // go through the word you entered letter by letter
57.   x=0;
58.   y=0;
59.   for (int i = 0 ; i < myText.length() ; i++) {
60.     // get the Baudot Code for the letter 
61.     currentBaudotCode = (String) baudotAlphabet.get(myText.charAt(i) + "");
62.     // if not found
63.     if (currentBaudotCode == null)
64.     {
65.       // not found: show a ? sign for the whole letter
66.       println(myText.charAt(i)
67.         + " not found in baudotAlphabet.");
68.       fill(0);
69.       text ("?", 20+i*fx, y+20+3*fy );
70.     }
71.     else
72.     {
73.       // found
74.       // check line break
75.       if (i>=45 && y==0) {
76.         x-=fx*45; // begin of line
77.         y+=300;   // next line
78.       }
79.       // interprete the  Baudot Code again letter by letter as saying: big or small cirlce
80.       for (int j = 0 ; j < currentBaudotCode.length() ; j++) {
81.         // if a
82.         if (currentBaudotCode.charAt(j) == 'a')
83.         {
84.           // big cirlce
85.           ellipse (x+20+i*fx, y+20+j*fy, 18, 18);
86.         }
87.         // if b
88.         else if (currentBaudotCode.charAt(j) == 'b')
89.         {
90.           // small cirlce
91.           ellipse (x+20+i*fx, y+20+j*fy, 12, 12);
92.         }
93.         else
94.         {
95.           // error: wrong character
96.           // show one ? instead of a circle
97.           fill(0);
98.           text ("?", x+20+i*fx, y+20+j*fy );
99.           println ("error in "
100.             + currentBaudotCode
101.             + " for "
102.             + currentBaudotCode.charAt(j)
103.             + " with "
104.             + myText.charAt(i));
105.         }
106.       }
107.     }
108.   }
109. } // func
110. //

sorry, line 75
      if (i>=45 && y==0) {

before line 91 just place // to get rid of the small circles....

Thanks, I'll post my modified version shortly!

This is the code I'm trying to generate:

1.

the size in the function setup

1.   size (displayWidth-10, displayHeight);

is the whole screen

in line 102 & 103 replace 45 twice by 75 or so

2.
sure.
just copy the defining line

1.   baudotAlphabet.put("a", "aabccc");

and put different stuff in it :

1.   baudotAlphabet.put("a", "aabccc");
2.   baudotAlphabet.put("-", "aabccc");

replace lines 101 to 105 with

1.       // check line break
2.       if (i > 3 && i % 65 == 0) {
3.         if ( y==0) {
4.           x-=fx*65; // begin of line
5.           y+=300;   // next line
6.         }
7.         else if ( y==300) {
8.           x-=fx*65; // begin of line
9.           y+=300;   // next line
10.         }
11.       }

hmm... it doesn't seem to be working, actually it wasn't working since I added the other letters of the alphabet, did I somehow override it by adding the "c" for no ellipse?

this works for me

1.   size (1400, 800);

and in
line 112 & 119 :

1.           ellipse (x+20+i*fx, y+20+j*fy, 18, 18);

x+ and y+ was missing

1. // what you enter (use backspace and type)
2. String myText="abca";
3. // the data for the whole alphabet (see below)
4. HashMap baudotAlphabet = new HashMap();
5. // the data for writing one letter in Baudot
6. String currentBaudotCode = "";
7. // some positioning stuff
8. final int fx = 25; // your size to the right
9. final int fy = 25; // your size between circles of one letter (to y)
10. int x, y;
11. // -------------------------------------------------------
12. void setup() {
13.   size (1400, 800);
14.   background (255);
15.   // the data: you have to fill that in
16.   baudotAlphabet.put("a", "aabccc");
17.   baudotAlphabet.put("b", "acbcaa");
18.   baudotAlphabet.put("c", "cabaac");
19.   baudotAlphabet.put("d", "acbcac");
20.   baudotAlphabet.put("e", "acbccc");
21.   baudotAlphabet.put("f", "acbaac");
22.   baudotAlphabet.put("g", "cabcaa");
23.   baudotAlphabet.put("h", "ccbaca");
24.   baudotAlphabet.put("i", "cabacc");
25.   baudotAlphabet.put("j", "aabcac");
26.   baudotAlphabet.put("k", "aabaac");
27.   baudotAlphabet.put("l", "cabcca");
28.   baudotAlphabet.put("m", "ccbaaa");
29.   baudotAlphabet.put("n", "ccbaac");
30.   baudotAlphabet.put("o", "ccbcaa");
31.   baudotAlphabet.put("p", "cabaca");
32.   baudotAlphabet.put("q", "aabaca");
33.   baudotAlphabet.put("r", "cabcac");
34.   baudotAlphabet.put("s", "acbacc");
35.   baudotAlphabet.put("t", "ccbcca");
36.   baudotAlphabet.put("u", "aabacc");
37.   baudotAlphabet.put("v", "cabaaa");
38.   baudotAlphabet.put("w", "aabcca");
39.   baudotAlphabet.put("x", "acbaaa");
40.   baudotAlphabet.put("y", "acbaca");
41.   baudotAlphabet.put("z", "acbcca");
42.   baudotAlphabet.put(" ", "ccbacc");
43. }
44. void draw() {
45.   // delete screen
46.   background (255);
47.   // show current word
48.   fill(0);
49.   text (myText, 20, 260);
50.   // show current word as Baudot
51.   showTheWordAsBaudot();
52. }
53. // -------------------------------------------------------
54. void keyPressed() {
55.   // here you enter the word
56.   if (key != CODED) {
57.     if (key == BACKSPACE)
58.     {
59.       // delete last letter
60.       if (myText.length()>0) {
61.         myText = myText.substring ( 0, myText.length()-1);
62.       }
63.     }
64.     else
65.     {
66.       // add letter to the word
67.       myText += key;
68.       fill(0);
69.       noStroke();
70.     }
71.   } // if (key != CODED) {
72. }
73. // ------------------------------------------------------------
74. void showTheWordAsBaudot() {
75.   // here Baudot circles are made
76.   // go through the word you entered letter by letter
77.   x=0;
78.   y=0;
79.   for (int i = 0 ; i < myText.length() ; i++) {
80.     // get the Baudot Code for the letter 
81.     currentBaudotCode = (String) baudotAlphabet.get(myText.charAt(i) + "");
82.     // if not found
83.     if (currentBaudotCode == null)
84.     {
85.       // not found: show a ? sign for the whole letter
86.       println(myText.charAt(i)
87.         + " not found in baudotAlphabet.");
88.       fill(0);
89.       text ("?", 20+i*fx, y+20+3*fy );
90.     }
91.     else
92.     {
93.       // found
94.       // check line break
95.       // check line break
96.       if (i > 3 && i % 55 == 0) {
97.         if ( y==0) {
98.           x-=fx*55; // begin of line
99.           y+=300;   // next line
100.         }
101.         else if ( y==300) {
102.           x-=fx*55; // begin of line
103.           y+=300;   // next line
104.         }
105.       }
106.       // interprete the  Baudot Code again letter by letter as saying: big or small cirlce
107.       for (int j = 0 ; j < currentBaudotCode.length() ; j++) {
108.         // if a
109.         if (currentBaudotCode.charAt(j) == 'a')
110.         {
111.           // big cirlce
112.           ellipse (x+20+i*fx, y+20+j*fy, 18, 18);
113.           fill (0);
114.         }
115.         // if b
116.         else if  (currentBaudotCode.charAt(j) == 'b')
117.         {
118.           // small cirlce
119.           ellipse (x+20+i*fx, y+20+j*fy, 12, 12);
120.           fill (0);
121.         }
122.         // if c
123.         else if  (currentBaudotCode.charAt(j) == 'c')
124.         {
125.           // small cirlce
126.           //ellipse (20+i*fx, 20+j*fy, 18, 18);
127.         }
128.         else
129.         {
130.           // error: wrong character
131.           // show one ? instead of a circle
132.           text ("?", x+20+i*fx, y+20+j*fy );
133.           println ("error in "
134.             + currentBaudotCode
135.             + " for "
136.             + currentBaudotCode.charAt(j)
137.             + " with "
138.             + myText.charAt(i));
139.         }
140.       }
141.     }
142.   }
143. } // func
144. //

I have to go...

don't mix up versions...

Thank you so much again, this has been an immense help!

feel free to ask more...