IAD Zeichenmodule

Zeichenmodule Dozierende: Max Rheiner / Jürgen Späth In den Letzten Woche hatten wir die Aufgabe, Zeichen in Processing zu Generieren. Der Code wurde fortzu erweitert, bis schliesslich ein mit Kinect angesteuertes Muster aus  Einheitlichen Zeichen auf Bewegungen im Realraum reagiert. Meinen Code habe ich versucht Modular aufzubauen, so das Erweiterungen einfach möglich sind, ohne das ganze Konzept neu zu schreiben. Des Weiteren habe ich versucht möglichst alle Werte über Variabeln zu definieren, was eine Grosse Anzahl von Möglichkeiten im Code zur Folge hat. Um diese Möglichkeiten zu nutzen, habe ich Tastaturinteraktionen miteinge-baut. Die Interaktionsmöglichkeiten lassen sich zudem per Tastendruck einblenden. Der Code ist in drei Hauptabschnitte gegliedert: -  Hauptcode mit Iterationsschleifen, Interaktionen und Funktionsanzeige (Menu) -  Permutationsschlaufen -  Zeichen     Download Code: Zeichentransformation       Hauptcode:

int zeichendurchmesser = 100;
int zeichenabstand =20;
int verschiebung = 0;
int zeichentyp = 0;
int zeicheninteraktion = 0;
int schwarz = 0;
int weiss = 255;
int interactiviti = 50;
PVector abstandmaus;
int raster = 7;
boolean rotation = false;
boolean position = false;
boolean skalierung = false;
boolean menu =true;
boolean mode =false;
boolean farbe = true;
int[]   permutationsIndexList = {
0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0
};

void setup()
{
size((zeichenabstand+zeichendurchmesser)*raster+zeichenabstand, (zeichenabstand+zeichendurchmesser)*raster+2*zeichenabstand);
smooth();
noStroke();
PFont font;
font = loadFont("Verdana-48.vlw");
textFont(font, 10);
}

void draw()
{
background(weiss);
pushMatrix();
if (farbe)
{
schwarz = 0;
weiss = 255;
}
else if (!farbe)
{
schwarz = 255;
weiss = 0;
}
if (menu)
{
textAlign(LEFT);
fill(schwarz);
text("= M", width-65, 160);
text("= P", width-65, 180);
text("= L", width-65, 200);
text("= O", width-65, 220);
text("= 0-9", width-65, 240);
text("= Q,W,E-Z", width-65, 260);
text("= A,S,D-K", width-65, 280);
text("= Y/X", width-65, 300);
text("= C/V", width-65, 320);
text("= B/N", width-65, 340);
text("= U/I", width-65, 360);
text("Menü ein/ausblenden", width-200, 160);
text("Bild Speichern", width-200, 180);
text("Interaktion umkehren", width-200, 200);
text("Farben umkehren", width-200, 220);
text("Iterationsvariationen", width-200, 240);
text("Zeichenvariationen", width-200, 260);
text("Interaktionsvariationen", width-200, 280);
text("Zeichengrösse ändern", width-200, 300);
text("Zeichenabstand ändern", width-200, 320);
text("Raster verschieben", width-200, 340);
text("interaktionsstärke", width-200, 360);
scale(.5, .5);
translate(width/4, height/2);
}
float distanz =0;
translate(verschiebung, verschiebung);
float zeicheniteration = 0;
int mouseposX = mouseX;
int mouseposY = mouseY;
int xPos;
int yPos;
int     permutationsIndex = 0;
pushMatrix();
translate(zeichendurchmesser/2+zeichenabstand, zeichendurchmesser/2+zeichenabstand);
xPos = zeichendurchmesser/2+zeichenabstand;
yPos = zeichendurchmesser/2+zeichenabstand;
for (int y=0; y<raster;y++)
{
pushMatrix();
for (int x=0; x<raster;x++)
{
abstandmaus = new PVector((xPos),(yPos));
println(xPos);
distanz = map(sqrt(sq(mouseX-xPos)+sq(mouseY-yPos)), 0, sqrt(sq(height-zeichendurchmesser/2-zeichenabstand)*2), 0.1, 1)*(-1);
drawPermutationObj(permutationsIndexList[permutationsIndex], zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
++permutationsIndex;
translate(zeichendurchmesser+zeichenabstand, 0);
xPos += zeichendurchmesser+zeichenabstand;
}
popMatrix();
xPos = zeichendurchmesser/2+zeichenabstand;
translate(0, zeichendurchmesser+zeichenabstand);
yPos += zeichendurchmesser+zeichenabstand;
}
popMatrix();
popMatrix();
}

void keyPressed()
{
switch(key)
{
case 'q':
zeichentyp = 0;
break;
case 'w':
zeichentyp = 1;
break;
case 'e':
zeichentyp = 2;
break;
case 'r':
zeichentyp = 3;
break;
case 't':
zeichentyp = 4;
break;
case 'z':
zeichentyp = 5;
break;
case 'a':
rotation = false;
position = false;
skalierung = false;
break;
case 's':
rotation = true;
position = false;
skalierung = false;
break;
case 'd':
rotation = false;
position = true;
skalierung = false;
break;
case 'f':
rotation = false;
position = false;
skalierung = true;
break;
case 'g':
rotation = true;
position = true;
skalierung = false;
break;
case 'h':
rotation = true;
position = false;
skalierung = true;
break;
case 'j':
rotation = false;
position = true;
skalierung = true;
break;
case 'k':
rotation = true;
position = true;
skalierung = true;
break;
case 'm':
menu =!menu;
break;
case 'l':
mode =!mode;
break;
case 'o':
farbe =!farbe;
break;
case 'u':
interactiviti=interactiviti-5;
break;
case 'i':
interactiviti=interactiviti+5;
break;
case 'y':
zeichendurchmesser=zeichendurchmesser-5;
break;
case 'x':
zeichendurchmesser=zeichendurchmesser+5;
break;
case 'c':
zeichenabstand=zeichenabstand-1;
break;
case 'v':
zeichenabstand=zeichenabstand+1;
break;
case 'b':
verschiebung = verschiebung -10;
break;
case 'n':
verschiebung = verschiebung +10;
break;
case 'p':
save("screenShot.jpg");
println("save the screen to screenShot.jpg");
break;
case '0':
permutationsIndexList= new int[] {
0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0
};
break;
case '1':
permutationsIndexList= new int[] {
0, 1, 2, 3, 2, 1, 0,
1, 2, 3, 4, 3, 2, 1,
2, 3, 4, 5, 4, 3, 2,
3, 4, 5, 6, 5, 4, 3,
2, 3, 4, 5, 4, 3, 2,
1, 2, 3, 4, 3, 2, 1,
0, 1, 2, 3, 2, 1, 0
};
break;
case '2':
permutationsIndexList = new int[] {
0, 1, 2, 3, 4, 5, 6,
6, 5, 4, 3, 2, 1, 0,
0, 1, 2, 3, 4, 5, 6,
6, 5, 4, 3, 2, 1, 0,
0, 1, 2, 3, 4, 5, 6,
6, 5, 4, 3, 2, 1, 0,
0, 1, 2, 3, 4, 5, 6,
};
break;
case '3':
permutationsIndexList = new int[] {
0, 1, 2, 3, 4, 5, 6,
1, 0, 1, 2, 3, 4, 5,
2, 3, 0, 1, 2, 3, 4,
3, 2, 5, 0, 1, 2, 3,
4, 3, 2, 5, 0, 1, 2,
5, 4, 3, 2, 3, 0, 1,
6, 5, 4, 3, 2, 1, 0
};
;
break;
case '4':
permutationsIndexList = new int[] {
0, 0, 0, 0, 0, 0, 0,
1, 2, 3, 4, 3, 2, 1,
2, 4, 6, 0, 6, 4, 2,
3, 6, 0, 4, 0, 6, 3,
4, 0, 3, 0, 3, 0, 4,
5, 2, 6, 4, 6, 2, 5,
6, 4, 0, 0, 0, 4, 6
};
break;
case '5':
permutationsIndexList = new int[] {
0, 0, 0, 3, 0, 0, 0, 0, 1, 1, 4, 1, 1, 0,
0, 1, 2, 5, 2, 1, 0,
3, 4, 5, 6, 5, 4, 3,
0, 1, 2, 5, 2, 1, 0,
0, 1, 1, 4, 1, 1, 0,
0, 0, 0, 3, 0, 0, 0
};
;
break;
case '6':
permutationsIndexList = new int[] {
0, 1, 2, 3, 4, 5, 6,
1, 2, 3, 4, 5, 6, 0,
2, 3, 4, 5, 6, 0, 1,
3, 4, 5, 6, 0, 1, 2,
4, 5, 6, 0, 1, 2, 3,
5, 6, 0, 1, 2, 3, 4,
6, 0, 1, 2, 3, 4, 5
};
;
break;
case '7':
permutationsIndexList = new int[] {
6, 0, 1, 2, 3, 3, 3,
6, 0, 1, 2, 2, 2, 3,
6, 0, 1, 1, 1, 1, 2,
6, 0, 0, 0, 0, 0, 1,
5, 6, 6, 6, 6, 0, 1,
5, 5, 5, 5, 6, 0, 1,
4, 4, 4, 5, 6, 0, 1
};
;
break;
case '8':
permutationsIndexList = new int[] {
0, 1, 1, 1, 1, 1, 0,
0, 2, 3, 3, 3, 3, 0,
0, 2, 4, 5, 4, 2, 0,
0, 2, 4, 6, 4, 2, 0,
0, 2, 4, 5, 4, 2, 0,
0, 2, 3, 3, 3, 3, 0,
0, 1, 1, 1, 1, 1, 0
};
;
break;
case '9':
permutationsIndexList = new int[] {
1, 2, 3, 3, 3, 2, 1,
2, 3, 4, 4, 4, 3, 2,
3, 4, 5, 5, 5, 4, 3,
4, 5, 6, 0, 6, 5, 4,
3, 4, 5, 5, 5, 4, 3,
2, 3, 4, 4, 4, 3, 2,
1, 2, 3, 3, 3, 2, 1
};
;
break;
}
}

Zeichenpermutation:

void drawPermutationObj(int type, float zeicheniteration, float distanz, PVector abstandmaus, boolean rotation, boolean position, boolean skalierung, boolean mode, int interactiviti)
{
pushStyle();
switch(type)
{
case 0:
zeicheniteration=zeicheniteration+0;
if (zeicheniteration>7)
{
zeicheniteration=(7-(zeicheniteration-7));
}
if (zeicheniteration<1)
{
zeicheniteration=((-1)*(zeicheniteration-1))+1;
}
if (zeichentyp == 0)
{
Zeichen0(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
else if (zeichentyp==1)
{
Zeichen1(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
else if (zeichentyp==2)
{
Zeichen2(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
else if (zeichentyp==3)
{
Zeichen3(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
else if (zeichentyp==4)
{
Zeichen4(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
else if (zeichentyp==5)
{
Zeichen5(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
break;
case 1:
zeicheniteration=zeicheniteration+1;
if (zeicheniteration>7)
{
zeicheniteration=(7-(zeicheniteration-7));
}
if (zeicheniteration<1)
{
zeicheniteration=((-1)*(zeicheniteration-1))+1;
}
if (zeichentyp ==0)
{
Zeichen0(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
else if (zeichentyp==1)
{
Zeichen1(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
else if (zeichentyp==2)
{
Zeichen2(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
else if (zeichentyp==3)
{
Zeichen3(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
else if (zeichentyp==4)
{
Zeichen4(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
else if (zeichentyp==5)
{
Zeichen5(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
break;
case 2:
zeicheniteration=zeicheniteration+2;
if (zeicheniteration>7)
{
zeicheniteration=(7-(zeicheniteration-7));
}
if (zeicheniteration<1)
{
zeicheniteration=((-1)*(zeicheniteration-1))+1;
}
if (zeichentyp ==0)
{
Zeichen0(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
else if (zeichentyp==1)
{
Zeichen1(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
else if (zeichentyp==2)
{
Zeichen2(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
else if (zeichentyp==3)
{
Zeichen3(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
else if (zeichentyp==4)
{
Zeichen4(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
else if (zeichentyp==5)
{
Zeichen5(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
break;
case 3:
zeicheniteration=zeicheniteration+3;
if (zeicheniteration>7)
{
zeicheniteration=(7-(zeicheniteration-7));
}
if (zeicheniteration<1)
{
zeicheniteration=((-1)*(zeicheniteration-1))+1;
}
if (zeichentyp ==0)
{
Zeichen0(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
else if (zeichentyp==1)
{
Zeichen1(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
else if (zeichentyp==2)
{
Zeichen2(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
else if (zeichentyp==3)
{
Zeichen3(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
else if (zeichentyp==4)
{
Zeichen4(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
else  if (zeichentyp==5)
{
Zeichen5(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
break;
case 4:
zeicheniteration=zeicheniteration+4;
if (zeicheniteration>7)
{
zeicheniteration=(7-(zeicheniteration-7));
}
if (zeicheniteration<1)
{
zeicheniteration=((-1)*(zeicheniteration-1))+1;
}
if (zeichentyp ==0)
{
Zeichen0(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
else if (zeichentyp==1)
{
Zeichen1(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
else if (zeichentyp==2)
{
Zeichen2(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
else if (zeichentyp==3)
{
Zeichen3(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
else if (zeichentyp==4)
{
Zeichen4(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
else if (zeichentyp==5)
{
Zeichen5(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
break;
case 5:
zeicheniteration=zeicheniteration+5;
if (zeicheniteration>7)
{
zeicheniteration=(7-(zeicheniteration-7));
}
if (zeicheniteration<1)
{
zeicheniteration=((-1)*(zeicheniteration-1))+1;
}
if (zeichentyp ==0)
{
Zeichen0(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
else if (zeichentyp==1)
{
Zeichen1(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
else if (zeichentyp==2)
{
Zeichen2(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
else if (zeichentyp==3)
{
Zeichen3(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
else if (zeichentyp==4)
{
Zeichen4(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
else if (zeichentyp==5)
{
Zeichen5(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
break;
case 6:
zeicheniteration=zeicheniteration+6;
if (zeicheniteration>7)
{
zeicheniteration=(7-(zeicheniteration-7));
}
if (zeicheniteration<1)
{
zeicheniteration=((-1)*(zeicheniteration-1))+1;
}
if (zeichentyp ==0)
{
Zeichen0(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
else if (zeichentyp==1)
{
Zeichen1(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
else if (zeichentyp==2)
{
Zeichen2(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
else if (zeichentyp==3)
{
Zeichen3(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
else if (zeichentyp==4)
{
Zeichen4(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
else if (zeichentyp==5)
{
Zeichen5(zeicheniteration, distanz, abstandmaus, rotation, position, skalierung, mode, interactiviti);
}
break;
}
}

Zeichen:

void Zeichen0(float zeicheniteration, float distanz, PVector abstandmaus, boolean rotation, boolean position, boolean skalierung, boolean mode, float interactiviti)
{
pushStyle();
noStroke();
fill(schwarz);
ellipseMode(CENTER);
pushMatrix();
if (mode)
{
if (rotation)
{
rotate(distanz*interactiviti/50);
}
if (position)
{
translate(abstandmaus.x/distanz/interactiviti/50, abstandmaus.y/distanz/interactiviti/50);
}
if (skalierung)
{
scale(distanz*interactiviti/50, distanz*interactiviti/50);
}
}
else
{
if (rotation)
{
rotate(distanz*interactiviti/50*(-1));
}
if (position)
{
translate((-1)*abstandmaus.x/distanz/interactiviti, (-1)*abstandmaus.y/distanz/interactiviti);
}
if (skalierung)
{
scale((1/(distanz-0.1))*interactiviti/500, (1/(distanz-0.1))*interactiviti/500);
}
}
ellipse(0, 0, (7-zeicheniteration)*zeichendurchmesser/5, (7-zeicheniteration)*zeichendurchmesser/5);
popMatrix();
popStyle();
}

void Zeichen1(float zeicheniteration, float distanz, PVector abstandmaus, boolean rotation, boolean position, boolean skalierung, boolean mode, float interactiviti)
{
pushStyle();
noStroke();
pushMatrix();
if (mode)
{
if (rotation)
{
rotate(distanz*interactiviti/50);
}
if (position)
{
translate(abstandmaus.x/distanz/interactiviti, abstandmaus.y/distanz/interactiviti);
}
if (skalierung)
{
scale(distanz*interactiviti/50, distanz*interactiviti/50);
}
}
else
{
if (rotation)
{
rotate(distanz*interactiviti/50*(-1));
}
if (position)
{
translate((-1)*abstandmaus.x/distanz/interactiviti, (-1)*abstandmaus.y/distanz/interactiviti);
}
if (skalierung)
{
scale((1/(distanz-0.1))*interactiviti/500, (1/(distanz-0.1))*interactiviti/500);
}
}
boolean z = true;
for (int i = 0; i < 6; i = i+1)
{
pushMatrix();
rotate(((-i))*(radians(6.42857)*(6*zeicheniteration*distanz)));
scale(pow(pow( (0.9), i), 1/4+1.62), pow(pow( (0.9), i), 1/4+1.62));
if (z) {
fill(schwarz);
}
else {
fill(weiss);
}
rectMode(CENTER);
rect(0, 0, zeichendurchmesser, zeichendurchmesser);
popMatrix();
z=!z;
}
popMatrix();
popStyle();
}

void Zeichen2(float zeicheniteration, float distanz, PVector abstandmaus, boolean rotation, boolean position, boolean skalierung, boolean mode, float interactiviti)
{
pushStyle();
noStroke();
pushMatrix();
if (mode)
{
if (rotation)
{
rotate(distanz*interactiviti/50);
}
if (position)
{
translate(abstandmaus.x/distanz/interactiviti, abstandmaus.y/distanz/interactiviti);
}
if (skalierung)
{
scale(distanz*interactiviti/50, distanz*interactiviti/50);
}
}
else
{
if (rotation)
{
rotate(distanz*interactiviti/50*(-1));
}
if (position)
{
translate((-1)*abstandmaus.x/distanz/interactiviti, (-1)*abstandmaus.y/distanz/interactiviti);
}
if (skalierung)
{
scale((1/(distanz-0.1))*interactiviti/500, (1/(distanz-0.1))*interactiviti/500);
}
}
boolean z = true;
for (int i = 0; i < 6; i = i+1)
{
pushMatrix();
rotate(((-i))*(radians(6.42857)*(zeicheniteration*distanz)));
scale(pow(pow( (0.9), i), 1/4+1.62), pow(pow( (0.9), i), 1/4+1.62));
if (z) {
fill(schwarz);
}
else {
fill(weiss);
}
rectMode(CENTER);
rect(0, 0, zeichendurchmesser, zeichendurchmesser);
popMatrix();
z=!z;
}
popMatrix();
popStyle();
}

void Zeichen3(float zeicheniteration, float distanz, PVector abstandmaus, boolean rotation, boolean position, boolean skalierung, boolean mode, float interactiviti)
{
pushStyle();
pushMatrix();
if (mode)
{
if (rotation)
{
rotate(distanz*interactiviti/50);
}
if (position)
{
translate(abstandmaus.x/distanz/interactiviti, abstandmaus.y/distanz/interactiviti);
}
if (skalierung)
{
scale(distanz*interactiviti/50, distanz*interactiviti/50);
}
}
else
{
if (rotation)
{
rotate(distanz*interactiviti/50*(-1));
}
if (position)
{
translate((-1)*abstandmaus.x/distanz/interactiviti, (-1)*abstandmaus.y/distanz/interactiviti);
}
if (skalierung)
{
scale((1/(distanz-0.1))*interactiviti/500, (1/(distanz-0.1))*interactiviti/500);
}
}
boolean z = true;
for (int i = 0; i < 40; i = i+1)
{
pushMatrix();
rotate(((-i))*(radians(6.42857)*(zeicheniteration*distanz)));
scale(pow(pow( (0.95), i), 1/4+1.62), pow(pow( (0.95), i), 1/4+1.62));
if (z) {
fill(schwarz);
}
else {
fill(weiss);
}
rectMode(CENTER);
rect(0, 0, zeichendurchmesser, zeichendurchmesser);
popMatrix();
z=!z;
}
popMatrix();
popStyle();
}
void Zeichen4(float zeicheniteration, float distanz, PVector abstandmaus, boolean rotation, boolean position, boolean skalierung, boolean mode, float interactiviti)
{
pushStyle();
pushMatrix();
if (mode)
{
if (rotation)
{
rotate(distanz*interactiviti/50);
}
if (position)
{
translate(abstandmaus.x/distanz/interactiviti, abstandmaus.y/distanz/interactiviti);
}
if (skalierung)
{
scale(distanz*interactiviti/50, distanz*interactiviti/50);
}
}
else
{
if (rotation)
{
rotate(distanz*interactiviti/50*(-1));
}
if (position)
{
translate((-1)*abstandmaus.x/distanz/interactiviti, (-1)*abstandmaus.y/distanz/interactiviti);
}
if (skalierung)
{
scale((1/(distanz-0.1))*interactiviti/500, (1/(distanz-0.1))*interactiviti/500);
}
}
int s = 100; //durcmesser kreis weiss
int v = 45; // verschiebung kreise  weiss-weiss X
int w = 75; // verschiebung kreise  weiss-weiss Y
float t = 0;
float f = 0.9;
float p = 5;
float c=1;
//  c = map(abstandmaus.y*abstandmaus.x, 0, (raster*(zeichenabstand+zeichendurchmesser)+zeichenabstand)*(raster*(zeichenabstand+zeichendurchmesser)+zeichenabstand), 0, 7);
c= zeicheniteration+ distanz*interactiviti/5;
if (c>7)
{
c=(7-(c-7));
}
if (c<1)
{
c=((-1)*(c-1))+1;
}
p = p+(2.5)*c;
f = pow(f, c);
t = t + (3.8)*c;
;
pushMatrix();
translate(0, 0);
scale(0.4, 0.4);
fill(schwarz);
ellipse(0, 50, 200, 200);
fill(weiss);
pushMatrix();
translate(0, t);
Kreis(t, p, f, s);
popMatrix();
pushMatrix();
translate(v*f, w*f+t);
rotate(radians(120));
Kreis(t, p, f, s);
popMatrix();
pushMatrix();
translate(-v*f, w*f+t);
rotate(radians(-120));
Kreis(t, p, f, s);
popMatrix();
popMatrix();
popMatrix();
popStyle();
}

void Zeichen5(float zeicheniteration, float distanz, PVector abstandmaus, boolean rotation, boolean position, boolean skalierung, boolean mode, float interactiviti)
{
pushStyle();
pushMatrix();

if (mode)
{
if (rotation)
{
rotate(distanz*interactiviti/50);
}
if (position)
{
translate(abstandmaus.x/distanz/interactiviti, abstandmaus.y/distanz/interactiviti);
}
if (skalierung)
{
scale(distanz*interactiviti/50, distanz*interactiviti/50);
}
}
else
{
if (rotation)
{
rotate(distanz*interactiviti/50*(-1));
}
if (position)
{
translate((-1)*abstandmaus.x/distanz/interactiviti, (-1)*abstandmaus.y/distanz/interactiviti);
}
if (skalierung)
{
scale((1/(distanz-0.01))*interactiviti/100, (1/(distanz-0.01))*interactiviti/100);
}
}
rectMode(CENTER);
rect(0, 0, zeichendurchmesser, zeichendurchmesser);
popMatrix();
popStyle();
}

void Kreis(float t, float p, float f, float s)
{
pushMatrix();
rotate(radians(-90));
stroke(weiss);
strokeWeight(3);
noFill();
for (int i = 0; i < p;i=i+1)
{
ellipse(0-i/2, 0, (s-i), (s-i));
ellipse(0+i/2, 0, (s+i), (s+i));
}
popMatrix();
}