The most recent workshop took place at Metropolitan Works, the London Metropolitan University’s digital fabrication facility. Under the overarching theme of digital fabrication, initially this workshop was focused almost exclusively on geometry aspects and how to use various toxiclibs classes to construct shapes & forms and solve problems in this domain. During the 2nd workshop session, I wanted to combine several related topics into a single large exercise and we started building a little hypothetical facade design tool.

Over the past couple of weeks I squeezed in some extra time to finish cleaning up and adding comments (lots of!) to the source code of that tool with some further descriptions below…

Facade designs generally require to take into account the varying light conditions & requirements of the space sections on the inside of the building. Using strategically placed particles & attractors we can model & modulate these different spatial densities on the facade surface…

Step 1: Strategically place some attractors & particles to modulate the spatial density of the facade

Step 2: Connect particles into a 2D mesh using Delaunay triangulation...

Step 2a: ...or use Voronoi to create more cell like patterning

Step 3: Map the 2D mesh onto the extruded profile of the facade

Step 4: Apply & tweak surface deformation along normal vectors

Step 5: Produce a water tight Iso-surface mesh of the wireframe structure and export as STL for 3D printing

Result of using a more complex profile spline

Since we didn’t fully get to finish everything as a group, I have added several more features (some on popular demand):

• Allow for selecting, repositioning & adjusting of particle attractors
• Produce 3d iso surface of facade wireframe/lattice mesh and export as STL
• Allow selecting & moving of points in spline editor component (incl. realtime updates in 3d wireframe preview)
• Added user adjustable 3D surface deformation using simplex noise
• Added toggle to switch between Delaunay & Voronoi shapes
• Adding arc ball controller to more naturally change 3D view orientation
• Integrating mouse wheel to adjust zooming in 3D
• Generally improved usability and made ControlP5 GUI more dynamic (some controllers are now context sensitive and only visible in certain display/edit modes)

It’s almost a proper little tool now and should provide a lot of food for thought for the dear students (and maybe give them something to do over the holidays :)

You can download the entire Eclipse project from here: learn.postspectacular.com/hg/metworks-2011-facade/

Please note, this project is a plain Java project (no Processing Eclipse plugin required) and contains all required libraries in the project’s /lib folder:

• Processing 1.5.1 + JOGL (only with OSX & Win32/64 binaries)
• ControlP5 0.5.4
• pre-release of toxiclibs-0021

Below are some quick steps to import the project into your Eclipse workspace:

• Download via the .zip link in the top toolbar…
• Unzip to anywhere on your disk
• Rename resulting folder into “metworks-2011-facade” (all lower case, use dashes, no quotes)
• In Eclipse, choose File > Import… > General > Existing projects into workspace…

• In the import dialog use the “select root directory” option and navigate to the folder in step 3
• The project should now show up just below, make sure it’s ticked
• Press “Finish”

• Back in the Eclipse workbench, open up the project in the project explorer…
• Right click on the file “FacadeApp.launch” and choose “Run > FacadeApp”… Have fun! That is all, if you’re on OSX…

Windows users will have to do a few more additional steps and edit the location of the native library components first (used by JOGL):

• Right click on the “metworks-2011-facade” project and choose “Properties > Java Build Path > Libraries”.
• open the sub-tree for jogl.jar, select “Native library location” and then press the “Edit…” button

• Now choose the /lib/windows64 (or 32) folder inside your project folder and then confirm all changes. Then you can have fun too! :)

Some more brief overview of the different classes in the project’s /src folder:

• FacadeApp – main application (extends PApplet)
• ParticleSystem – physics based particle simulation & simple editor features for attractors
• SplineEditor – simple 2D curve editor for designing the facade profile
• FacadePoint – extension of Vec3D to include surface normal and normalized 2D position (needed for displacement)
• DisplacementStrategy – interface definition for defining concrete displacement operators (applied to FacadePoints)
• NoiseDisplacement – the currently sole available implementation of DisplacementStrategy, using 2d simplex noise
• ArcBall – re-usable arc ball view component for easier navigation/rotation of the 3D view

Last, but definitely not least: Many, many dear thanks to Arthur Mamou-Mani and Marcus Bowerman for organising, your hospitality, 3d printing and making everything happen… We all hope to repeat something similar in the next year. You’ve been (and will be again) warned! :)

Mark these dates in your calendar: July 12-18th 2010 – It’s going to be a whole 7 long days of code crafting in the north of Portugal and I’m looking very forward to it! The workshop is limited to 14 participants. Bookings are handled by the University and should be done via their special website. Thank you dearly!

The planned outline is below the poster I made for this unique occasion, so please do read on:

The general idea is to split our time into 4 days of intense tutorials and hands-on examination of core principles & techniques of the computational design approach in the context of creating “generative identities”, without prescribing too much what shape & form these should take. Part of our workshop’s remit is also to enquire the current possibilities. The final 3 days will then be used to build your own project(s) to be use for the Olhares de Outono festival later in November.

The topics listed below are not set in stone and we’ll decide as group on what to focus (much depends on the skills & interests of the participants). Similarly, if you’d like to experiment/include external devices into your project (Wiimote, Arduino), please bring them along. The workshop space is equipped with iMacs, but there’re also a couple of spaces to use your own machine as well… At the end of the workshop, we all should have at least one completed (if not polished) project for the festival, and should strive to document it (the project) too.

Day 1: Getting ready

Processing

• recap of basics
  • types
  • structures
  • working with libraries
  • exporting

• scope
  • learning curve
  • use as environment (PDE)
  • use online vs. offline
  • use as library in larger frameworks
  • P5 within the bigger picture
    • JavaScript
    • Java (Android)
    • OpenFrameworks
    • Cinder

Toxiclibs

• Overview
• Recent updates
• Philosophy
• Resources
• Use cases
• Exercises
  • Key techniques/classes
  • Layering processes/Combining modules
  • Easier handling in Processing

OOP

• Concepts
  • Interfaces
  • Inheritance
  • Polymorphism
  • Encapsulation

• Best practices
  • Events
  • Architecture
  • Design patterns
  • Anti patterns
  • Reusability
  • Open source

Eclipse

• overview
• project setup
• using Processing as lib only
• editor features
  • code completion
  • navigation
  • refactoring

Day 2: Working with data

Data modelling/processing

• Collections
  • Hashmaps
    • Histograms:
      • Images, FFT
      • Tag clouds
  • Lists
    • Iterators
  • Queues
    • Priority based processing
    • Pipes
    • Stacks
  • Trees
    • recursion
    • sorted sets using comparators
      • sort by custom criteria
      • spatial subdivision (quadtree, octree etc.)

• XML
  • standard formats
    • Atom
    • RSS
  • code generation from data model
    • XML Schema
    • JAXB
  • Defining your own formats
    • Loading/saving app state
    • Presets
    • Configuration

• • Aggregation
    • merging of sources and/or time samples
    • set theory
      • union
      • intersection
      • difference
      • relationships (1:1, 1:N, N:M)

Visualisation

• basic graph theory
• finding & creating metaphors
• techniques
  • geometry basics
  • coordinate systems
    • spherical (Geomapping example)
    • polar (color transforms)
    • cartesian
  • vector maths
  • mapping/geometric transformations
    • M->N dimensions
    • time -> space
  • mesh generation
• animation
  • interpolation curves
  • state transitions
  • viewport changes
    • transformation matrix
    • camera control (e.g. 3rd person camera)
• exporting data
  • high res bitmap
  • PDF
  • image sequence + automatic FFMPEG assembly
  • 3D data for digital fabrication

Day 3: Interactions

Building on previous day exercises

HCI

• Wiimote
• Mobile
• Computer vision
• TUIO / OSC
  • • multitouch
    • reacTIVision
    • external devices
• QRCodes
• Location triggers
  • GPS/compass based AR
• Serial input
  • Firmata

Machine-machine interactions

• asynchronous event handling
  • twitter updates
  • reacting to Pachube sensor data
• multi-threading
• network communications/protocols
  • UDP
  • OSC

Day 4: Generative techniques

Building on previous day exercises

Processes as design tools

• inputs
  • observation
  • abstraction
  • mental model building
• behaviour
  • parametrization
  • rules
  • feedback
• simulation
  • agents
  • automata
  • erosion
  • fluids
  • particles
  • physics
• randomness
  • balance of control
  • bias
  • chaos vs. determinism
  • role of authorship?
  • techniques & differences

Day 5-7: Work on own projects

Process

• If possible form pairs/groups
• 2 reviews/status reports/discussion per day with all
  participants
• Karsten giving help & support to all groups
• Final review and presentation on Sunday PM
• Project documentations

And once again, please head over to this site for further organisational things & the signup form…

On April 23 & 24, 2010 I’ll be teaching an advanced Processing, Eclipse & toxiclibs workshop as part of the Processing Paris activities organized by the talented Mr. Webster & David Abouna-Tomé from OFFF.

The Memory Tree

During the 2 days of the advanced Processing Paris workshop we will create an interactive installation called The Memory Tree. The installation will consist of a large projection of a generative, slowly growing 3D tree whose leaves are all made up from messages/thoughts left by visitors and workshop participants.

These messages can either be submitted as voice via mobile phones, Skype or IM, but will also be harvested automatically via tagged content from Flickr and Twitter. The tree will grow and become more complex with every new message collected and so slowly form a browsable history of its creation during the workshop, but also document the reactions of exhibition visitors. Visitors can interact with the installation via a mouse (or Wiimote, if we’re quick…) to change the view of the tree, zoom in, and focus particular messages/images or play recorded voice messages. There could also be a mode where the user directs a “cursor” freely between the various tree branches and listens to all voice messages associated with leaves in the cursor’s proximity. This playback would use 3D audio so that when the focal point is moved, the recorded voices move around in space accordingly and are creating an immersive audio collage. Voices closer to the cursor will play louder than ones further away.

The installation concept will nicely combine a number of different concepts, technologies and programming techniques. It’ll also educate participants about the distributed nature of technologies available and the importance of open standards acting as technological glue between them.

Scope

Amongst other things, we will cover:

• core 3D geometry techniques: vectors, matrices, quaternions, cameras, curves, texture mapping
• complex mesh creation with volumetric modelling
• working with OpenGL
• dealing with parallel processes using multi-threading
• working with 3rd party libraries (mainly from toxiclibs.org)
• multi-channel audio playback
• working with XML efficiently (using JAXB)
• parsing RSS/Atom feeds (Flickr, Twitter integration)
• working with (and creating) REST based web services
• designing an application data model
• object oriented architecture as key enabler for flexible designs

The installation will be obviously using Processing as core platform, however we will use Eclipse as development environment to make development faster, easier and more efficient. Participants should have a medium/firm grasp of Processing and feel comfortable with experimenting with new concepts & techniques with a looming deadline.

If you want to sign up for this, please head over to: processingparis.ning.com

The images are above and below are some very early explorations of a deterministic random 3D tree generator. I’m currently working on a proof-of-concept of some of the above ideas, mainly in order to help us be as efficient as possible on these two workshop days…

The images below are showing the combination of the generated tree structures above with volumeutils to create 3D meshes of the trees…