25. November 2010

Im Zeichenmodul haben wir verschiedene Permutationen mit Zeichen erstellt, die wir nun mit dieser Aufgabe angefangen haben mit Processing zu verbinden. Basierend auf einem Ausgangsscript, das einfache Zeichenfunktionen verwendet und die Anordnung der Elemente bereitstellt, durften wir eine eigene Permutation übernehmen. Um besser Varianten der Permutation zu erstellen, habe ich den Code so geändert, dass das Zeichnen eines einzelnen Objektes von einer Funktion übernommen wird. Mit den Parametern dieser Funktion kann ich dann das Aussehen steuern. Diese drawSign-Funktion wird von drawPermutationObj() aufgerufen, welche die Startwerte und Increments definiert (Vergrösserung, Verkleinerung, Verschiebung). Ich sage hier also, dass der weisse kleine Kreis in der Mitte am Anfang der Transformation z.B. die Grösse 12px hat und sich von Transformationsschritt zu Transformationsschritt um 3px vergrössert. Beim "Trabanten", der sich optisch um das zentrale Element dreht kann ich zudem noch die Verschiebung in der Y-Achse definieren. Zusatzaufgabe: Für die Funktion drawPermutationObj() müssen wir noch einen weiteren Parameter einführen (Float), welcher das Objekt auf irgendeine Art verändert, z.B. Skalierung. Schlussendlich werden wir unsere drawPermutationObj-Funktion untereinander austauschen und diese animieren. Programm Code

int     anzahl = 7;
int     rand = 75;
float   xStep;
float   yStep;
int[]   permutationsIndexList = {0, 1, 2, 3, 4, 5, 6,
                                 1, 2, 3, 4, 5, 6, 5,
                                 2, 3, 4, 5, 6, 5, 4,
                                 3, 4, 5, 6, 5, 4, 3,
                                 4, 5, 6, 5, 4, 3, 2,
                                 5, 6, 5, 4, 3, 2, 1,
                                 6, 5, 4, 3, 2, 1, 0};

void setup()
{
  size(760, 760);
  smooth();

  xStep = (width - 2 * rand) / (float)(anzahl-1);
  yStep = (height - 2 * rand) / (float)(anzahl-1);

  noLoop();
}

void draw()
{
  background(255);

  int     permutationsIndex = 0;

  pushMatrix();
    translate(rand,rand);
    for(int y=0; y<anzahl;y++)
    {
      pushMatrix();
        for(int x=0; x<anzahl;x++)
        {
          drawPermutationObj(permutationsIndexList[permutationsIndex], permutationsIndex);
          print(str(permutationsIndexList[permutationsIndex]) + "\t");

          ++permutationsIndex;

          translate(xStep,0.0f);
        }
        println();
      popMatrix();
      translate(0.0f,yStep);
    }
  popMatrix();

}

void drawSign(int b1, int w1, int b2, int w2, int tb1, int tw1, int tb2, int rot, int sb2, int sw2, int stb1, int stw1, int stb2, float scaling)
{
  pushMatrix();
  scale(scaling);
  rotate(radians(rot));
  pushStyle();
    fill(0);
    noStroke();
    ellipse(0,0,b1,b1); // black circle 1
    ellipse(0,stb1,tb1,tb1); // trabant black circle
    fill(255);
    ellipse(0,0,w1,w1); // white circle 1
    fill(0);
    ellipse(0,sb2,b2,b2); // inner black circle
    fill(255);
    ellipse(0,stw1,tw1,tw1); // trabant white circle
    ellipse(0,sw2,w2,w2); // inner white spot
    fill(0);
    ellipse(0,stb2,tb2,tb2); // trabant black inner circle
  popStyle();
  popMatrix();
}

void drawPermutationObj(int type, int index)
{
  // central element
  int startB1 = 75; // B1: big black circle
  float incB1 = 0;
  int startW1 = 64; // W1: big white circle
  float incW1 = 0;

  int startB2 = 42; // B2: smaller black circle
  float incB2 = -1.5;
  int startW2 = 8; // W2: smallest white circle
  float incW2 = 3.0;

  int startSb2 = 0; // Sb2: shift B2
  float incSb2 = 2.0;
  int startSw2 = 0; // Sw2: shift W2
  float incSw2 = 2.7;

  // trabant
  int startTb1 = 40; // Tb2: big black circle trabant
  float incTb1 = 1.0;
  int startTw1 = 29; // Tw2: big white circle trabant
  float incTw1 = 2.0;
  int startTb2 = 8; // Tb2: small black circle trabant
  float incTb2 = 4.0;

  int startStb1 = -36; // Stb1: shift Tb1
  float incStb1 = 2.8;
  int startStw1 = -36; // Stw1: shift Tw1
  float incStw1 = 3;
  int startStb2 = -36; // Stb2: shift Tb2
  float incStb2 = 4.0;

  // scaling sign
  float startScale = 0.8;
  float incScale = 0;

  drawSign(
      startB1+(int)(type*incB1),
      startW1+(int)(type*incW1),
      startB2+(int)(type*incB2),
      startW2+(int)(type*incW2),
      startTb1+(int)(type*incTb1),
      startTw1+(int)(type*incTw1),
      startTb2+(int)(type*incTb2),
      type*30,
      startSb2+(int)(type*incSb2),
      startSw2+(int)(type*incSw2),
      startStb1+(int)(type*incStb1),
      startStw1+(int)(type*incStw1),
      startStb2+(int)(type*incStb2),
      startScale+(float)(type*incScale));
}

void keyPressed()
{
  switch(key)
  {
  case ' ':
    save("permutation.jpg");
    break;
  }
}