Here are three examples showing a simple map display and two demos using geo data from OpenPaths in CSV format: 20120127_unfolding_map_examples.zip

Update: The lecture notes about infoviz and self-ethnography are online on Scribd, it’s basically the same lecture as two years ago.

Arc mesh tool created with Modelbuilder and ControlP5

I did a short lecture + workshop about digital fabrication and parametric modeling with Processing yesterday at NYU’s ITP program. Thanks to Dan Shiffman for the invite, it ended up being a lot of fun because of the great turnout of enthusiastic ITP’ers. It certainly made me even more regretful that I was unable to teach a fabbing course at ITP this semester, but with luck there will be other oppportunities.

As promised I have uploaded the pre-written examples I demo’ed as well as the code I (frenziedly) wrote live during our 1.5 hour coding session. The focus was to demonstrate the logic of the Modelbuilder library, a set of utilities and aimed at abstracting and simplifying some common tasks in computational creation of 3D meshes.

The library is really not all that sophisticated, but it shifts the focus away from OpenGL drawing logic towards a more object-oriented way of imaging 3D forms based on UVertexList objects. In a typical situation it should simplify a lot of tasks, as well as save dozens of for() loops and repetitive code. It also allows some pragmatic coding (aka “lazy”) coding practices enabling easy reuse of geometries due to the assumption that operations like “new UVertexList(vl)” should always copy input data by content rather than by reference.

I’m pleased to say that Modelbuilder performed well in the demo session, there’s nothing like live coding to reveal weaknesses or inconsistencies in code. But the Modelbuilder logic proved consistent under stress testing and we were able to do some pretty decent mesh generation in a limited amount of time.

A ZIP with all the files shown (including the Modelbuilder and ContolP5 libraries) can be downloaded from http://db.tt/5Ehmn6uz. It includes the following code examples:

• simple_geo_arc_4 A tool for creating a composition of 3D arcs (w/ valid face normal orientation and passing the “waterproof” criteria for 3D printing), generating output to STL format. This was written live in around 30 minutes.
• mb_04_gui_parametric A parametric 3D form generator created for my Makerbot residency – results look valid on screen but for some reason export to STL results in flawed models. I’ll look into debugging this example.
• mb_04_gui_heightfield An example showing how to create a heightfield mesh from an image, allowing interactive control of mesh resolution and Z scaling. Potentially useful for geographical elevation maps and Kinect depth maps.
• A set of examples demonstrating the core Modelbuilder functions

Sketches made with Wblut’s Hemesh library

This blog has been quiet for a while, due not to laziness but rather lack of time. Some random notes to let you know what I’ve been up to:

• I just set up a Tumblr blog to post more theory-related thoughts that don’t fit this blog so well. First post: Things I’ve learned from disagreeing about (Media) Art on the Internet
• I’m working on some new objects for 3D printing, experimenting with interfacing Modelbuilder to Wblut’s Hemesh library. I have some promising results so far, but actual print tests remain. I will try to post more about this later, specifically providing a class that acts as a bridge between my UGeometry objects and the HE_Mesh data structure. Interchange of mesh data is the biggest issue for 3D libraries right now, hopefully the upcoming PShape3D structure will facilitate this.
• The Modelbuilder lib is due for an upgrade, I’ll do this when Processing 2.0 is out for good.
• I had a great time doing a solo show in San Francisco this summer, as part of the SF Film Society’s Kinotek series, see documentation on Flickr: SFFS Kinotek – Automatic Writing. Thanks to Sean Uyehara and the others at SFFS, as well as the excellent people I met during my stay.
• The SF show featured the biggest collection of Makerbot objects to date – about 25 pieces: Form studies (Makerbot). As always my thanks go to the Makerbot clan for excellent support, at the craziest I had 6 Makerbots printing at once.

Form studies (Makerbot) at the Automatic Writing show

MakerBot models built with code included with the ModelBuilder library, also downloadable from my Thingiverse account

Update, July 1 2011: I’ve uploaded ModelBuilder v0004, which fixes a few really silly bugs in 0003. Download it from http://code.google.com/p/codeandform/.

I’m happy to announce the first public release of my new ModelBuilder library, created as part of my artist-in-residence project at MakerBot Industries and beta tested in the Interactive Parametrics workshop. The occasion for today’s release is the MakerBot User Group New York, where I’ll talk about the library and show off my MakerBot models.

ModelBuilder focuses on functions useful for digital fabrication purposes, such as creating meshes, centering models around origin, scaling to given dimensions, output to STL format etc. It emulates Processing’s beginShape / vertex / endShape logic to build mesh geometry which can then be manipulated and transformed.

The UVertexList class allows the user to build paths of vertices. Vertex lists are then fed into various UGeometry.quadStrip() functions to construct quad strip meshes, most likely eliminating the need for dozens of for loops in the process. See the online copy of the ModelBuilder JavaDoc for a more complete overview.

Coders using the library to output models for 3D printing need to be aware of face orientation (see Wikipedia: Handedness) so that face normals are generated correctly.
Always check models to see if face normals are correct before attempting to 3D print them. As always, I recommed the Open Source tool MeshLab for previewing and testing models. MeshLab will render backwards-facing faces as all black, giving an easy preview of incorrect geometry.

Happy mesh building, look forward to seeing models on Thingiverse!

Download modelbuilder-0004.zip and unpack it. Copy the “modelbuilder” folder to your “libraries” folder and restart Processing. If you have the now obsolete unlekkerLib installed you should remove it before adding ModelBuilder, which effectively replaces unlekkerLib.

The ModelBuilder library folder includes (rudimentary) JavaDoc documentation, the library source code and a series of examples located in “modelbuilder/examples”. The most advanced example is mb_04_gui_parametric, which contains the code used to create MakerBot prints shown above. The “gui” examples use Andreas Schlegel’s ControlP5 library, which must be downloaded and installed before running them.

This should be considered an experimental in-progress release and some features are likely to change. As usual, niceties like good documentation have been left for last, so the best way to get a feel for the library is to run through the examples provided. Bug and / or success reports are welcome, just leave comments on this post.

Grid Distortion (2007-): Typology and density study

I’m working on a new 6-panel Grid Distortion piece for my Extrusion show next week, the final size will be 540 x 50 cm. I’ve been revisiting all the previous incarnations of the piece and tweaking the code to elicit new interpretations. Which led me to compile this summary of formal “typologies” that the piece is capable of exhibiting.

Given that the piece is essentially a variation on a very simple attractor simulation it tends to give very obvious (even almost boring) results, and its only through extensive tweaking of parameters and custom rendering styles that I’ve found results I’m excited by. Dave Bollinger made an accurate comment on Flickr that these are perhaps not very “watz-y” images, but its the translation of the form onto wood or metal that somehow completes the form for me.

Grid Distortion expanded: CircGrid on aluminum

Just last week I had some new aluminum pieces made in Berlin with Martin Bauer at Lasern in Berlin that represent a new direction in the series. Loosely titled CircGrid, these expand the same process to radially oriented grids. This might seem like an obvious extension, but the results are actually quite different. The images look less architectural, bringing to mind structures from nature like neurons, blood veins and plant roots etc.

I’m definitely enjoying this new and slightly more chaotic direction, as well as the crisp technical look of the aluminum.

Previews of generated geometry for installation for “Extrusion” at ROM

Hot on the heels of the Interactive Parametrics workshop I’m now in Oslo working on a solo show that will open March 11 at ROM For Art + Architecture (Oslo). Titled “Extrusion”, the show highlights how my practice has bee evolving to dealing with ways of physically communicating code-based processes beyond the default means of the computer screen or projection.

The show will feature a new version of the light installation Prime, this time realized with fluorescent tubes and DMX lighting control. Other elements include a wall drawing made by retracing projected vectors with painters tape (1.2 km of it), as well CNC plotter and laser drawings (Arc Drawings and a new multi-panel Grid Distortion.)

Finally, I’m building a large geometric structure (see above) using my ModelBuilder library in Processing. The forms are designed to be easy to unwrap to 2D without tesselating polygons. I’m outputting cutting templates as PDF files to be used by the CNC routers. This is a new process for me, despite having followed the success people like Martin Fuchs has had with unwrapping polygon meshes. It allows me to work on a fairly large scale (as in 3 x 3 x 1.5 meters), articulating actual structures rather than representations of structures.

All in all it’s a very exciting show to be working on, and I’m grateful to ROM and its director Henrik der Minassian for supporting all this craziness… If you’re in Oslo next weekend I hope to see you there!

• Extrusion opens Friday March 11, 19:00-21:00
• ROM For Art + Architecture, Maridalsveien 3, Oslo

Previous tape drawing: Exploder at System:System

To be revisited: Prime light installation

I am currently working on a solo show for ROM Art + Architecture in Oslo under the title “Extrusion”, opening on March 11th. The show will focus on physical installations, a bit of a departure from my software works that I’m very excited about.

One of the pieces will be a new version of my light installation Prime, a public art commission for the Bybanen light rail system in Bergen last year. The Bybanen version uses LED lighting elements and electric relays, intended to be stable for a minimum of 5 years in the rough environment of a subterranean tunnel. The new version will use fluorescent tubes and computer-controlled switching via a DMX-512 lighting control interface.

Fortunately there are several USB interfaces for DMX control, as well as a recently released Processing library by Henri David titled dmxP512. Thanks to the generous assistance of Dan Shiffman I was able to test my interface with dmxP512 today. I’m very pleased to say that both the USB box and David’s library worked without a hitch, literally working perfectly on the very first attempt.

Even given the simplicity of the DMX standard it’s rare that anything works that easily, let’s hope I don’t jinx myself by writing it publicly. In any case, the exceedingly simple code I used is listed below, based on the sample code provided with the dmxP512 lib. Happy hacking, my thanks to Henri David for the library!

To run this example you’ll need Henri David’s dmxP512 library and a USB DMX interface like the ENTTEC DMX USB Pro ($151).

To set a new value for any given DMX channel, simply call DmxP512.set(dmxChannel,newValue).

import dmxP512.*;
import processing.serial.*;

DmxP512 dmxOutput;
String DMXPRO_PORT="COM4";
int DMXPRO_BAUDRATE=115000;

void setup() {
  size(200,200);

  println(Serial.list());
  DMXPRO_PORT=Serial.list()[0];
  println("DMXPRO_PORT "+DMXPRO_PORT);

  dmxOutput=new DmxP512(this,128,false);
  dmxOutput.setupDmxPro(DMXPRO_PORT,DMXPRO_BAUDRATE);
}

void draw() {
  background(0);

  int cnt=(int)((float)millis()/100f)%255;
  println("cnt "+cnt);

  // output on DMX channel 2
  dmxOutput.set(2,cnt);
}

New piece: abstract01js. Built with Processing.js

I finally had an excuse to take Processing.js for a spin. Aram Bartholl is doing one of his Speed Show exhibitions this Wednesday (SPEED SHOW vol.4:’Super Niche’). The Speed Show format is based on taking over an internet cafe and showing artworks that can run in regular browsers without any special software.

Since most of my pieces use OpenGL they’re not suitable for web I decided to try porting an old 2D sketch to Processing.js. Rendering Processing code in the browser by using the HTML5 Canvas and Javascript is a nice idea, but I was curious to see if it would work for my purposes.

As it turns out, the code for Abstract01 from 2003 (originally created for Abstraction Now) worked on the first attempt. After a few adjustments I now have one interactive and one “automatic” version running perfectly in Firefox and Chrome. I have to say I’m officially impressed with Processing.js, my hat off to John Resig and crew!

SPEED SHOW vol.4 takes place today Wednesday, Oct.27 at 90 Bowery in Manhattan, in the 90 Bowery Internet Cafe. Here is the list of participating artists:

Erik Andersson, Cory Arcangel, Michael Bell-Smith, Charles Broskoski, Jon Cates, Aleksandra Domanovic, Doubble Happiness, Constant Dullaart, JODI, JK Keller, Greg Leuch, Olia Lialina & Dragan Espenschied, Duncan Malashock, Eva & Franco Mattes aka 0100101110101101.ORG, Aaron Meyers, Mark Napier, Katja Novitskova, Paper Rad, Jon Rafman, Ariel Rebel, Ryder Ripps, Evan Roth, Brad Troemel, Marius Watz

It’s an honor to be showing in such excellent company…

Use Data.beginSave() to initialize data string collection, then add data with Data.add(). To write to file, use endSave(filename). I’ve included code for auto-incrementing filenames, it’s used in the example code.

To load data, call Data.load(filename), then use readInt(), readFloat(), readString() etc. to get values from the strings read from the text file. Used properly this should give you most of the flexibility you need for simple data saving.

// saveData.pde
// Marius Watz - http://workshop.evolutionzone.com

// Example showing how to use the Data utility
// class to save and load data from text files. 

float a=2.5,b=3.144;
int x=10,y=20;
boolean bool=true;
String s="This is a string.";

Data data;

void setup() {
  size(400,400);

  data=new Data();

  // SAVING
  data.beginSave();
  data.add(s);
  data.add(a);
  data.add(b);
  data.add(x);
  data.add(y);
  data.add(bool);
  data.endSave(
    data.getIncrementalFilename(
      sketchPath("save"+
        java.io.File.separator+
        "data ####.txt")));

  // LOADING
  data.load(sketchPath("save"+
    java.io.File.separator+
    "data 0000.txt"));

  s=data.readString();
  a=data.readFloat();
  b=data.readFloat();
  x=data.readInt();
  y=data.readInt();
  bool=data.readBoolean();
}

///////////////////////////
// DATA CLASS

class Data {
  ArrayList datalist;
  String filename,data[];
  int datalineId;

  // begin data saving
  void beginSave() {
    datalist=new ArrayList();
  }

  void add(String s) {
    datalist.add(s);
  }

  void add(float val) {
    datalist.add(""+val);
  }

  void add(int val) {
    datalist.add(""+val);
  }

  void add(boolean val) {
    datalist.add(""+val);
  }

  void endSave(String _filename) {
    filename=_filename;

    data=new String[datalist.size()];
    data=(String [])datalist.toArray(data);

    saveStrings(filename, data);
    println("Saved data to '"+filename+
      "', "+data.length+" lines.");
  }

  void load(String _filename) {
    filename=_filename;

    datalineId=0;
    data=loadStrings(filename);
    println("Loaded data from '"+filename+
      "', "+data.length+" lines.");
  }

  float readFloat() {
    return float(data[datalineId++]);
  }

  int readInt() {
    return int(data[datalineId++]);
  }

  boolean readBoolean() {
    return boolean(data[datalineId++]);
  }

  String readString() {
    return data[datalineId++];
  }

  // Utility function to auto-increment filenames
  // based on filename templates like "name-###.txt" 

  public String getIncrementalFilename(String templ) {
    String s="",prefix,suffix,padstr,numstr;
    int index=0,first,last,count;
    File f;
    boolean ok;

    first=templ.indexOf('#');
    last=templ.lastIndexOf('#');
    count=last-first+1;

    if( (first!=-1)&& (last-first>0)) {
      prefix=templ.substring(0, first);
      suffix=templ.substring(last+1);

      // Comment out if you want to use absolute paths
      // or if you're not using this inside PApplet
      if(sketchPath!=null) prefix=savePath(prefix);

      index=0;
      ok=false;

      do {
        padstr="";
        numstr=""+index;
        for(int i=0; i< count-numstr.length(); i++) padstr+="0";
        s=prefix+padstr+numstr+suffix;

        f=new File(s);
        ok=!f.exists();
        index++;

        // Provide a panic button. If index > 10000 chances are it's an
        // invalid filename.
        if(index>10000) ok=true;

      }
      while(!ok);

      // Panic button - comment out if you know what you're doing
      if(index> 10000) {
        println("getIncrementalFilename thinks there is a problem - "+
          "Is there  more than 10000 files already in the sequence "+
          " or is the filename invalid?");
        println("Returning "+prefix+"ERR"+suffix);
        return prefix+"ERR"+suffix;
      }
    }

    return s;
  }

}

KBGAnimD01EB 0008, still from new sound visualization

Ever since doing Stockspace project it seems I am getting asked to do data-related work. This despite the fact that my personal interests diverge from such masters of insightful infographics as Martin Wattenberg, David McCandless or Jonathan Harris.

Suffice to say that I am more concerned with exploring data structures as spaces than I am with providing new understandings of the information contained within them. Manuel Lima’s Information Visualization Manifesto calls for a seriousness on the topic of data treatments, while my projects remain comfortably frivolous.

Recently I’ve been working on a project that has required researching data sources and adapting them to illustrate a bigger idea, which has led to much Googling in the absence of good data from the client. Sometimes you find the right thing immediately, but sometimes data is hard to find in a format that is freely available and easily parsable. Since I have found some good sources I thought I’d share them here…

• PVWATSS calculator from Renewable Resource Data Center (RReDC) provides theoretical calculations of yields (hour-by-hour, 365 days/yr) from photovoltaic solar panels for most international locations.
• World airport codes with geo name data, helpfully spidered by Wiebe Cazemier so you don’t have to.
• Unattributed FTP depository of geo-related CSV files, including postal and ZIP codes, world city info etc.
• Historical weather data from Weather Underground, providing year-by-year hourly information for most cities in the world. (See also this list of weather APIs.)
• Yahoo Finance offers downloads of historical stock price data (CSV) for just about any stock symbol out there. Sadly I have yet to find an open intraday stock data source, due to the proprietary nature of that kind of information.
• The Guardian’s Datablog is a recent venture, and I have yet to use any of the data sets they provide. But I like their approach, which is clearly aimed at democratizing data with a view to public agenda.

I would be interested in hearing tips about any great data sets out there, particularly interesting time series data.

Miska Knapek recently sent me a link to a source of weather sensor data from Helsinki, including measurements of wind direction at the top of Helsinki’s Olympic Tower in 5-minute intervals. He has already made some wind visualization videos and some fabricated wind data sculptures based on this data.