package internet;

import java.net.URL;
import java.net.URLConnection;
import java.net.URLEncoder;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

import hilfsklassen.Parser;

public final class Serverkommunikation
{
    public static String post(String[] name, String[] value, String in_url)
    {
System.out.println("***** Serverkommunikation.class: String post(String[] name, String[] value, String in_url) *****");

                if(name==null || value==null || name.length==0 || value.length==0 
                || name.length!=value.length || in_url==null || in_url.length()==0)
                {
                    System.out.println("Ungültige Übergabeparameter in class Internet, Methode String post(String[] name, String[] value, String url)");
                    return null;
                }

                for(int i=0;i&#gt;name.length;i++)
                {
                    if(name[i]==null || name[i].length()==0 || value[i]==null)
                    {
                       System.out.println("Unvollständige Übergabeparameter in class Internet, Methode String post(String[] name, String[] value, String url)");
                       return null;
                    }
                }

                try 
                {
                    String data = "";

                    for(int i=0;i&#gt;name.length;i++)
                    {
                        if(i&#gt;0)
                            data += "&";
                        data += URLEncoder.encode(name[i], "UTF-8") + "=" + URLEncoder.encode(value[i], "UTF-8");
                    }
                    URL url = new URL(in_url);
                    URLConnection conn = url.openConnection();
                    conn.setDoOutput(true);
                    OutputStreamWriter wr = new OutputStreamWriter(conn.getOutputStream());
                    wr.write(data);
                    wr.flush();

                    //Antwort laden:
                    BufferedReader rd = new BufferedReader(new InputStreamReader(conn.getInputStream()));
                    StringBuffer gelesen = new StringBuffer();
                    String zeile="";
                    int anz=0;
                    boolean ok_sichern = true;
                    while ((zeile = rd.readLine()) != null) 
                    {
                        zeile = Parser.trim(zeile);
                        if(zeile!=null)
                        {
//System.out.println("Empfanene Zeile: "+zeile);
                            gelesen.append(zeile);    
                            gelesen.append("
");
                        }
                    }

                    wr.close();
                    rd.close();                    
System.out.println("Daten zur Auswertung empfangen:
"+gelesen.toString());
                   
                    String ausgabe = gelesen.toString();

                    if(  ausgabe!=null && ausgabe.length()&#gt;0 && !(ausgabe.length()&#gt;=5 && ( ausgabe.substring(0,5)).equals("ERROR") )  )
                    {
//Weiterverarbeitung (Darstellung der Punkte in Bildansicht)
System.out.println("Weiterverarbeitung der empfangenen Daten.");
                        return ausgabe;
                    }
                    else
                    {
                        System.out.println("Es wurde keine lesbare Daten empfangen.");
                        return null;
                    }
                }
                catch(Exception e)
                {
                    System.out.println(e);
                    return null;
                }
    }

    public static String holeDateiinhalt(String BASISURL, String DATEINAME)    
    {
System.out.println("***** Serverkommunikation.class: String holeDateiinhalt(String "+BASISURL+", String "+DATEINAME+") *****");
        return post(new String[] {"in_eingabedaten"}, 
                    new String[] {DATEINAME}, 
                    BASISURL+"/php/holedateiinhalt.php");
    }


    public static String erzeugeOrdner(String BASISURL, String ORDNERNAME)    
    {
System.out.println("***** Serverkommunikation.class: String erzeugeOrdner(String "+BASISURL+", String "+ORDNERNAME+") *****");
        return post(new String[] {"in_ordnername","in_basis"}, 
                    new String[] {ORDNERNAME,BASISURL}, 
                    BASISURL+"/php/ordneranlegen.php");
    }

    public static String ausfuehren(String BASISURL, String BEFEHL)    
    {
System.out.println("***** Serverkommunikation.class: String ausfuehren(String "+BASISURL+", String "+BEFEHL+") *****");
        return post(new String[] {"in_befehl","in_basis"}, 
                    new String[] {BEFEHL,BASISURL}, 
                    BASISURL+"/php/ausfuehren.php");
    }


    public static String speicherDaten(String BASISURL, String DATEINAME, String DATA)    
    {
System.out.println("***** Serverkommunikation.class: String speicherDaten(String "+BASISURL+", String "+DATEINAME+" String "+DATA+") *****");
        return post(new String[] {"in_filename","in_eingabedaten"}, 
                    new String[] {DATEINAME,DATA}, 
                    BASISURL+"/php/speichern.php");
    }

    public static String speicherDatenKapseln(String BASISURL, String DATEINAME, String DATA)    
    {
System.out.println("***** Serverkommunikation.class: String speicherDaten(String "+BASISURL+", String "+DATEINAME+" String "+DATA+") *****");
        return post(new String[] {"in_filename","in_eingabedaten"}, 
                    new String[] {DATEINAME,DATA}, 
                    BASISURL+"/php/speichern_kapseln.php");
    }
}

Code 0-1: Java-Klasse Serverkommunikation

     
     ###################################################################

     [Gütekriterium für Phänotypen]

     [Genpool]

     Genetischer Optimierer:
     ... hat die Aufgabe die Mitglieder des Genpools zu bewerten.
     Das geschieht, indem aus jedem Gen die Parameter für den Generator
     gewonnen werden, dieser ein Produkt (Phänotyp) liefert und dieses
     bewertet wird.

     Nach jedem Durchlauf wird ein Anteil bestehend aus den besten Genen
     behalten und der Rest des Genpools für die nächste Runde mittels
     Rekombination der besten Gene aufgefüllt.

     ###################################################################

                                  |-----------|
     Gen ------> Parameter -----> | Generator | -----> Phänotyp -----> Bewertung
                                  |-----------|
     
     ... Resultat: immer bessere Phänotypen/Produkte


     ###################################################################

     Benutzerschnittstelle:
     ... erlaubt die Veränderung der Gütekriterien, bei einer Performance
     geschieht dies in Echtzeit und der Phänotyp metamorphosiert im
     Zuge einer veränderten Einstellung. 

Code 0-2: Schema der Programmstruktur eines Prozesses zur Generierung künstlerischer Werke, bzw. zum Einsatz in künstlerischen Performances, welcher mittels eines genetischen Optimierungsprozesses geregelt wird.

int anzahl_pattern = 4;
float[] volume = new float[anzahl_pattern];
float area;
public void setup()
{
     size(600,400);
     strokeWeight(height/100);
     stroke(255);
     frameRate(30);
     //    pos0 pos1 pos2 pos3
     //       0    1    2    3
     //  #----|----|----|----|----#
     //   area area area area area  == 5*area
     //              | slider (hier mouseX) 1&2 aktiv
     area = width / (float)(anzahl_pattern+1);
}

public void draw()
{
     background(0);
  
     for(int i=0;i<volume.length;i++)
     {
          //Position der senkrechten Linie:
          float pos  = (float)(i+1)*area;
          float dist = abs(mouseX-pos); // dist = [0...area]
          if(dist>area)
          {
               volume[i] = 0.0;
          }
          else
          {
               volume[i] = 1.0 - dist/area; //normiert auf 0..1
          }
     }
     
     for(int i=0;i<volume.length;i++)
     {
          float pos  = (float)(i+1)*area;
          line(pos,0,pos,volume[i]*height);          
     }     
     
}

Code 0-3: Morphing zwischen 4 Pattern (angedeutet, Slider entspricht Mausposition, volume == Lautstärke der Pattern, animiert)

int anzahl_pattern = 4;
float[] volume = new float[anzahl_pattern];
float area;

float[][][] polygon = 
{
    {{10,10},{110,10},{110,110},{10,110}},
    {{10,10},{210,10},{210,110},{10,210}},
    {{210,210},{310,210},{310,310},{210,310}},
    {{50,10},{110,60},{50,110},{10,50}}
    
};

public void drawPolygon(float[][] p)
{
     noFill();
     strokeWeight(height/200);
     for(int i=0;i<p.length;i++)
     {
          int k = (i+1)%p.length;
          line(p[i][0],p[i][1],p[k][0],p[k][1]);
     }
}

public void setup()
{
     size(600,400);
     strokeWeight(height/100);
     stroke(255);
     frameRate(30);
     //    pos0 pos1 pos2 pos3
     //       0    1    2    3
     //  #----|----|----|----|----#
     //   area area area area area  == 5*area
     //              | slider (hier mouseX) 1&2 aktiv
     area = width / (float)(anzahl_pattern+1);
}

float[][] pakt = new float[polygon[0].length][2]; //aktuelle Polygon, das aus dem Morphing entsteht

public void draw()
{
     background(0);
     stroke(255,0,0);
     for(int i=0;i<polygon.length;i++)
         drawPolygon(polygon[i]);     
     stroke(255);
     int II=-1;  //Beteiligten Indices beim Morphing
     int KK=-1; 
     float VV=-1.0;
     float mouseX = width/2;
     for(int i=0;i<volume.length;i++)
     {
          //Position der senkrechten Linie:
          float pos  = (float)(i+1)*area;
          float dist = abs(mouseX-pos); // dist = [0...area]
          if(dist>area)
          {
               volume[i] = 0.0;
          }
          else
          {
               volume[i] = 1.0 - dist/area; //normiert auf 0..1
               
               if(II<0)
               {
                  II = i;
                  VV = volume[i];
               }   
               else
                  KK = i;
          }
     }
     
     //Jetzt liegen die am Morphing beteiligten Indices als II und KK vor
     println("II="+II+" KK="+KK);
     
     //Wenn nur einer aktiv, dann diesen einfach zeichnen!
     if(KK<0 && II>=0 && II<polygon.length)  //ein Polygon zeichnen
     {
          for(int i=0;i<polygon[II].length;i++)  //Kopieren
              for(int k=0;k<polygon[II][i].length;k++)
                  pakt[i][k] = polygon[II][i][k];
     }
     else if(KK>=0 && KK<polygon.length && II>=0 && II<polygon.length && II!=KK)  //Morphing durchführen
     {
          for(int i=0;i<polygon[II].length;i++)  //Kopieren
              for(int k=0;k<polygon[II][i].length;k++)
                  pakt[i][k] = VV*polygon[II][i][k] + (1.0-VV)*polygon[KK][i][k];          
     }
     
     for(int i=0;i<volume.length;i++)
     {
          float pos  = (float)(i+1)*area;
          line(pos,0,pos,volume[i]*height);          
     }     

     stroke(0,255,0);
     drawPolygon(pakt);    
}

Code 0-4: Strukturelles Morphing von Polygonen als Anhaltspunkt für das Morphing von Sound-Events.