@mariuswatz websaver awe.sm/5daM6 is a great way to use a processing.js sketch as a screensaver. Here’s mine: viz.runningwithdata.com/boids/

— Jason Sundram (@jsundram) January 28, 2012

Websaver runs on MacOS and allows the user to specify a web page to load when the screensaver is active. And since it uses Safari to render the HTML (I assume), you can use HTML5 and Processing.js to run computational sketches on that web page.

It’s a nice hack to enable easy development of screensavers based on open web standards, without having to worry about interaction with the OS etc. In fact, it’s nearly as good as my Google Chrome screensaver idea, minus an app store etc.

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.

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.

Workshop with Studio Mode & MakerBot: Interactive Parametrics

This weekend I’ll be teaching the Interactive Parametrics Workshop with Studio Mode (Gil Akos and Ronnie Parsons) and MakerBot (represented by Bre Pettis). We’ve been planning this for a while, but since it’s happening during my residency at MakerBot we thought it’d be fun to focus on the MakerBot as a possible output method. Our thanks to Bre and the MakerBot crew for supporting the workshop!

With a good mix of architects and code-hacking designers as our participants it should be an interesting weekend. We will be posting the resulting code examples and STL models after the workshop.

We’ll be looking at strategies for parametric modeling using Processing, outputting MakerBot-ready models as STL files and printing them on site.

Processing lacks the hardcore math engine of typical CAD packages, but is far more flexible when it comes to working interactively with dynamic realtime systems. By extending Processing’s core functionality with libraries for simulation and 3D mesh construction we can combine realtime processes with advanced geometry tools.

We’ll be relying on a selection of Processing libraries:

• unlekker.ModelBuilder, a new library I’ll be releasing for the workshop that supports mesh-oriented parametric modeling for 3D printing. It’s nothing fancy, but it’ll get the job done in predictable ways.
• Karsten Schmidt’s always excellent Toxiclibs library offers volumetric modelling and advanced simulation functions.
• Frederik Vanhoutte’s Hemesh library is a comprehensive set of tools for constructing and modifying meshes through procedural tools like extruding, subdividing, slicing, chamfering etc. Hemesh allows the effortless creation of hypercomplex models.
• Andreas Schlegel’s ControlP5 library will be our steady workhorse for GUI interface elements.

We’ll also be using Rhino3D and MeshLab to clean up models for fabrication.

Below is a list of links to tutorials and resources related to the tools we’ll be using:

• Processing
  Processing Primers 1-3 on modeLab.nu
  Processing.org/learning, great collection of tutorials
  OpenProcessing.org, social network for sharing Processing sketches
• Toxiclibs
  Toxiclibs home page
  Toxiclibs demos on OpenProcessing.org
• Hemesh
  Hemesh home page
  Hemesh introduction tutorial
  Hemesh Share && Tell presentation by Frederik Vanhoutte
  Hemesh post on Creative Applications
• Makerbot / Thing-O-Matic
  MakerBot Thing-O-Matic details
  Thingiverse – Open Source hub for digital design

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);
}

MakerBot model tests

I’m excited to announce that I’ve been asked by Bre Pettis and the MakerBot crew to be first ever MakerBot artist-in-residence. This means that I am free to use and abuse their new Thingomatic model and waste spools of ABS plastic, trying out forms suited to the MakerBot’s quirky plastruder 3D printing method.

If you’ve somehow managed to miss the buzz about MakerBot, what you need to know is that it’s an Open Source 3D printing platform using a plastic extruder head with a moving platform controlled by stepper motors. By laying threads of plastic in layers calculated by slicing 3D models into cross-sections, the MakerBot is capable of producing durable 3D prints for a fraction of the cost of high-end SLA or SLS systems.

Having shipped close to a thousand of their MakerBot kits, MakerBot Industries is the most popular Open Source 3D printer out there. Their new Thingomatic machine is a big improvement on their Cupcake model, adding an automatic build platform and improved layer alignment, as well as replacing some of the Cupcake’s more vulnerable parts with superior equivalents.

The MakerBot is a DIY hacker project and wears its colors on its sleeve. It might lack the slickness and of a SLS machine, but at a fraction of the price it makes 3D printing affordable for experimentation on a shoestring budget. With some tinkering skills and loving care a MakerBot will deliver endless amounts of 3D printed fun. If you need convincing just look at all the models on Thingiverse, the Open Source sharing site for digital designs.

MakerBot’s core community is based on hackers and DIY enthusiasts, for whom assembling a kit and even hacking the hardware is no big challenge. A logical next step is to reach designers, artists and architects, who want 3D printing but might be less technically inclined. But as Bre Pettis likes to say, if you can assemble an IKEA bookshelf you should be able to assemble a MakerBot. Your mileage might vary…

My interest in the MakerBot is as a low-cost platform to test parametrically generated geometry. Having experimented with SLS printing as a way to produce miniature sculptural forms (the Object 1-3 series), I want to make much larger objects and installations. The MakerBot is perfect for hands-on testing of shapes I can later replicate at a larger scale.

The MakerBot is also ideal for parametric models for mass customization. A typical workflow might involve an applet on a web site allowing the user to customize their model, with parameters sent to a server-side application that generates a STL file ready for printing. Nervous System already have several such interactive applets showing how their jewelry is designed.

My goal for my MakerBot residency is to produce a set of models for my upcoming exhibition at ROM for Kunst og Arkitektur in Oslo next month. As part of that process I will be developing a new Processing library for 3D model building, to be released as Open Source along with a series of models I’ll publish on Thingiverse (see thingiverse.com/watz) in the MakerBot spirit of openness. You can already get a preview on Flickr, I can’t wait to add more!

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.

Multiple JDIC browsers integrated into Processing sketch

A while back I posted a simple hack to open a web browser from Processing by using JDesktop Integration Components (JDIC). A recent discussion on the Processing forums asked about how to use it to open multiple browsers inside the actual Processing sketch window.

My original hack used an instance of org.jdesktop.jdic.browser.WebBrowser integrated into a java.awt.Panel instance and laid out in a java.awt.Frame. That meant that the browser would open in an external window. The discussion on the Processing forum asked specifically about opening multiple browsers in the main sketch window, so I made the following quick hack.

I’m posting the actual code below, but to run the example you should download the following ZIP file: JDIC_multiple.zip. It includes the JDIC binaries required to run it on Windows.

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

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

import java.net.URL;
import java.net.MalformedURLException;
import org.jdesktop.jdic.browser.*;

aBrowser browser[];
long last;

void setup() {
  size(800,600);
  frame.setLayout(new GridLayout(2,2));

  browser=new aBrowser[4];
  for(int i=0; i<4; i++) {
    browser[i]=new aBrowser();
    browser[i].initPanel(400,300);

    if(i==0) browser[i].setURL("http://www.google.com/");
    if(i==1) browser[i].setURL("http://processing.org/");
    if(i==2) browser[i].setURL("http://ffffound.com/");
    if(i==3) browser[i].setURL("http://sojamo.tumblr.com/"); 

    frame.add(browser[i].panel);
  }
}

void draw() {

}

public class aBrowser {
  Panel panel;
  WebBrowser webBrowser;

  public aBrowser() {
    // Set engine to IE
    BrowserEngineManager mng=BrowserEngineManager.instance();
    mng.setActiveEngine(BrowserEngineManager.IE);
    webBrowser = new WebBrowser();
  }

  public void initPanel(int w,int h) {
    panel = new Panel();
    panel.setLayout(new BorderLayout());
    panel.setSize(w,h);
    webBrowser.setSize(w, h);
    panel.add(webBrowser, BorderLayout.CENTER);
  }

  public void setContent(String htmlContent) {
    webBrowser.setContent(htmlContent);
  }

  public void setURL(String url) {
    try {
      webBrowser.setURL(new URL(url));
      webBrowser.setDebug(false);
    }
    catch (MalformedURLException e) {
      System.out.println(e.getMessage());
      return;
    }
  }
}

Take a look at the list of existing pages and see if you can’t contribute something…

Rapid prototyping objects generated with Processing and output to STL using unlekkerLib.

I’ve just uploaded a new Processing library called unlekkerLib. It is a collection of tools and code snippets I use frequently, and which I’ve now just barely cleaned up enough for other people to use. Instead of releasing them piece by piece, I’ve decided to bundle them together in a package hierarchy.

The main reason I decided to release it now is the STL export code I’ve written for my rapid prototyping projects. Several people have asked for the code, so I wanted to get it out there for you to play with. Obviously, it works as well with Processing as it does with regular Java.

Caveat emptor:There’s not much documentation but I do provide the source code. This is v.0001 – the very first release, so it’s pretty basic. See below for an idea of what the library contains. Right now the most exciting new component is the unlekker.data.STL class, which supports export and import of STL stereolithography files for rapid prototyping. Have a look at the Javadoc for more details.

Updates will appear here: http://workshop.evolutionzone.com/unlekkerlib/.

• unlekker.data.STL: STL import and export.
• unlekker.util.Rnd: Mersenne Twister pseudo-random number generator.
• unlekker.util.TileSaver: The TileSaver class for creating high-res images from OpenGL graphics by tiling the viewport.
• unlekker.geom.Intersect: Line intersection and checking for collision with complex 2D polygons.

Download unlekkerLib-0001.zip and unpack it.

Copy the "unlekker" folder from the “00 For processing library folder” folder into the "libraries" subfolder of your Processing application. The library should now appear as a choice in "Import library" next time you start Processing.

The Java source can be found in “00 For processing library folder > unlekker> src”.