Toolbox Interactiondesign


Generative Gestaltung

GGGAnalog Entwurf // Visuelle Parameter übersetzt in die Physis

Muster goes Analog | Entwurf

Ann-Cathrin Zogbaum, 02.09.2013 | Generative Gestaltung Goes Analog bei Prof. Dr. Christine Goutrié

Einfache geometrische Formen – ein Kreis oder ein Quader. Halbtransparent gefüllt.
Gerastert in X- und Y-Richtung. Größenverstellbar, drehbar.
Was passiert?

In meinem Projekt ‘‘Muster goes Analog‘‘ gehe ich dieser Frage nach. Ich untersuche die Mustergestaltung ausgehend von einer einfachen geometrischen Form  in Processing. Angeordnet in einem Raster werden durch die Überlagerung der  halbtransparenten Flächen unterschiedliche Helligkeitsstufen erzeugt und eine Vielzahl von Mustern digital generiert.
Die Übersetzung vom Digitalen in die Physis funktioniert dadurch, dass die Halbtransparenz durch eine Schraffur dargestellt und in ein beliebiges Material gefräst wird.

Muster goes Analog | Präsentation

Ann-Cathrin Zogbaum, 02.09.2013 | Generative Gestaltung Goes Analog bei Prof. Dr. Christine Goutrié und Prof. Dr. Michael Herzog

Die Präsentation des Projektes „Generatives Gestalten goes Analog“ umfasste 2 Bereiche. Zum Einen die interne Präsentation im Haus 9, Raum 0.02 vor Professoren und interessierten Studenten, wo jeder sein Projekt in 10 Minuten mit Hilfe des Beamers vorgestellt hat. Zum Anderen wurde im Rahmen der SINNflut eine Ausstellung mit den jeweiligen Arbeiten und ein zusammfassendes Plakat geschaffen.

Zu Beginn der Präsentation ging ich kurz auf die Einstiegsaufgaben und Materialrecherche ein, fokusierte mich dann jedoch schnell auf mein eigenes Projekt. Dabei war mir wichtig, dass ich verständlich und anschaulich erkläre, wie ich visuelle Parameter vom Digitalen in die Physis übersetze.

Für die Ausstellung lag mein Fokus auf die Interaktion der Besucher. Ich wollte, dass sie meinen Mustergenerator vor Ort ausprobieren können. Daher stellte ich nicht nur die Ergebnisse aus, sondern brachte auch das Programm zum Laufen.

Muster goes Analog | Prozess

Ann-Cathrin Zogbaum, 02.09.2013 | Generative Gestaltung Goes Analog bei Prof. Dr. Christine Goutrié

Die Basis für mein Projekt ‘‘Muster goes Analog‘‘ bildet die vorangehende Aufgabe „parametriesierbare Raster“. Innerhalb dieser Aufgabe schaffte ich ein Raster, welches aus einem einfachem geometrischen Element besteht – einmal dem Kreis und einmal dem Quader. Dieses konnte über Slider individuell bearbeitet werden – die Größe der Formen und speziell beim Quader die Rotation um den eigenen Mittelpunkt war variierbar. Da die Flächen halbtransparent gefüllt sind, werden durch Überlagerungen dieser Bereiche unterschiedliche Muster erzeugt. Diese Beobachtung brachte mich dazu, mit den Ergebnissen weiter zu arbeiten und sie unter dem Aspekt „Generatives Gestalten goes Analog“ zu beleuchten.

Die Gegenüberstellung der von mir erstellten Kreis- und Quader-Rastern hat mir gezeigt, dass die Vielfalt an Mustervariationen beim Quader um einiges höher ist, da der Kreis sich nur durch Änderung des Durchmessers variieren lässt. Der Quader hingegen bietet durch die Rotation um seinen Mittelpunkt ein noch größeres Spektrum an Mustern. Trotz der Vielfalt der Quader entschied ich mich dazu, mich bei meiner weiteren Arbeit auf den Kreis zu konzentrieren.
Digital lag mir nun eine interessante Form des Gestaltens vor. Doch wie bekomme ich diese in die analoge Welt?

Diese Frage bildet mein Kernthema. Die nächsten Schritten befassten sich damit, wie ich visuelle Parameter, in diesem Falle die Halbtransparenz, mit Hilfe der Fräse in die Physis bringe. Meine Untersuchung ergab, dass eine Option eine gefüllte Fläche darzustellen die Schraffur ist. Sie besteht aus einzelnen, parallelen Linien und ermöglicht es, durch den Freiraum zwischen ihnen, überlagerte Flächen zu verdeutlichen. Da eine Linie gut fräs- und definierbar ist, erschien es mir eine gute Möglichkeit digital und analog zusammenzubringen. Dieses wurde mir durch meine ersten Versuche bestätigt. Anschließend fräste ich in die unterschiedlichsten Materialien, verarbeitete diese zum Teil weiter und experimentierte unteranderem mit Farbe, Gips und Gummi.

 

Anschließend lag meine Konzentration auf der Ausarbeitung im digitalen Bereich. Ich entwickelte einen Mustergenerator, mit dem durch unterschiedliche Parameter, wie die Größenverstellbarkeit der Form, individuelle Muster entstehen können. Die Muster werden erzeugt und der Generator übersetzt die digitale in die analoge Variante. Die digitale Variante funktioniert durch halbtransparente und die analoge durch schraffierte Flächen. Neben der Dichte kann ebenfalls die Ausrichtung der Schraffur verändert werden, wodurch das digitale Muster je nach Einstellung unterschiedlich ins Analoge übertragen wird. Das Programm schreibt nach Betätigen des GCODE-Buttons den passenden Code für die Fräse heraus und das erzeugte Muster kann ins Material eingearbeitet werden.

Profilierte Materialien aus meinen Untersuchen waren Polystyrol und Gummi unter anschließender Weiterverarbeitung mit Gips. So gestaltete ich als Resultat meines Projektes 3 Exponate (30cmx30cm) in denen jeweils das selbe Muster, um eine bessere Vergleichbarkeit der unterschiedlichen Materialien zu erhalten, eingearbeitet wurde.
Die Polystyrolpatte lackierte ich vor dem Fräsen farbig, damit die Überlagerung der schraffierten Flächen noch deutlicher gezeigt wird. Mein zweites Exponat bestand aus einer Gummimatte, die hauptsächlich als Basis für Exponat 3 diente. Von der Matte erzeugte ich einen Gipsabdruck und schaffte somit ein breites Spektrum an Strukturen im 3D-Bereich.

Muster goes Analog | Ausblick

Ann-Cathrin Zogbaum, 02.09.2013 | Generative Gestaltung Goes Analog bei Prof. Dr. Christine Goutrié

Ausgehend von meinem aktuellen Endstand des Projektes, würde ich in 3 weiteren Monaten auf die konkrete Anwendung meiner Idee eingehen. Ich zeige mit meinem Projekt, wie digitale, visuelle Parameter zurück in die Physis gebracht werden können. Der nächste Schritt wäre, zu untersuchen inwiefern mein Konzept zum Beispiel direkt mit Produktdesign verbunden werden kann.
Kann man die Idee mit Siebdruck verbinden? Kann das Konzept die Basis einer Lampe sein?
Diesen und ähnlichen Fragen würde ich mit zusätzlicher Zeit nachgehen.

Muster goes Analog | Generative Gestaltung

Ann-Cathrin Zogbaum, 02.09.2013 | Generative Gestaltung Goes Analog bei Prof. Dr. Christine Goutrié
///////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////
//Ann-Cathrin Zogbaum//////////////////////////////////////////////////////////////////
//4. Semester SoS 2013/////////////////////////////////////////////////////////////////
//Projekt//////////////////////////////////////////////////////////////////////////////
//Generatives Gestalten////////////////////////////////////////////////////////////////
//Frau Goutrie/////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////
//Überlagerung von Kreisen/////////////////////////////////////////////////////////////
//Digital und Analog ausgearbeitet/////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////



//Import Slider////////////////////////////////////////////////////////////////////////
import controlP5.*;
ControlP5 MyController;

  
//Grundvariabeln///////////////////////////////////////////////////////////////////////
int breite=1200;
int hoehe=900;
int hintergrund=220;


//Variabeln für die Slider und Buttons/////////////////////////////////////////////////
int durchmesser=90;
int anzahl_X=7;
int anzahl_Y=7;
int radius=90;
int winkel=45;
int schraffur=20;
boolean gcode = true;
boolean digital_analog_switch = true;


//Variabeln für Raster/////////////////////////////////////////////////////////////////
int nullPXY=90;
int startPXY=90;
int abstand=90;


//G-Code///////////////////////////////////////////////////////////////////////////////
PrintWriter output;
float fraestiefe =-2.7;
float fraesBreite=400; 


///////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////


void setup() {

  size (breite, hoehe);

  MyController = new ControlP5(this);
  PFont p = createFont("HelveticaNeue",14);
  MyController.setControlFont(p);
  MyController.setColorForeground(#00bbb0);
  MyController.addSlider("durchmesser",90,300,90,930,225,100,20); 
  MyController.addSlider("anzahl_X",1,7,7,930,285,40,20);
  MyController.addSlider("anzahl_Y",1,7,7,930,325,40,20);
  MyController.addButton("digital/analog",0,930,385,130,25).setId(1);
  MyController.addSlider("schraffur",5,30,20,930,450,60,20);
  MyController.addKnob("winkel",0,180,45,930,510,60);
  MyController.addButton("gcode",1,930,630,60,25);

}

///////////////////////////////////////////////////////////////////////////////////////

public void controlEvent(ControlEvent theEvent) {
  switch(theEvent.getId()) {
    case(1): 
    digital_analog_switch=!digital_analog_switch;
    break;
  }
}

///////////////////////////////////////////////////////////////////////////////////////

void draw() {

  background(hintergrund);

  noStroke();
  fill(1,20,30);
  rect(hoehe, 0, width-hoehe, height);

  PFont t = createFont("TitilliumText22L", 28);
  textFont(t);
  fill(0,187,176);
  text ("Muster goes Analog",920,135);


  //digitale Transparenz
  if(digital_analog_switch){
  pushMatrix();
  translate(nullPXY,nullPXY);
  for (int i=startPXY; i<=anzahl_X*abstand; i+=abstand) {
    for (int j=startPXY; j<=anzahl_Y*abstand; j+=abstand) { 
      fill(0,30);
      ellipse(i, j, durchmesser, durchmesser);
      }
    }
  popMatrix();
  }


  //analoge Transparenz
  else{
  pushMatrix();
  translate(nullPXY,nullPXY);
  for (int i=startPXY; i<=anzahl_X*abstand; i+=abstand) {
    for (int j=startPXY; j<=anzahl_Y*abstand; j+=abstand) { 
      stroke(40);
      //stroke(random(1,255),random(1,255),random(1,255));
      //strokeWeight(2);
      kreis(i, j, durchmesser/2, winkel, schraffur);
    }
  }
  popMatrix();
  }


  //G-Code
  if(gcode){
  initGCode("kreise");
  geschwindigkeit(300);
  pushMatrix();
  translate(nullPXY,nullPXY);
  for (int i=startPXY; i<=anzahl_X*abstand; i+=abstand) {
    for (int j=startPXY; j<=anzahl_Y*abstand; j+=abstand) { 
      kreis(i, j, durchmesser/2, winkel, schraffur);
    }
  }
  popMatrix();
  endGCode();
  gcode=false;
  }

}


///////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////



///////////////////////////////////////////////////////////////////////////////////////
//eigene Funktionen////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////
//Schraffur im Kreis

void kreis(float x, float y, float rad, float ang, float teilung) {
  for (int i = 0; i<teilung+1; i++) {

    float h= rad- (rad/(teilung/2)*i);
    float phi = acos(h/rad);
    float omega = phi + radians(90)+radians(ang);
 
    float xpos = cos(omega)*rad+x;
    float ypos = sin(omega)*rad+y;

    PVector richtung = new PVector(cos(radians(ang)), sin(radians(ang)));

    richtung.setMag(2*(sin(phi)*rad));
    float xpos2 = xpos+richtung.x;
    float ypos2 = ypos+richtung.y;

    line(xpos, ypos, xpos2, ypos2);

    if (gcode) G1_line(xpos,ypos,xpos2,ypos2,fraestiefe);
  }
}

///////////////////////////////////////////////////////////////////////////////////////
//G_Code

void G1_line(float x, float y,float x2, float y2, float tiefe){
  XY_G0_Code(x, y);
  Z_GCode(tiefe);
  XY_G1_Code( x2, y2);
  Z_GCode(3);
}

void XY_G1_Code(float X, float Y) {
  //mappt die x,y werte zwischen 0 und fraesBreite
  X=map(X, 0, width, 0, fraesBreite);
  Y=map(Y, 0, width, 0, fraesBreite);

  // rundet auf 0.001
  X=runden(X);
  Y=runden(Y);

  //schreibt X und Y in den output
  output.println("G1 X"+ X +" Y"+Y);
}

void XY_G0_Code(float X, float Y) {
  X=map(X, 0, width, 0, fraesBreite);
  Y=map(Y, 0, width, 0, fraesBreite);
  X=runden(X);
  Y=runden(Y);

  //schreibt X und Y in den output
  output.println("G0 X"+ X +" Y"+Y);
  /*schreibt X und Y in den output PLUS maximale geschwindigkeit; 
   doch VORSICHT dannach muss wieder die geschwindigkeit auf 
   normales maß eingestellt werden*/
}

void Z_GCode(float Z) {
  Z=runden(Z);
  output.println("G1 Z"+Z);
}

void geschwindigkeit(float geschwindigkeit) {
  output.println("F"+geschwindigkeit);
}

float runden(float zahl) {
  zahl= zahl*1000.0;
  zahl=round(zahl);
  zahl=zahl/1000.0;
  return zahl;
}

void initGCode(String name) {
  output = createWriter(name + ".ngc");
  // erstellt eine datei mit der endung .ngc mit dem geünschten namen 
  output.println("%");
  output.println("G 54");
}

void endGCode() {
  output.println("G1 Z10");// fährt die fräse 1cm nach oben
  output.println("M 02");// stopt den motor
  output.println("%");
  output.flush();
  output.close();
}


///////////////////////////////////////////////////////////////////////////////////////
//ENDE/////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////
02.09.2013 | Ann-Cathrin Zogbaum |