Bestiary

Bryan and I are having a great time showing Bestiary, our projection-based book of randomly generated animals, at the ITP Spring Show. Here’s a quick video we shot this morning during set up:

Bestiary from Caroline Brown on Vimeo.

Yesterday was day one of the show, and we got lots of great feedback on the project. Today is the second and last day of the show, so come see us! The floor is open to the public 5-9pm.

Photo by Gilad Lotan

Unholy Mess of a Processing Sketch

We reworked the program to display each animal part as a set of vectors, allowing us to be a little more creative with assigning positions for various parts. We’re  placing a set of circles to overlap as joints in each composite. Our working drawings look like this:

Horse Body Working Sketch with Joints

In an effort to provide a more engaging user experience, we’ve also moved from a mouse-activated screen display to a physical installation. Our aim now is to project the creatures onto the blank pages of a book, creating a new animal each time a page is turned, and using QR codes to facilitate recall of previous pages’ animals. The installation will be on display at the ITP Spring Show. We’re getting a little closer to the aesthetic we’re looking for, although I’m still hunting for the right font and tweaking the drawings:

Mantidilloboon

Here’s today’s working code. It will go through some more changes tomorrow since here our samples are hard coded, rather than drawn from our grammar file:

PShape body;
PShape part;
//String bodyString = “horse2.svg”;
String bodyString =”bluejay2body.svg”;
//PShape frontLegs;
//PShape rearLegs;
//PShape head;

String[] bodyParts = {
“horse2head.svg”, “bluejay2frontlegs.svg”, “horse2rearlegs.svg”, “trans.svg”};

int cx;
int cy;
int bcx;
int bcy;

void setup() {
size(800,800);
body = loadShape(bodyString);
//head = loadShape(“horse2head.svg”);
//frontLegs = loadShape(“horse2frontlegs.svg”);
//rearLegs = loadShape(“horse2rearlegs.svg”);

smooth();
noLoop();

}

void draw() {
shape(body);
assemble(bodyString);
//translate(cx, cy);

//getBodyPoint(“horse2head.svg”);
//shape(head, -bcx, -bcy);
}

int findCoord(String working_, String lookingFor_) {
String lookingFor = lookingFor_;
String working = working_;
int start = working.indexOf(lookingFor);
int end = working.indexOf(” “, start);
String coord = working.substring(start, end);
coord = coord.replace(“cx=”", “”);
coord = coord.replace(“cy=”", “”);
coord = coord.replaceAll(“”", “”);
return int(coord);
}

void assemble(String svgFile_) {
String svgFile = svgFile_;
XMLElement xml = new XMLElement(this, svgFile);
XMLElement[] desc = xml.getChildren(“g/g/circle”);
println(desc);

for (int i=0; i<desc.length; i++) {
String working = desc[i].toString();
cx = findCoord(working, “cx”);
cy = findCoord(working, “cy”);

translate(cx, cy);
getBodyPoint(bodyParts[i]);
println(bodyParts[i]);
part = loadShape(bodyParts[i]);
shape(part, -bcx, -bcy);
translate(-cx, -cy);
}

}

void getBodyPoint(String svgFile_) {
String svgFile = svgFile_;
XMLElement xml = new XMLElement(this, svgFile);
XMLElement[] desc = xml.getChildren(“g/g/circle”);
println(desc);

for (int i=0; i<desc.length; i++) {
String working = desc[i].toString();
bcx = findCoord(working, “cx”);
bcy = findCoord(working, “cy”);

println (“bcx: ” + bcx + ” bcy: ” + bcy);
}
}

From the Brooklyn Museum Collection

For Programming A to Z last week, Adam asked us to get some XML from a web service and use it as input into one of our previous programs. I chose to work with the Brooklyn Museum’s API. In looking through an XML sample from their site, I was intrigued by the variety of artists’ materials listed under each object’s “medium” attribute. When I look at art in museum’s I’m often left guessing by the signage, wondering what process the artist used in order to get a material to behave in a specific way. So, I thought it would be interesting to reduce a description of a work to the media used to create it, then compile a new work out of images of those media (e.g. a work made of glass and walnut transformed and remade with images tagged “glass” and “walnut”). My code for getting the artist and materials data out of the XML returned by a keyword search is here:

import org.dom4j.Document;
import org.dom4j.DocumentFactory;
import org.dom4j.io.SAXReader;
import org.dom4j.Element;
import java.util.List;
import java.util.HashMap;
import java.net.URLEncoder;

public class BrookMuse {

public static void main(String[] args) throws Exception {

String keyword = args[0];

SAXReader reader = new SAXReader();
EasyHTTPGet getter = new EasyHTTPGet(
“http://www.brooklynmuseum.org/opencollection/api/?method=collection.search&version=1&api_key=[API KEY]&keyword=” + keyword
);

Document document = reader.read(getter.responseAsInputStream());
List works = document.selectNodes(“//items/object”);

for (Object o: works) {
Element work = (Element)o;

List artists = work.selectNodes(“artists/artist”);

if (artists.size() > 0) {
Element firstArtist = (Element)artists.get(0);
String artist = firstArtist.attributeValue(“name”);
String medium = work.attributeValue(“medium”);
System.out.println(artist + “: ” + medium);
}

else{
String medium = work.attributeValue(“medium”);
System.out.println(“Unknown: ” + medium);
}
}
}
}

It returns a list that looks ike this (e.g. with search term “noguchi”):

Unknown: Low fired earthenware pottery, reassembled from fragments
Isamu Noguchi: Terracotta, plaster
Isamu Noguchi: Glass, walnut
Isamu Noguchi: Bakelite plastic

Now on to gathering some images…

Don't bother reading this drivel.

On the other hand, if I ask it to tell me whether or not I ought to read the works of Jane Austen, based on my interest in Shakespeare’s sonnets, it tells me something different:

You should definitely read this.

Oblique Strategies Box

Over Spring Break we had two assignments to finish for Programming A to Z. The first was to modify, augment, or create a program based on our in-class examples of context-free grammars. I originally planned to create a grammar for walking– some sort of computer-generated dérive– but the weather hasn’t been particularly conducive to walking. This dreary March weather has put me into a bit of a creative slump, so I decided to make something to help shake my brain up a bit: I wrote a grammar based on the 1979 edition of Brain Eno & Peter Schmidt’s Oblique Strategies, and I fed it to Adam’s ContextFilter. It’s a little wonky since the structures of Eno & Schmidt’s instructions are so diverse, but it’s spit out a few interesting phrases so far. Here are a few of its suggestions:

breathe more deeply

burn more often

disconnect from always time

decorate dirty disciplined things

consider cascades

build and abandon extravagant transitions

destroy sections

burn normal cascades and build first instruments

dirty an easement

don’t be frightened to display and discard

use desire as an anchor

This is the code for the main class of our creature-maker:

import java.util.HashMap;
HashMap words = new HashMap();
String[] lines;
String oneLine;
String animalName;
PImage head;

PImage body;
PImage legs;
PFont font;

void setup() {
background(random(100, 255), random(100, 255), random(100, 255));

animalName=”";
font = loadFont(“Goudy-Bold-70.vlw”);

size(700, 700);

words.put(“horsehead.png”, “H”);
words.put(“bluejayhead.png”, “Bl”);
words.put(“staghead.png”, “St”);
words.put(“horsebody.png”, “or”);
words.put(“bluejaybody.png”, “ue”);
words.put(“stagbody.png”, “a”);
words.put(“horselegs.png”, “se”);
words.put(“bluejaylegs.png”, “jay”);
words.put(“staglegs.png”, “g”);

}

void draw() {

//puts file into contextFilter object, collectString retreives output that
//would normally be printed, puts into oneLine String
oneLine = new ContextFilter().collectString(createReader(“animals.txt”));
lines = oneLine.split(” “);

//for debugging
for (int i = 0; i < lines.length; i++) {
String t = lines[i];
if (words.containsKey(t)) {
animalName = animalName + words.get(t);
}
}

//we’ll have
head = loadImage(lines[0]);
body = loadImage(lines[1]);
legs = loadImage(lines[2]);

image(head, 0, 0);
image(body, 0, 0);
image(legs, 0, 0);

println(animalName);
textFont(font);
textAlign(CENTER);
fill(0);
text(animalName, width/2, 620);

noLoop();
}

void mousePressed() {
background(random(100, 255), random(100, 255), random(100, 255));
animalName=”";
redraw();
}

Hueg

Bryan Lence and I developed a creature-maker for our Programming A to Z midterm. We based the program on a simple context-free grammar defining our animal structures, and applied that grammar to a Processing sketch based on Adam Parrish’s ContextFilter. Each click of the mouse while the sketch is running assembles a new animal assembled from parts of a horse, a stag, and a blue jay that we created using Photoshop and Illustrator.

This week’s assignment for Programming A to Z was to modify or augment our in-class example of a Markov chain. Somehow during class I got the idea to make a program that would create imaginary creatures by analyzing n-grams from a list of animals. I created a list of creatures from a medieval bestiary, and made a few simple changes to Adam’s MarkovFilter example. Here are some examples of creatures created by the program: kitelerowl, elockdawk, swatyr, bonomelizarr, hydrowhawk, heleonewt and, my favorite, hootalaphoot. This is the code for Bestiary.java:

import com.decontextualize.a2z.TextFilter;
public class Bestiary extends TextFilter {
public static void main(String[] args) {
new Bestiary().run();
}
Markov mark = new Markov(2, 10);
public void eachLine(String line) {
mark.feedLine(line);
}
public void end() {
println(mark.generateLine());
}
}

I would like to eventually narrow down the list of possible animal components, create images for each, and develop a Processing sketch to assemble composites of the animals as the algorithm pieces them together.

Imagine my surprise, nay, my consternation, when without moving from his privacy, Bartleby in a singularly mild, firm voice, replied, I would prefer not to.
But in quite as clear a one came the previous reply, I would prefer not to.
I would prefer not to, said he.
I would prefer not to, he said, and gently disappeared behind the screen.
Why do you refuse? I would prefer not to.
I would prefer not to.
I would prefer not to.
Will you tell me, Bartleby, where you were born? I would prefer not to.
Will you tell me any thing about yourself? I would prefer not to.
At present I would prefer not to be a little reasonable, was his mildly cadaverous reply.
I would prefer not to quit you, he replied, gently emphasizing the not.
Now what sort of business would you like to engage in? Would you like to re-engage in copying for some one? No; I would prefer not to make any change.
Too much confinement, I cried, why you keep yourself confined all the time! I would prefer not to take a clerkship, he rejoined, as if to settle that little item at once.
No: at present I would prefer not to make any change at all.

Our assignment for Programming Ato Z this week was to use regular expressions in Java to transform or analyze a text. I immediately thought of Herman Melville’s Bartleby, the Scrivener and imagined it might be fun to extract all the instances of Bartleby’s assertion: “I would prefer not to…” The block quote above is the output from the following code:

import com.decontextualize.a2z.TextFilter;
import java.util.regex.*;
public class Bartleby3 extends TextFilter {
public static void main(String[] args) {
new Bartleby3().run();
}
private String contents = new String();
public void begin() {
println(“Starting Succinct Scrivener…”);
}
public void eachLine(String line) {
String tempString=line.replaceAll(“\”", “”);
contents += tempString + ” “;
}
public void end() {
String[] temp;
temp = contents.split(“\\.”);
for(int i =0; i <temp.length ; i++){
Pattern p = Pattern.compile(“[Ii] would prefer not “);
Matcher m = p.matcher(temp[i]);
if (m.find()) {
println((temp[i])+”.”);
}
}
}
}

Create a program (using, e.g., the tools presented in class) that behaves like a UNIX text processing program (such as cat, grep, tr, etc.). Your program should take text as input (any text, or a particular text of your choosing) and output a version of the text that has been filtered and/or munged. Your program should use at least one method of Java’s String class that we didn’t discuss in class.

Be creative, insightful, or intentionally banal. Optional: Use the program that you created in tandem with another UNIX command line utility.

I wanted to create a completely silly text this week, so I based my assignment on Lewis Carroll’s poem,  The Jabberwocky, replacing a’s with o’s. Here’s the code:

import com.decontextualize.a2z.TextFilter;
public class JabberMoshy extends TextFilter {
public static void main(String[] args) {
JabberMoshy j = new JabberMoshy();
j.run();
}
public void begin(){
}
public void eachLine(String line) {
String tmpString = line.replace(‘a’,'o’);
println(tmpString);
}
public void end(){
}
}

Here’s the command line input:

caroline-browns-computer:~/atoz caroline$ javac JabberMoshy.java
caroline-browns-computer:~/atoz caroline$ java JabberMoshy <jabberwocky.txt

And here’s the result:

‘Twos brillig, ond the slithy toves
Did gyre ond gimble in the wobe:
All mimsy were the borogoves,
And the mome roths outgrobe.

“Bewore the Jobberwock, my son!
The jows thot bite, the clows thot cotch!
Bewore the Jubjub bird, ond shun
The frumious Bondersnotch!”

He took his vorpol sword in hond:
Long time the monxome foe he sought–
So rested he by the Tumtum tree,
And stood owhile in thought.

And, os in uffish thought he stood,
The Jobberwock, with eyes of flome,
Come whiffling through the tulgey wood,
And burbled os it come!

One two! One two! And through ond through
The vorpol blode went snicker-snock!
He left it deod, ond with its heod
He went golumphing bock.

“And host thou sloin the Jobberwock?
Come to my orms, my beomish boy!
O frobjous doy! Collooh! Colloy!”
He chortled in his joy.

‘Twos brillig, ond the slithy toves
Did gyre ond gimble in the wobe:
All mimsy were the borogoves,
And the mome roths outgrobe.

Next steps: Make the replace function case-insensitive, replace multiple characters.