| Overview |
|
"The Shape of Discourse"
uses the processing IDE to create dual graphical interfaces. These interfaces
are based on a data set which is the result of an internet bot . One of
the interfaces displays a three dimensional architectural structure that
dynamically changeds over time; the other interface gives a two dimensional
network representation of how the data is interpreted to create the structures
that are being displayed. |
| |
|
|
| processing |
|
Processing
is an open project started by Ben Fry and Casey Reas at MIT and UCLA. Processing
is a programming environment built on top of Java that allows for sophisticated
graphical design via relatively simple Java code. "The Shape of Discourse"
uses processing to create both the three dimensional structures and the
two-dimensional network; processing was chosen because of the projects dependence
on graphics. |
| |
|
|
| Spidering |
|
This project relies
on creating a cohesive/current-day discourse between different architects
that shape our modern world. To this effect, a bot was created in processing
to scour the internet looking for relationships between architects. The
bot is seeded with 64 historically significant architects; by automatically
accessing a search engine (Alta-Vista was used because it lacked anti-spidering
software) the bot enters in every combination of architect pairs. This results
in a set of webpages containing both names inclusively. By enumerating the
number of “hits” each query produces allows for the quantification
of a relationship between two architects. Thus the queries with more hits
leads to a stronger relationship between architects while the queries with
fewer hits leads to a weaker relationship. These results are put into a
matrix of all the architects, and this data is passed to the three-dimensional
processing program. |
| |
|
|
| Architectural
Structure |
|
The architectural structure
code contains three main parts. The first part is code to build one truncated
octahedron (toh). The toh is the primative brick that constitutes the three
dimensional structure. Each toh has six squares and eight hexagons. Thus
it has 24 vertices, 34 edges, and 14 sides. Therefore the code has three
functions to deal with the creation of the toh: makePoints(), makeEdges(),
and makeFaces(). All of these together make a single toh. The second part
of the code is to implement an algorithm. This will be explained later in
the Algorithm section. The third part of the code is the interface. The
actual structure is limited to a box with a horizontal plane in the middle
to simulate a three-dimensional grid. No toh can extend outside this box.
Each toh represents a different architect; the initial camera orientation
places the user behind a clear vertical plane that acts as a screen. Names
of architects that represent the most recently created tohs are projected
on this screen with the recent ones being dark and older ones faded. Using
the mouse in the display window, the user can move the camera orientation
to view the box/structure from any orientation. |
| |
|
|
| Algoritim |
|
After the bot returns
a matrix of numbers relating the architects, this algorithm is used to create
the three dimensional structures. A first architect is picked at random.
This architect is represented by a toh at the origin. For each side of this
toh, an architect is chosen using the bot results. The 14 architects that
relate most closely to the current architect get designated to each side
of this toh (toh has 14 sides). Thus the related architects that have the
highest relationship number to the current architect as determined by the
bot get chosen. A weighted random function is used to pick a side of the
toh. This function is weighted in proportion to the relationship number.
The sides with the closer relationships get picked more often. The side/related
architect that gets picked spawns another toh, out of that side, connected
to the first toh. This toh represents the architect that the side was designated
to. The algorithm starts over with the new toh. The total toh’s are
set to some maximum number. After they are all drawn, the next toh is obtained
by moving the very first toh to get a snake like effect. If the future position
of a toh is already occupied by another toh, the weighted random function
is run again until a vacant side is chosen. |
| |
|
|
| Network
Display |
|
The network display
shows the history of our "discourse" displayed by the three dimensional
architectural structure. The network display consists of a square grid of
64 points. Each point represents an architect. For each toh created by the
architectural display, the related dot is highlighted. Then 14 lines are
drawn from the highlighted dot to 14 different related architects on the
grid based on the bot data. A colored line is drawn between the current
architect and the chosen architect while the other 13 lines fade away. By
following the colored lines one can follow the path of architect interaction
being displayed by the architectural structure. Over a longer duration the
dark lines fade away. |
| |
|
|
Abstract