Recoding by Joachim Wedekind

Watch out a presentation by Joachim Wedekind at iCAP Université Claude Bernard Lyon 1 in July, 2017:

Recode Mondrian

It is time for the ‘Volcano of Art‘ to get interactive and to get ‘telepathic‘. The interactive machine will be presented first at the FdL 2013 in two virtual worlds. Join a performance in the Metropolis Grid on October 18, 2013.

See the draft videos to get an idea:

Recode Workshop in Rome

Get all about the LPM 2013 in Rome at: http://2013.liveperformersmeeting.net/

LPM 2013

For  ‘the live performers meeting’ LPM 2013 in Rome I uploaded in recodeproject.com a sketch of the routine SNEKAO using the artist name ROT-13 Ervare Farroretre. The sketch is a 100% recoding of the original routine SNEKAO programmed in FORTRAN in 1976-78. The recoding was done by Dietrich M. Scheringer. I will demonstrate live how one can just use this experimental code to do art.

4 steps from ‘recode’ to your own art [ a piece of historic value ‘by the code you use’ ]

Step 1: go to recodeproject.com and search for Ervare Farroretre – or click on the link: Ervare.

Step 2: Click on ‘Edit In Browser’ so you can change the code. Experiment with ‘the parameters’ used for a SNE KAO artwork. In case you want to be guided for now, then do it this way:

let the parameters float startx=20. and starty=60. as they are. Change the values for:

anzinx=28. / anziny=28. / feldx=10. / feldy=10. / anzstr=3. / pwaag=50. / psenk=50.

Here you find a picture where you can see how the new settings of the paramters shall look.

Step 3: Click on ‘Run’ so the code (sketch) is executed and enjoy the result.

Make a screen capture and copy it to a Paint programm. Then do some things you like: zoom, strech, make silly things and become a famous ‘parameterart artist’. Just as you can see it here …

Step 4: send your code to info@recodeart.com until 31.12.2015 with some information you like to include so it gets known in ‘2035’. More at http://2035.recodeart.com

SNERKT done :)

Here is the newest recoding 🙂

/** Sne Comp Art: Routine SNE RKT

originally developed in 1976 by Reiner Schneeberger
recoded in Processing in 2013 by Dietrich M. Scheringer
version 2.0

*/

void setup() // Setting up the area for drawing
{
size(400,600); // 0 <= x <= 1280, 0 <= y <= 1024
background(0); // backround colour: black
stroke(255); // colour of the lines: white
noLoop(); // execute method draw only once
}

void draw()
{
/* Parameters für snerkt */

float x1 = 10.; // Lower boundary for x-ccodinates
float x2 = 370.; // Upper boundary for x-coodinates
float y1 = 10.; // Lower boundary for y-ccordinates
float y2 = 595.; // Upper boundary for y-coordinates
float anzpkt = 1000.; // Maximal number of points
float amplx = 12.; // Maximal distance between two consecutive points in direction of the x-axis
float amply = 18.; // Maximal distance between two consecutive points in direction of the y-axis
float startx; // Start of the number of consecutive lines in the direction of the x-axis
float starty; // Start of the number of consecutive lines in the direction of the y-axis
float period = 12.; // Defines the period of repetition of the number of consecutive lines

for (int i=1; i <= 40; i++)
{
startx = rad(4., 350., 999.);
starty = rad(400., 450., 999.);
snerkt(x1, x2, y1, y2, anzpkt, amplx, amply, startx, starty, period);
}

} // end of draw
void snerkt(float x1, float x2, float y1, float y2, float anzpkt, float amplx, float amply, float startx, float starty, float period)
{
float xl = min(x1,x2);
float xr = max(x1,x2);
float yu = min(y1,y2);
float yo = max(y1,y2);

float x_new = min(max(xl,startx),xr);
float y_new = min(max(yu,starty),yo);
float x_old;
float y_old;

int k = (int) rad(1.1,2.9);
int l = (int)round(abs(anzpkt)) + (int)k – 2;
float h;

for (int i = k; i <= l; i++)
{
x_old = x_new;
y_old = y_new;
h = rad(0., TWO_PI, period);
if (i % 2 == 1)
{
y_new = y_old + sin(h)*amply;
}
else
{
x_new = x_old + sin(h)*amplx;
}
if (x_new >= xr || x_new <= xl || y_new >= yo || y_new <= yu)
{
break;
}
else
{
line(x_old,y_old, x_new, y_new);
}
}
}

/*———————————————————————*/

// Methods for generating random numbers

float [] zzuf = {0., 3.1415926, 3.1415926};
float [] rrad = {0., 3.1415926, 3.1415926, -1., 3.1415926, 3.1415926};
float rrga = 3.1415926;
float pi = 3.1415926;
float e = 2.71828182;

float rad(float von, float bis)
{
zzuf[1] = amod(zzuf[1]*pi + zzuf[2],1.);
zzuf[2] = amod(zzuf[2]*e,1.) + 1.;
return zzuf[1]*abs(von – bis) + min(von,bis);
}

float rad(float von, float bis, float period)
{
float izaehl = 0.;
if (rrad[3] != period)
{
rrad[3] = period;
rrad[4] = rrad[1];
rrad[5] = rrad[2];
izaehl = 0.;
}
izaehl = izaehl + 1.;
if (izaehl >= period)
{
rrad[1] = rrad[4];
rrad[2] = rrad[5];
izaehl = 1.;
}
rrad[1] = amod(rrad[1]*pi + rrad[2],1.);
rrad[2] = amod(rrad[2]*e, 1.) + 1.;
return rrad[1]*abs(von – bis) + min(von, bis);
}

// modulo-calculation for numbers of type float

float amod (float x, float y) // calculates x modulo y
{
while ( x >= y)
{
x = x – y;
}

return x;
}

And this happens, when you use it:

 

Soon I there will be the documentation online. The “rad” routine makes random numbers. In this example: startx will be in the range between 4 and 350 and sequence repeating after 999 numbers

SNELIN is back

Dietrich M. Scheringer made it 🙂

Here there is the code you may use to experiment:

/** Sne Comp Art: Routine SNE LIN

originally developed in 1979 by Reiner Schneeberger
recoded in Processing in 2013 by Dietrich M. Scheringer
version 2.0

*/

void setup() // Setting up the area for drawing
{
size(600,600); // 0 <= x <= 1280, 0 <= y <= 1024
background(0); // backround colour: black
stroke(255); // colour of the lines: white
noLoop(); // execute method draw only once
}

void draw()
{
/* Parameters for snelin */

float anzpkt = 7.; // number of points
float anzstr = 80.; // number of repetitions of drawing
float [] xwerte = {0., 40., 300., 590., 300., 500., 100., 5.}; // Array with anzpkt-elements // x-coordinates of the points + xwerte[0]
float [] ywerte = {0., 20., 580., 25., 50., 500., 500., 410.}; // Array with anzpkt-elements // y-coordinates of the points + ywerte[0]
float pstrek = 7.; // pstrek > 0 –> scaling down next drawing
// pstrek < 0 –> scaling up next drawing

snelin(anzpkt, anzstr, xwerte, ywerte, pstrek);

}

void snelin(float anzpkt, float anzstr, float [] xwerte, float [] ywerte, float pstrek)
{
float [] x = new float[61];
float [] y = new float[61];

float b = 0.01*pstrek; // percentage of scaling up (pstrek < 0) or scaling down (pstrek > 0)
int n = min(round(abs(anzpkt)),59);
int m = round(abs(anzstr));
int kk;

for (int i=1; i <= n; i++)
{
x[i] = xwerte[i];
y[i] = ywerte[i];
}
for (int j=1; j <= m; j++)
{
x[0] = x[1];
y[0] = y[1];
for (int k=1; k <= n; k++)
{
kk = (k+1) % (n+1);
line (x[k], y[k], x[kk], y[kk]);
}
for (int k=1; k <= n; k++)
{
kk = (k+1) % (n+1);
x[k] = b*(x[kk] – x[k]) + x[k];
y[k] = b*(y[kk] – y[k]) + y[k];
}
}

} // end of snelin

And this you will get:

SNE KAO in Processing

Hier ein Textauszug aus Programmierte Fälschungen Digitaler Kunst als Museumsprojekt? Software dreht schneller als alle Innovationen vor ihr und Softwarekunst wird schneller museal als jede Kunstform zuvor.

von Reiner Schneeberger

” … Als Parameter, die der Anwender an ein entsprechendes Programm-Modul übergeben musste wurden in SNE KAO festgelegt: Größe und Anzahl der Elemente (Kästchen) in x- und y-Achse, Zahl der Linien innerhalb eines Kästchens und eine Angabe zur Verteilung von Horizontal und Vertikalen Elementen. War die Summe von Horizontal und Vertikal kleiner Hundert entstanden „Löcher“ in dem Werk. …”

Bild A

Bild B

Bild C

Bild D

	Bild A	Bild B	Bild C	Bild D
Anzahl der Felder waagrecht (x-Achse):	40	6	6	6
Anzahl der Felder senkrecht (y-Achse):	60	4	4	4
Länge eines Feldes in x:	10	100	100	100
Länge eines Feldes in y:	20	70	70	70
Anzahl der Striche in einem Feld:	2	10	2	50
Prozentsatz waagrechter Felder:	70	30	40	0
Prozentsatz senkrechter Felder:	30	60	60	50

SNE KAO

Dietrich M. Scheringer hat für recodeproject.com die Routine SNE KAO unter Processing realisiert …

Hier ist der Quellcode:

/** Sne Comp Art: Routine SNE KAO

originally developed in 1976 by Reiner Schneeberger
recoded in Processing in 2013 by Dietrich M. Scheringer
version 3.0

*/

void setup() // Setting up the area for drawing
{
size(400,600); // defines the dimension of the display window in units of pixels
background(0); // backround colour: black
stroke(255); // colour of the lines: white
noLoop(); // execute method draw only once
}

void draw()
{
/* Parameters for snekao */

float startx = 20.; // starting point in direction of x-axis
float starty = 60.; // starting point in direction of y-axis
float anzinx = 6.; // number of fields in direction of x-axis
float anziny = 12.; // number of fields in direction of y-axis
float feldlx = 50.; // field lenght in direction of x-axis
float feldly = 30.; // field length in direction of y-axis

float anzstr = 10.; // number of lines per field
float pwaag = 40.; // percentage of fields filled with horizontal lines
float psenk = 55.; // percentage of fields filled with vertical lines
// pwaag + psenk <= 100. !

snekao(startx, starty, anzinx, anziny, feldlx, feldly, anzstr, pwaag, psenk);
}
//——————————————————————————–

void snekao(float startx, float starty, float anzinx, float anziny, float feldlx, float feldly, float anzstr, float pwaag, float psenk)

{
float strtx = 0.; // local variables
float strty = 0.;
float start = 0.;
float delta = 0.;
float h = 0.;

int istr = round(abs(anzstr));
int inx = round(abs(anzinx));
int iny = round(abs(anziny));
float pdicht = pwaag + psenk;

if (istr == 0)
{
pdicht = 0.;
}

for (int i=1; i <= iny; i++)
{
strty = float(i-1)*feldly + starty;
for (int j=1; j <= inx; j++)
{
strtx = float(j-1)*feldlx + startx;
h = random(0.00001,100.);
if (h > pdicht)
{
continue; // next loop
}
else if (h > pwaag)
{
delta = feldlx/float(istr);
start = strtx;
for (int k=1; k <= istr; k++)
{
line(start, strty+feldly,start, strty);
start += delta;
}
}
else
{
delta = feldly/float(istr);
start = strty;
for (int m=1; m <= istr; m++)
{
line(strtx+feldlx,start,strtx,start);
start += delta;
}
} // end of if … else if … else …
} // end of inner for-loop
} // end of outer for-loop
} // end of snekao

Dieser Code geht in Processing direkt. Dazu die Software von processing.org downloaden. Dann den SNEKAO “Scetch” laden und los geht es.

Das Ganze sieht dann etwa so aus:

Zum Vergrößern einfach auf das Bild klicken.

Der SNEKAO Scetch kann auch online unter recodeproject.com direkt genutzt werden. Ein Herunterrladen der Processing Software auf Ihren PC ist dann nicht erforderlich:

Einfach eine andere Umsetzung nehmen und diese im Edit-Fenster überschreiben. So sieht das dann in etwa aus:

MARION

Im Jahre 1982 ging die Kunstmaschine SNE ART in Lizenz an die Fachhochschule für Gestaltung in Bielefeld. Als historischer Auslöser des Projekts Recode MARION kann – im Nachhinein und viele Jahre später – auch die Implementation der Kunstmaschine SNE ART durch den Mitarbeiter der Fachhochschule, Dietrich M. Scheringer, betrachtet werden.

Implementiert wurden alle 2D-Module der Kunstmaschine ebenso wie das Projektionsmodul SNE PER, seinerzeit unter Verwendung der Sprache Fortran 77 auf einem Prozessrechner (!) der Firma Krupp Atlas. “Bilder” wurden zu dieser Zeit geplottet, die Ausgabe der Bilder auf grafikfähigen Bildschirmen war noch nicht das Gebot der Stunde.

Um die Erstellung von Graphiken bis zu einem gewissen Grade zu automatisieren, wurde auch ein Graphikmonitor Marion, entwickelt von Schülern Reiner Schneebergers, Klaus Klawonn, Günther Pajonk, Hans Scheerer und Dietrich M. Scheringer, implementiert. Marion erlaubte die Eingabe einer beliebigen Folge von Routinen der Kunstmaschine zusammen mit den für die Routinen erforderlichen Parametern. Die Abarbeitung der Routinen erfolgte dann im Batchbetrieb. Diese Vorgehensweise förderte und unterstützte die Konzeption und Erzeugung von teilweise hochkomplexen Graphiken (z.B. auch Muster für Textilien). Als weiterer Vorteil des Graphikmonitors erwies sich die Speicherung von Graphiken in Dateien, nicht als Bilder, sondern als beliebig oft abrufbare und reproduzierbare Folgen von fertig parametrisierten Routinen.

Text: Dietrich M. Scheringer, 2013

Random in SNE ART

Hier ein Einblick in die Anfänge …