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

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

However, I tried the original TileSaver code posted back in 2006 and miraculously that still works. This would imply a larger issue with the unlekkerLib library and Processing 1.0, which I’ll have to address when I have the time.

For now, here is a link to a working Processing sketch using the old TileSaver code: TileSaverTest.zip

In particular, STL export should work again. However I haven’t had the chance to test the code very much, so please let me know if you find any bugs.

• unlekkerLib0003c

You can download unlekkerLib-0003 from the Code & Form Google Code repository. I’ve added the missing classes, but otherwise the library is the same. If you still experience problems please report them here.

Contents of Code & Form code library v0001

I’ve decided to put my Processing hacks from the Code & hacks page and consolidate them into a downloadable archive. Thus the Code & Form code library is born. It will contain various demos and hacks, as well as example code for the unlekkerLib library. It should be much easier to publish code this way, since students etc. can simply download the archive and dump the contents in their sketchbook folder for quick access.

I’ve started a Google Code repository for this purpose, which seems a good way to go. I’m still figuring out SVN etc, hopefully I can switch to publishing the unlekkerLib source “live” through SVN once I figure it out. I’ll also publish archives of code written during past workshops to the repository.

There seems to be a growing list of Processing-related Google Code repositories out there, examples include Toxi’s Toxiclibs, interfascia and jddaniels. Do a search for processing.org to find more.

I added two new functions to the library, nothing big but could be useful for some people:

• unlekker.data.POVRay: Primitive POV-Ray triangle geometry export.
• unlekker.data.FeedReader: Feed reading utility class (requires installing extra JARs)

To use the feed classes simply use the code from this previous post, minus the class definitions.

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”.

To run the code below you’ll need to download ROME and JDOM. Make a “code” subfolder in your sketch and paste “jdom.jar” and “rome-*.jar” into it, then run the code as given. The FeedReader and FeedEntry convenience classes take care of parsing the feed and returning the entries with the most common fields included. Error checking is rudimentary, however.

// feedParser.pde
//
// Reads RSS and Atom feeds. Requires ROME
// (https://rome.dev.java.net/)
// and JDOM (http://www.jdom.org/), just make
// a code folder and copy "jdom.jar" and "rome-*.jar"
// into it.
//
// Marius Watz - http://workshop.evolutionzone.com

import com.sun.syndication.feed.synd.*;
import com.sun.syndication.io.*;

FeedReader feed;
String feedurl;

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

  // load feed
  feedurl="http://feeds.feedburner.com/CodeForm";
  println("Loading feed: "+feedurl);
  feed=new FeedReader(feedurl);

  // print feed data
  println("Feed: "+feed.title);
  println("------------------------------");
  println("Description: "+feed.description);
  println("\nNumber of entries: "+feed.numEntries);
  println("------------------------------");

  // print feed entries
  for(int i=0; i< feed.numEntries; i++) {
    println(i+": "+feed.entry[i]);
  }
}

class FeedReader {
  SyndFeed feed;
  String url,description,title;
  int numEntries;
  FeedEntry entry[];

  public FeedReader(String _url) {
    url=_url;
    try {
      feed=new SyndFeedInput().build(new XmlReader(new URL(url)));
      description=feed.getDescription();
      title=feed.getTitle();

      java.util.List entrl=feed.getEntries();
      Object [] o=entrl.toArray();
      numEntries=o.length;

      entry=new FeedEntry[numEntries];
      for(int i=0; i< numEntries; i++) {
        entry[i]=new FeedEntry((SyndEntryImpl)o[i]);
        println(i+": "+entry[i]);
      }
    }
    catch(Exception e) {
      println("Exception in Feedreader: "+e.toString());
      e.printStackTrace();
    }
  }

}

class FeedEntry {
  Date pubdate;
  SyndEntryImpl entry;
  String author, contents, description, url, title;
  public String newline = System.getProperty("line.separator");

  public FeedEntry(SyndEntryImpl _entry) {
    try {
      entry=_entry;
      author=entry.getAuthor();
      Object [] o=entry.getContents().toArray();
      if(o.length>0) contents=((SyndContentImpl)o[0]).getValue();
      else contents="[No content.]";

      description=entry.getDescription().getValue();
      if(description.charAt(0)==
        System.getProperty("line.separator").charAt(0))
          description=description.substring(1);

      url=entry.getLink();
      title=entry.getTitle();
      pubdate=entry.getPublishedDate();
    }
    catch(Exception e) {
      println("Exception in FeedEntry: "+e.toString());
      e.printStackTrace();
    }

  }

  public String toString() {
    String s;

    s="Title: "+title+newline+
      "URL: "+url+newline+
      "Date: "+pubdate.toString()+newline;

    if(description.length()>50)
      s+="Descr: ["+description.substring(0,50)+
        "...]"+newline;
    else s+="Descr: ["+description+"]"+newline;

    if(contents.length()>50)
      s+="Contents: ["+contents.substring(0,50)+
        "...]"+newline;
    else s+="Contents: ["+contents+"]"+newline;
    return s;
  }
}