ICM Midterm: Portrait of Mao

UPDATE 22 Feb 2009:
I have written a new concise description of the Portrait of Mao:

The Portrait of Mao is a 42 inch by 42 inch color print on archival paper. The image was generated by a Processing sketch I wrote, which reads pixel color data from an image file and replaces each pixel with a text character with the same color as the original pixel. In the case of the Portrait of Mao, the source image was obtained from a Cultural Revolution-era LP cover of revolutionary songs featuring Chinese leader Mao Zedong and a bright, motley array of proletarian workers, representing different ethnic groups in China. My Processing sketch used this source image and replaced the pixels with the Chinese-language text of The Little Red Book AKA Quotations from Chairman Mao Zedong, a required text for every Chinese citizen during the Cultural Revolution.

In creating the Portrait, I wished to explore how text and images play a role in political propaganda and how they serve to construct a cult of personality around a paternal and pop-cultural icon. We know that words and images have persuasive and seductive powers, but how, and why? In reappropriating the propagandistic images and text and by depicting the controversial leader in an irreverently kitsch, Pop-Art way (Andy Warhol’s Mao paintings are an obvious point of reference), I sought to deconstruct the aura surrounding such a well-known figure who is still revered by millions in China.

The fusing of words and images also plays on the pictographic and ideographic nature of the graphemes used in the Chinese language. Chinese characters are simultaneously words, images, and symbols. In the Portrait of Mao they become both semantic and graphic building blocks of a text, an image, and an ideology.

Original blog post from 29 Oct 2008:

I presented my ICM midterm project yesterday.  I wanted to explore how text and images play a role in political propaganda and how they serve to construct a cult of personality.

The image above is just a scaled-down version, the real version is a 42 inch x 42 inch poster.  The poster consists of a text mosaic derived from a scan of a Cultural Revolution era LP cover of propaganda songs.  My Processing program reads the color information in the pixels of the source JPG and replaces it with characters from the Chinese version of The Little Red Book.

Here is a close up of the text mosaic, taken from the Technicolor Dream Coat guy on the bottom right.

I hope to one day present the poster in an over-the-top kitsch setting.  I want to frame it with red Christmas lights and build a “shrine” to the Chairman, with flowers and Tsing Dao beer bottles.  I also have another poster in the works featuring the Dear Leader composed out of the Korean-language text of his On the Juche Idea.  Ultimately, I want to create a triptych, but I haven’t decided on a third subject yet.  Uncle Ho?  Or maybe Grandpa Marx?

Here is a snapshot of me presenting the piece to my class.  Photo credit: Catherine White.

ICM Midterm Proposal

For my midterm project, I want to escape from the computer screen and work in a medium that has the potential to be larger format, more tactile, and less ethereal.  Using the text mirror example from Learning Processing as a departure point, I am working on a Processing program that will allow me to create high resolution image files that will allow me to print a series large format posters.  Perhaps it is easier to show than to tell, so here is an example of a work in progress.

I started with the iconic image of Mao Zedong in Tiananmen Square.  Then I redrew the image using the text of the The Little Red Book.

Here is a close up:

I still have some work to do to address the spacing issues around the punctuation marks, which creates too much black space.  Ultimately, I intend to provoke a dialogue about the relationship between text and images, especially in the Chinese ideographic writing system, as well as explore the the roles that text and images play in political propaganda and the construction of ideology.

P-Comp: Sine Wave of Doom AKA the Poser Theremin

In this week’s lab, we learned about Serial Duplex and continued to learn more about how to get Arduino and Processing to talk to each other.

In my spin on the lab, I hooked up 2 potentiometers through the Arduino to control the frequency and panning of a sine wave in Processing that is manifested on screen and as audio.  I don’t know why I chose red and blue for the sine waves.  Maybe I’ve been watching too much TV coverage of the presidential campaign.  In any case, the effect is that of a sine wave of doom or a poser theremin.

To get Processing to play sound, I used the Minim library.  I basically poached some example code from the Minim site and tweaked it so the sound responds to analog ins from the Arduino instead of mouseX and Y in the original sketch.


I hope to use more exciting sensors later on to make it more expressive and musical when I get back from fall break next week, but it took me awhile to tweak the software side of things and the computer store was already closed by the time I got around to this. Here it is in action:

My digital camera didn’t pick up the audio very well, so here is an MP3 of some “music” I made.  And here is another attempt.

And finally, here is the Processing code:

import processing.serial.*;     // import the Processing serial library
import ddf.minim.*;
import ddf.minim.signals.*;

Serial myPort;                  // The serial port
AudioOutput out;
SineWave sine;
int sensors[] = new int[2];

int passX;
int passY;

void setup(){
myPort = new Serial(this, Serial.list()[0], 9600);
size(512, 200);
// always start Minim before you do anything with it
// get a line out from Minim, default sample rate is 44100, bit depth is 16
out = Minim.getLineOut(Minim.STEREO, 512);
// create a sine wave Oscillator, set to 440 Hz, at 0.5 amplitude, sample rate 44100 to match the line out
sine = new SineWave(440, 0.5, 44100);
// set the portamento speed on the oscillator to 200 milliseconds
// add the oscillator to the line out
passX = 0;
passY = 0;

void draw()
// draw the waveforms
for(int i = 0; i < out.left.size()-1; i++)
stroke(#FF0000); //left is red
line(i, 50 + out.left.get(i)*50, i+1, 50 + out.left.get(i+1)*50);
stroke(#0023FC); //right is blue
line(i, 150 + out.right.get(i)*50, i+1, 150 + out.right.get(i+1)*50);
float freq = map(passY, 0, 1023, 1500, 60);
// pan always changes smoothly to avoid crackles getting into the signal
// note that we could call setPan on out, instead of on sine
// this would sound the same, but the waveforms in out would not reflect the panning
float pan = map(passX, 0, 1023, -1, 1);

void stop()

void serialEvent(Serial myPort)
// read the serial buffer:
String myString = myPort.readStringUntil(‘\n’);
myString = trim(myString);
int sensors[] = int(split(myString, ‘,’));
for (int sensorNum = 0; sensorNum < sensors.length; sensorNum++)
// print(“Sensor ” + sensorNum + “: ” + sensors[sensorNum] + “\t”);
passX = sensors[0];
passY = sensors[1];
//print(“PassX= ” + passX + “, PassY= ” + passY);


ICM: Sakura (Revisited) and Koyo

This week in Intro to Computational Media @ ITP, we learned how to add text into a Processing sketch.  I used my Sakura (cherry blossom) sketch from week 3 as a departure point and added the Japanese characters for sakura さくら into the new version of the sketch (above). I wanted to create a kind of “digital calligraphy” that explored the relationship between words and abstract shapes and set everything in motion. I also made an autumn leaves (koyo) sketch with the Japanese characters for koyo 紅葉 and an autumn color story.  To make things more visually appealing, I increased the size of the triangles and added some transparency to the background to create a more stylized sense of the passage of time in the animation and to create an illusion of three-dimensional depth.

There was a slight problem in getting the sketches to execute correctly though.  Although Processing is able to deal with Unicode-8 character sets, I was unable to get the Japanese characters to display correctly in the calligraphy font that I wanted.  The Japanese characters were showing, but in a default san-serif font and not the font that I created and specified in Processing.  I realized that I had to import the full character set and not just the default characters that Processing turns into bitmaps when you create a font.  However, when I checked “all characters” in the Create Font menu and clicked on “Create”, my computer froze up, probably because Japanese fonts have literally thousands of different characters, unlike the 26 letters and handful of punctuation marks we have in English.  Since I was only using 3 different characters in the Sakura sketch and 2 different characters in the Koyo sketch, I thought I that I might try creating SVG files in Adobe Illustrator for each character and then importing the Candy SVG library into my Processing sketches, which would then allow me to import the Japanese characters as vectors instead of bitmapped fonts.  Also, I only had to load the characters that I needed, and not the entire character set of the font.  As you can see from the screenshots, this approach worked!  I got the Japanese chracters to display in the calligraphy font instead of the default Processing font which didn’t work in the context of the sketches.

Click on the screenshots above and below to play with the sketches.  Drag the mouse around the frame and hold down any key on the keyboard to scatter cherry blossoms petals/autumn leaves.

ICM: Week 3 – Sakura

In week 3 of Intro to Computational Media at ITP, we learned about functions and objects in Processing.  I also peaked ahead to arrays so I could execute my idea.  I was inspired by my t-shirt (below), which is a Japanese design of cherry blossom petals (sakura in Japanese) blowing in the wind.

Here is my abstract Processing version (or click on the screenshot below to view). Press any key or click the mouse in the square to scatter cherry blossom petals.

View source code