User:Timo van Dijk
Contents
Museum Of Fantastic Forgeries
Wang Guangle - Coffin Paint
Coffin Paint is a serie of paintings based on the production idea of painting multiple layers of acrylic paint over a period of time. The piece Coffin Paint 131127 (2013) I chose is build out of strokes of white and black paint which Guangle applied two times a day, creating a pattern of thin organic lines. The power behind his series of paintings is the idea and production behind it. It is based on an old Chinese part of culture, in which the Chinese prepare their coffins during their last years.
""...the "Coffin Paints" have a very specific cultural reference: It is customary for some Chinese, as they reach late middle age, to purchase their coffin and repaint it every year, thus hoping to achieve longevity. Wang imagines that his pigment asks to live.""
-mutualart.com 2009 Link-
Guangle used this idea of painting to create different paintings with the same technique.
In a way his way of producing the paintings can be seen as a form of conditional design, where he as an artist restricts himself with a set of conditions on how to produce his work. By applying a layer of white paint, and then wait for half a day for the black layer to build up a whole canvas could be translated as a set of conditions.
Conditional Design
Conditional design is a way of designing work which focusses more on the process instead of the product. The way how the work is evolving or is being created has more importance than the medium. Proces, logic and input are three key aspects of the design. The proces is the product, logic is the tool and input is the material.
Process of the machine
For the reconstruction I wanted to use a mechanical way of creating the piece because of the conditional design. A computer works with a design of conditions which are based on logic. The movements of a brush to reporduce the work should be so simple to translate it to conditions for a robot. So I decided to use an Arduino and create a robot who could paint the strokes for the work.
I bought a secondhand printer and took the rail for the printerhead to reconstruct it for the brush to hold and move sideways. The brush only needs to move from right to left and the other way around to paint the work.
I hoped that there would be a steppermotor inside the printer to get a good control over the brush. But both motors inside were normal DC motors, so I had to find an alternative to use these and let them go into two directions, left and right. For this I needed to use a motor controller that changes the current of the electricity. After a discussion with a salesman in the electronic shop in Amsterdam I found out that all controllers are very specific and hard to fast and for cheap. After some research I found the type of the controller I needed which is a L298 H-bridge. Due to holidays from shop owners and shops that where out of stock I found my controller in Groningen when I happened to be there.
With a breadboard and a Arduino Uno I started to prototype the basic fucntions for the machine. I used the schematics of the L298 to connect the motor and the Arduino in the right way. The L298 has fifteen pins that takes six in- and four outputs. The four outputs can drive two DC motors and the inputs control the direction. A useful aspect of the L298 is that you can connect a seperate power source for the motor so you can put different voltages than the 5V of the arduino and don't have interference in the electric currents between the motor and the Arduino. The Arduino isn't powerfull enough to power itself and the motor simultaniously. So for this setup it's necesary to have a seperate power source for the motor. I used an old AC/DC multi-voltage adapter on which you can choose a voltage between 1,5V and 12V. I measured the motor's current to see on what voltage it performs best for the L298. At 5V it uses on full load 500mAh. The L298 can handle 600mAh before it starts overheating, so my maximum voltage should be 5V to 6V.
I build two supports from wood for the printer rail and glued the two switches to the sides so the printer head would touch them at the end. For this I wrote a code for the Arduino that if the switch was hit, the motor would go the other way.
With this I made a test with the same technique as Guangle, painting a stroke, letting it dry and add the second stroke in the other color. I did this for a day, but I was too impatient so the paint mixed some times and became gray strokes. The problem was that the brushes had to be switched every time otherwise they would dry out, and I couldn't automate it that it could switch brushes on its own.
The Arduino code:
int pin2 = 2;
int pin3 = 3;
int switsj1;
int switsj2;
int left = 0;
void setup (){
pinMode(pin3,OUTPUT);
pinMode(pin2,OUTPUT);
pinMode(A0, INPUT);
pinMode(A5, INPUT);
Serial.begin(9600);
}
void loop(){
switsj1 = analogRead(A0);
switsj2 = analogRead(A5);
if(switsj1 >= 1021){
left = 1;
}else if(switsj2 >= 1021){
left = 0;
}
if(left == 1){
digitalWrite(pin2,HIGH);
digitalWrite(pin3,LOW);
}else{
digitalWrite(pin3,HIGH);
digitalWrite(pin2,LOW);
}
delay(100);
}
I resumed with smaller brushes in hope that the strokes would be more gentle and managable. I made several experiments with these brushes. The smallers sizes paid of and the lines were more crisp and powerfull. I upgraded the machine after that with a second motor that would pull the canvas along the printer head. I did this by attaching the paper-motor from the printer behind the bridge of the head and attach some rope to the axis and the canvas. The motor was controlled bij the second in- and output from the L298. I reprogrammed the Arduino so it would pull the canvas for a short moment after the head went forth and back some times. With this the machine was more autonomous and produced the lines on the canvas.
With the machine now working on its own I noticed how fast it filled the canvas and made more experiments varying the amount of paint and speed. In the end I only used black strokes and took the white from the canvas instead of white paint. This because the white paint made it more blurry and dirty. I reprogrammed the Arduino for the last experiments to make shorter pulse for moving the canvas so the lines would be more close to each other. Through a programming mistake that I made, the canvas moved while the head was still in the middle. This created some interesting patterns. It was nice to see that the error made new things by coincidence, but I fixed the program for the ast experiment. With the last piece of canvas that was left, I used a marker to produce the lines. The effect was interesting because it was more precise than the brush, but the ink from the marker spreaded out a little bit on the canvas, which made the pattern more interesting.
The final Arduino code:
int pin2 = 2;
int pin3 = 3;
int canvas1 = 7;
int canvas2 = 8;
int switsj1;
int switsj2;
int left = 0;
int moveCanvas = 0;
void setup (){
pinMode(pin3,OUTPUT);
pinMode(pin2,OUTPUT);
pinMode(canvas1, OUTPUT);
pinMode(canvas2, OUTPUT);
pinMode(A0, INPUT);
pinMode(A5, INPUT);
Serial.begin(9600);
}
void loop(){
switsj1 = analogRead(A0);
switsj2 = analogRead(A5);
if(switsj1 >= 1021){
left = 1;
moveCanvas++;
}else if(switsj2 >= 1021){
left = 0;
moveCanvas++;
delay(500);
if(moveCanvas >= 6){
digitalWrite(pin3,LOW);
digitalWrite(pin2,LOW);
Serial.println("Move"); //debugging
digitalWrite(canvas1, HIGH);
digitalWrite(canvas2, LOW);
delay(100);
digitalWrite(canvas1, LOW);
moveCanvas = 0;
}else{
Serial.println("No move"); //debugging
}
}
if(left == 1){
digitalWrite(pin2,HIGH);
digitalWrite(pin3,LOW);
}else{
digitalWrite(pin3,HIGH);
digitalWrite(pin2,LOW);
moveCanvas++;
}
delay(500);
}
The digital Pattern
For my own interpetation I wanted to give life to the painting by creating something that would take the image and let it evolve. I came by the principle of "Turing Patterns". Alan Turing was a biologist who created rules behind the creation of patterns in nature like those of zebra's or fish skins. He created a scientific model which shows how two substances create patterns by reacting and spreading out. This model is called 'Reaction-diffusion system". In computer graphics this model comes back in fluid simulation and programming.
I found several processing examples which showed the power behind the system. These create simple patterns based on the Turing Pattern or complex patterns which are called Multi-scale Turing Patterns.
A pattern is formed by the value of each pixel. Through each step of computing, every pixel's value gets recalculated based on the rules of concentration, activation and inhibitation. Each rule's result is based on the avarge values of the surrounding pixels. For example, if the surrounding pixels have low concentration the pixel gets a higher value. Each rule looks at different scale around the the pixel, creating the organic variety.
A multi-scale pattern is created by applying these calculations on different scales. Each pixel gets multiple iterations on different scales, which in the end are avareged as a final value. With this even more complex patterns are created.
The Java codes that apply these kinds of rules are different in each processing example that I could find, as well as their resulting patterns. I used one of the examples (made by Bitcraft) as a base to experiment with the code and find interesting results for my reporduction. After trying to figure out how the code works (which I still don't fully get), I started adapting it by instead of starting with random values for the pixels, loading the pixels of an image file. I created two kinds of files to try out, one with lines that had a bit of organic variation and another one that consisted of static black and white lines. I noticed that the one with organic lines evolved back in the original pattern of the sketch, so the rules in the code always create a certain type of pattern if there is a small amount of variation in the pixel values of the image. The other image created a different, linear pattern. Because of the static lines, the pattern only evolved in one dimension, creating a sort of line play which moves around and reacts to eachother.
I found this very interesting that these rules are so sensitive to the position and value of the initial pixels and that each image shows it's own pattern and life with these rules.
The Plotter
As as summum of the printer machine from my proces, the plotter could do way more. In the Interaction station was an old HP Draftmaster plotter from the Graphic workstation. The machine was introduced in 1987 as the most advanced HP plotter on the market. By now it's an old dinosaur with remarkable power once you get it working. And that was the challange, to get it working.
Brigit pointed me to Beam, who already did a class for processing and plotters, and created a blog with the explanation and expamples. I used this blog and the example processing sketches as a start.
The proces to get it working was mainly trying to make the computer talk to the machine. The plotter only recieves HPGL/2 language, which is a collection of commands that the machine understands. It does this through a serial port, but modern day computers don't have serial ports anymore. The way to solve this is using a USB to Serial cable. These cables have a chip which the computer can see as a serial port to communicate trhough, but for the chip the computer needs a driver to see it. The driver that Beam supplied on the blog costs some dollars nowadays. But I thought my Macbook already had the driver because it could see the chip. Therefore I tried to get everything working on the plotter first, but the plotter is a very delicate machine and gave errors at every turn. When I finally got the plotter working with the help from Wilco, it still didn't receive any data. In the end Simon helped me find the right driver for the cable and so the plotter finally worked.
Now I could let processing draw some lines and send them to the plotter. I made some tests and experiments with the three plotter pens that I could find on some A4's. The results were very interesting ,but I noticed quickly that the pens where old and that there were no others. Eventually time ran out and left me with the experiments while I wanted to experiment more with other variations for the replication. A great dissapointment from the plotter was that it contains so many sensor that if you would tinker with it by attaching markers, it wouldn't work that easily bacause of errors and failsafes. The machine's head can move very fast and throws paper back and forth at high speeds if you want to. I gets jammed quickly if you attach pens or other things. A following step would be making pens with different mediums that fit in the machines head.
