05.16.2013 Rhino to HPGL

We’ve collectively discovered that there are no good vector graphics (dxf or pdf, etc) to HPGL converters available on the windows platform. Some of them produced files that had extraneous commands that made the plotters work very slowly. Others didn’t get units right.

Here’s a bare bones python script written with rhinoscript, which will allow the direct creation of an HPGL file from within Rhino. updated 5/16/13 rhinoToHPGL-v3.py

it assumes you’ve already made a rhino file that contains drawn information on the x-y plane only (nothing in 3-D). it also assumes your model is already scaled to the size of the drawing. And lastly, it assumes your rhino units are set to inches.

it draws curves (including straight lines of course) only. If you have surfaces in your file, even if they are 2-S, they will be ignored.

05.14.2013 Using the new Roland plotter

You will need to swap out this configuration file for the old one. I recommend that rather than replace your existing config.py file you rename it to something like config-old.py (so you can revert back to it when necessary)

On a mac: it’s in a hidden folder (google show hidden folders in mac os for instructions) your-home-directory/.chiplotle/

On windows: look in C://your-home-directory/.chiplotle

the file: config.py

04.22.2013 Python Editor in Grasshopper This is the link to download the grasshopper ad-on that allows you to create new custom nodes in the Python language: http://www.food4rhino.com/project/ghpython (registration required) (instructions for installing also on that page)
04.18.2013 Reciprocal funcitons

examples from class today:

04.12.2013 Reading

Each student is assigned one of the following reading pairs. Over the remainder of the course, students are responsible for becoming an expert on these texts and bringing the relevant conversations to our collective discussions, their work, and the work of others. Students will not only need to read, re-read, and understand each text, but understand the relationships between the two. Where do these readings align, contrast, contradict or support each other? Students will investigate other texts referenced in each reading and the contexts within which each author was writing.

MD, PS, NW will read:
William Empson, 7 Types of Ambiguity (excerpts)
Colin Rowe and Robert Slutzky, Transparency: Literal and Phenomenal

SW,MK, MJ will read:
Stan Allen, From Object to Field
Stan Allen, Field Conditions Revisited

JM,SF, W(J)J, JB will read:
Malcolm McCullough, 20 Years of Scripted Space
Antoine Picon, Forward to Algorithmic Architecture

NV, AD, CB will read:
Nigel Cross, Designerly Ways of Knowing, Design Discipline vs. Design Science
Paul Klee, The Thinking Eye (excerpt)

04.04.2013 Beginning Phase 2.1 with two short exercises

Today we begin the second and final phase of the course. As a transition between the first and second phase students will complete two short exercises. The first is the creation of a three-second animation that captures the perception of the construct designed in phase 1.2 from a moving point of view. The second is a set of diagrams that document distinctly varied approaches to the program and site in term of thick surface(s).

Subsequent directions that the work will take are to a large extent at the discretion of students, who are charged with designing a process for designing a building. The recently provided program and site will provide resistance, but successfully responding to their forces is only the beginning. The “big question” that initiated our work must continue to be addressed: how does drawing mediate/influence/fuel/disrupt the relationship between you, computing and architecture?

Obviously, to address that question we will keep drawing. Some of the drawing will be representational. Other drawing will operate entirely within the space of the page and serve as autonomous works of art. How, with what media, and with what machines you program is open. We will consider and discuss the role of automation, indirection, instruments and knowledge under the conceptual umbrella of authorship.

Here’s the full assignment sheet for download: spring2013_computingDrawing_2.1.pdf

03.18.2013 Rhinoscript Python – Lines on a Surface

This example script demonstrates one example of a methodology that may be useful for some students in the transition from drawing on paper to drawing in space: buildLinesOnSurface.py. It involves parsing the U and V (equivalent to X and Y) values. This is often the basis of algorithms for meshing (converting NURBS to facets) but more fundamentally it allows the use of a non-planar surface form as a surface for drawing. UPDATE:Today we walked through this in class and modified it slightly to make lines normal to the surface. Here’s the modified version: buildLinesOnSurface-normal.py

03.09.2013 We begin phase 1.2: Prototype Thick Surface

First, an acknowledgement: a thick surface is impossible. Surfaces are thin. In fact, they are infinitely thin. Their presence in architecture is entirely a matter of abstraction and perception–of edge, boundary, smoothness, and continuity of a two-dimensional realm. As we proceed in this assignment let’s endeavor to maintain rigorous though plastic conceptions of surface. How might it be possible to leverage the sidedness of surfaces (especially those which are non-planar) to articulate interior volumes? What are the implications of building a surface as opposed to building along a surface?

Students will primarily consider to what extent perceived depth in the drawing translates into deep space within the construct. Additionally in question is the correspondence between linear language(s) in the drawing and formal language(s) in the construct. For example, a student may build the drawing or build from the drawing.

Students are also prompted to consider space made within the surface and the space(s) implied in front of or behind the surface. From different points of view does the surface project space differently? Conversely, how might the geometry collapse into apparent flatness. Related are questions of transparency and figure. Finally, some welcome realities: the surface must end (or begin) at its edges, above, to the sides, and at the ground.

Program: A person, alone or in a group, needs to be able to walk through and into the construct and occupy at least one discrete space.

download the 1.2 project brief (PDF)

03.07.2013 Guests Today we were joined by some members of the MIT Design and Computation Group: Moa Carlsson, Onur Yüce Gün, and Theodora Vardouli

This is the rhinoscript file I used as a demo in class yesterday (at the time it was called 1.py for convenience): rhinoscript-inClass-connectAcrossRandomlyGeneratedCurves.py


Yesterday we randomly assigned students a position for their drawings in the “stack.” Each student will be asked to take as input information from the drawing “below,” and each drawing will therefore serve as a kind of interpretation or reading of another. There’ll be three iterations. assignedpositions

02.27.2013 Mentioned in class… http://hackertyper.com
02.25.2013 Python in Rhino!

If you have Rhino 5, you’re ready to go. From the rhino command prompt type “EditPythonScript” and press enter. It will bring up the scripting window from which you can open/save/run python scripts.

Get Rhino 5 beta
Install Rhino python plugin. Download installer from here http://wiki.mcneel.com/rhino/mac/python
Read through that page, especially RunPythonScript command with a ‘-’ in front of it to save you some time (the mac version of Rhino 5 doesn’t have a text-editor built in so you will be using SublimeText to edit and Rhino to run your scripts)

A few sample scripts to get you started: rhinoscriptPython-attractor-grid-example.py, rhinoscriptPython-web-draw-example.py, and rhinoscriptPython-hairy-line-example.py

02.25.2013 Plotting!

First, there are two libraries that Chiplotle (the library that allows us control the plotter) requires, called “dependancies” that will need to be installed before anything else: Pyserial and Numpy. You will also need the driver for the physical USB-serial adapter.

Mac OS
MAC USB-Serial Driver
MAC Numpy
MAC Pyserial

WINDOWS USB-Serial Driver
WINDOWS Pyserial

Lastly, for both Mac and Windows

This is the Chiplotle documentation site: http://music.columbia.edu/cmc/chiplotle/manual/

Here are two example scripts for plotting. They are heavily commented. Please read through them completely: plotting-basics.py and plotting-generating-HPGL-file.py

02.23.2013 transparency

Nicole just emailed asking about how to make lines that were translucent. She suggested an algorithmic approach that involves, “overlaying the pixels with white in the loop so that you can tell which lines were drawn first.” Sounds like a good idea.

So far we’ve been working with a single surface in pygame. The most straightforward way to create transparency is to create a new surface (in Nicole’s case this will be a new surface filled entirely with white), reduce the opacity of that surface, then draw it onto the screen surface.

The relevant functions involved will be pygame.Surface() to create a new surface, Surface.set_alpha() to adjust opacity and Surface.blit() to draw the new surface onto the screen.

I made an example to illustrate:
First, a simple drawing program (think microsoft paint):simple-draw.py
Now, that same program with a translucent white surface drawn between each line segment:simple-draw-plus-transparency.py


two examples we worked through in class today webdrawing.py

02.21.2013 simple grid sample file


02.21.2013 SublimeText2 – a better text editor for writing code

download sublimetext2

on a mac
sublime text 2 ->preferences->Browse Packages
open Python folder
find Python.sublime-build and right click ->open with sublime text 2

open terminal (applications/utilities)
type the followign line and press enter:
which python
the result should look something like (if not exactly like):

copy that path and paste it into the file you have open in SublimeText2 inside the first set of quotes in the first line so that it looks like:
“cmd”: ["/Library/Frameworks/Python.framework/Versions/2.6/bin/python", "-u", "$file"],
“file_regex”: “^[ ]*File \”(…*?)\”, line ([0-9]*)”,
“selector”: “source.python”
quit and reopen SublimeText 2

on windows
First, locate the python.exe on your hard drive. Its loctation will depend on the version of windows you’re using and if you have installed Python for “all users” or just for your user account. It is likely in either your home directory or the root of the C drive. It will be in a folder called python26. If you don’t see it, do a search for python.exe.

Open SublimeText2
preferences ->browse packages
open Python folder
find Python.sublime-build and right click ->open with sublime text 2
update the information to reflect the full path to Python.exe on your harddrive. Beginning with C:\\ and placing a \\ to indicate folder structure. It should like something like:

“cmd”: ["C:\\python26\\python.exe", "-u", "$file"],
“file_regex”: “^[ ]*File \”(…*?)\”, line ([0-9]*)”,
“selector”: “source.python”

quit and reopen SublimeText2

02.18.2013 Installing Python

Please follow these steps exactly
On a Mac:

  1. download and install Python version 2.6.6. This link is a download of the installer file: python 2.6.6 installer (click mac installer disk image) Complete the installation before going on to the next step
  2. download and install Pygame using this link: pygame-1.9.1release-py2.6-macosx10.5.zip
  3. locate the Python 2.6 folder inside your Applications folder. Inside you should see an application called IDLE. Open it. You will use this often. Maybe you want to make a shortcut on your dock.

OR if you’re using Windows:

  1. download and install Python version 2.6.6 via this link: Windows x86 MSI Installer (2.6.6) (upon conclusion, restart)
  2. download and install Pygame via this link: pygame-1.9.1.win32-py2.6.msi
  3. from the start menu find the Python 2.6 folder (probably you will need to click “show all programs” ) inside you should see IDLE. Open it.

Lastly, the test file: simple_sample.zip

02.17.2013 Syllabus and Assignment 1.1

Syllabus (PDF)
1.1 Assignment Brief (PDF)

Alan Gauld’s Learning to Program site
The first few sections of “Concepts” and “The Basics” might be very useful. (Some pages offer additional discussion of Javascript and VBScript. We’re using Python only, so feel free to ignore those paragraphs)

Documentation of Pygame “Draw” functions

Frascari reading 1 (PDF)
Frascari reading 2 (PDF)
Petherbridge Reading (PDF)
Reiser+Umemoto reading (PDF)

02.14.2013 course description

This studio will explore the role of computation as medium for thinking and making. This means avoiding the treatment of the computer as a tool to help solve already defined problems. It means going deeper than using software. It means operating outside the bounds of the digital. Perhaps most importantly, it means conflating the action of design with the action of computing.

The course is divided into two phases. The first will be a kind of calisthenics and will begin by coding in the Python programming language to control a machine (pen plotter, laser cutter or other) that will affect material. This process will be augmented by–or perhaps convolve with– visual computing with graphite on paper. Although computing is usually associated with building models, operating in the realm of the drawing will allow an exploration of architectural issues before they manifest as buildings. Drawing also is a prime territory for learning the language of computing because its reduced dimensions make mathematics and logics simpler than working in three dimensional space. We’ll begin programming with an emphasis on live input from a user, so authorship and the role of the human remain at the center of our process and discourse. Each drawing will be autonomous as a work of art, but each student will be assigned a depth position within a communal “stack” of all the drawings and will be tasked with reading and responding to the neighboring drawing positioned above.

Because Python has recently been adopted as a scripting language in Rhinoceros and other software, we’ll be able to tap into those geometric libraries as needed and eventually extend our algorithms into the third dimension and/or build out the thickness that we read in the drawing surface into a digital and physical construct. Non-uniform rational basis spline (NURBS) surfaces are of particular opportunity because of their inherently two-dimensional operational structure in three-dimensional space. These models will evolve based on prompts laden with enigmatic and seemingly contradictory requirements rooted in inherently architectural problems and conditions: the corner, ground, and perception by a moving observer.

If the first phase of the course is calisthenics, the second phase is performance. A site and program will be introduced that challenge the methods, tactics and products cultivated in phase one. The specifics of the site and program will be reveled only after the first phase is complete in an effort to control earlier research and inhibit bias. The program will have demanding and nuanced requirements for observing, connecting, isolating, socializing, and learning. The site will urban, finite, and be contextualized by unusually varied and highly structured systems of movement around and through it. As this phase progresses, drawing, now as a medium for representation, will remain at the center of attention and critique.

05.26.2013 final review Note to students: Have additional photos from the review? Please email to Carl!
The group (somebody please take the liberty of photoshopping in Alexander, Sara and Sierra)

The group (somebody please take the liberty of photoshopping in Alexander, Sara and Sierra)

J. Johnston's final presentation

J. Johnston’s final presentation

Half of Maryam Dashti's final presentation

Half of Maryam Dashti’s final presentation

Maryam Dashti's final presentation

Maryam Dashti’s final presentation

Peeraya Suphasidh’s final presentation

Peeraya Suphasidh’s final presentation

Part of Peeraya Suphasidh’s final presentation

Part of Peeraya Suphasidh’s final presentation

Peeraya Suphasidh’s final presentation with the work of Nathaniel Vice in the distance

Peeraya Suphasidh’s final presentation with the work of Nathaniel Vice in the distance

Part of Nathaniel Vice's final presentation

Part of Nathaniel Vice’s final presentation

Caterina Belardetti’s final presentation

Caterina Belardetti’s final presentation

Half of Nicole Wiznitzer's final presentation

Half of Nicole Wiznitzer’s final presentation

Sara Fetterolf's final presentation

Sara Fetterolf’s final presentation

Invited guest Stephan Rutz studies the work of Michael Jacobs

Invited guest Stephan Rutz studies the work of Michael Jacobs

Michael Jacobs' final presentation

Michael Jacobs’ final presentation

you're welcome

you’re welcome

05.16.2013 Work in progress
Nicole Wiznitzer's drawing

Nicole Wiznitzer’s drawing

Maryam Dashti's desk

Maryam Dashti’s desk

Peeraya Suphasidh’s screen

Peeraya Suphasidh’s screen

John Mars' drawing media experiment

John Mars’ drawing media experiment

John Mars' screen

John Mars’ screen

05.15.2013 Drawn space | Inhabitable space
Peeraya Suphasidh's work in phase 2.1

Peeraya Suphasidh’s work in phase 2.1

05.15.2013 Penetrating wrapper
Caterina Belardetti's work in phase 2.1

Caterina Belardetti’s work in phase 2.1

05.15.2013 Partially thick striated surface
Julia Bowlin's work in phase 2.1

Julia Bowlin’s work in phase 2.1