Lostritto Thesis

building update

2008-04-03T20:05:00.004-04:00

scripting revised

2008-04-03T18:39:00.006-04:00

I focused my attention recently to two specific "skinning" scripts. Both are visualized here in terms of their output. The parameters here are (happily) plentiful:

-reflective surfaces respond to solar rays throughout day to focus energy to PV tubes through the use of varying parabolic control lines along surface. These parabolic contours vary by the relationship between the absolutely regular PV tubes and the irregular surface (which itself responds to broader scale parameters from earlier investigations). The result is a surface articulation pattern that is indirectly (although I think visually apparently) related to that geometry.

-an information display and solar filtering surface that is itself characterized by its ability to adjust to communicate specific content (ie-signage and video) directly and by manipulating the difference between multiple layers of the same system. Geometry here was driven by a need to construct a standardized system where a mesh of panels could mechanically adjust to any 3d vector for any purpose.

catch-up post: first stab at building from scripts/video

2008-02-21T10:17:00.003-05:00

packing program

2008-01-29T11:09:00.000-05:00

This function places a set of programatic volumes tightly together in an effort to produce as minimal a total volume as possible. The animation shows solutions given modification of overall volumetric bounds. The algorithm works by assigning hierarchy to the axes (you can see this manifestation as nested while loops (note: no recursion here), the x-axis (east-west) is least-favored in that objects shift from x coord at origin only when z-positions have been exhausted. Z-position is only adjusted when y-position (north-south or along 14th St) is exhausted. This axis selection both responds to a site need (so create a surface along 14th St with a program that I know will not fill the entire site) and a need to make more efficient the packing function itself.

GCR brought up the efficiency of these scripts at the last december meeting. At the time these processes were computationally insignificant relative to processing power available. That turned out to be ironically prophetic as this next computational exercise has the potential to be wildly inefficient and computationally daunting. There turns out (to my great delight) to be a wealth of mathematic and CS research on the "bin-packing problem": wiki summary. Research into optimization and theory of 1-d packing (good diagrams).

So this is indeed an unsolvable problem in the mathematical proof sense. It is impossible to prove, for example, that any given packing algorithm will produce THE best solution. Algorithms can APPROACH idealization but the problem soon becomes that tiny improvements in solution-optimization mandate very inefficient algorithms. Its not hard to quickly come to a solution on the order of n^n magnitude (meaning that a programatic set with 100 elements will take 100 to the 100th power, one tretrigintillion, to arrive at a solution.

What I have here is much more efficient but does not ever produce the mathematically best solution. It is though, the ideal solution given computational resources. Of course at some point further optimization pushes us down wasteful roads as such detail is kind of insignificant given assumptions already build into this exercise.

Like all other scripts its important to appropriately draw the line between what is computationally useful and what is best solved with the intuitively smart human brain (trying to code that intuition is totally out of bounds). I think this line is somewhere around where this algorithm has gotten me. Future posts will show that my human edits modify it significantly, of course.

Here is the code which packs a set of smartBlocks, (see previous post)... a few things to note:
-the presort (helps with solution-optimization and efficiency but also biases solution slightly)
-if the current volume is exactly the same as the previous volume we can start the testing at the previous-volume position (a huge shortcut)
-there are some functions called here that I haven't posted because they are of little conceptual value. If anyone wants them to actually run this I'll happily provide them.

Function pack (arrBlocks, XRange, YRange, ZRange, arrOrigin, gap)
'first, sort array in decending order of volume
Dim newArray:newArray=sort(arrBlocks)


'position in best possible position
Dim k
Dim n
Dim outofBoundsX:outofBoundsX=vbFalse
Dim outofBoundsY:outofBoundsY=vbFalse
Dim outofBoundsZ:outofBoundsZ=vbFalse

Dim shiftNecessary

For k=0 To UBound(newArray)
shiftNecessary=vbFalse
If (k>0) Then
If checkShape(newArray(k),newArray(k-1)) Then 'if this shape is the same as last shape then  immediately place in last position
  Call Rhino.MoveObject(newArray(k)(0), newArray(k)(1), newArray(k-1)(1))
  newArray(k)(1)=newArray(k-1)(1)
Else
Call Rhino.MoveObject(newArray(k)(0), newArray(k)(1), arrOrigin)
newArray(k)(1)=arrOrigin
End If
Else 'otherwise place at origin
Call Rhino.MoveObject(newArray(k)(0), newArray(k)(1), arrOrigin)
newArray(k)(1)=arrOrigin
End If
For n=0 To UBound(newArray)
If (n<>k) Then
If (testIntersect(newArray(k),newArray(n))) Then
  shiftNecessary=vbTrue
End If
End If
Next

Do While ((shiftNecessary)And (((newArray(k)(1)(0)+newArray(k)(2))<arrOrigin(0)+Xrange)))
Call Rhino.print("inside the x move loop")
Call Rhino.print(k)
Do While ((shiftNecessary) And (((newArray(k)(1)(1)+newArray(k)(3))<arrOrigin(1)+Yrange)))
Call Rhino.print("inside the y move loop")
Call Rhino.print(k)
Do While ((shiftNecessary) And (((newArray(k)(1)(2)+newArray(k)(4))<arrOrigin(2)+Zrange)))
Call Rhino.print("inside the z move loop")
Call Rhino.print(k)
Call Rhino.MoveObject(newArray(k)(0), Array(0,0,0), Array(0,0,gap))
newArray(k)(1)(2)=newArray(k)(1)(2)+gap
shiftNecessary=testIntersectArray(newArray(k), newArray)
Loop

If (shiftnecessary) Then
 Call Rhino.MoveObject(newArray(k)(0), Array(0,0,0), Array(0,gap,0))
 newArray(k)(1)(1)=newArray(k)(1)(1)+gap
 Call Rhino.MoveObject(newArray(k)(0), newArray(k)(1), Array(newArray(k)(1)(0),newArray(k)(1)(1),arrOrigin(2)))
 newArray(k)(1)(2)=arrOrigin(2)
 shiftNecessary=testIntersectArray(newArray(k), newArray)
End If
Loop
If (shiftnecessary) Then
Call Rhino.MoveObject(newArray(k)(0), Array(0,0,0), Array(gap,0,0))
newArray(k)(1)(0)=newArray(k)(1)(0)+gap
Call Rhino.MoveObject(newArray(k)(0), newArray(k)(1), Array(newArray(k)(1)(0),arrOrigin(1),arrOrigin(2)))
newArray(k)(1)(2)=arrOrigin(2)
newArray(k)(1)(1)=arrOrigin(1)
shiftNecessary=testIntersectArray(newArray(0), newArray)
End If
Loop

Next

End Function

pseudo-class "smartblock"

2008-01-29T10:48:00.000-05:00

Since Rhino separates object identifiers (string variables which are unique names of objects in Rhino) from the data structures OF the actual geometries, none of these data structures are immediately available in rhinoscript (compare to actionscript and flash or any other object-oriented language). Rhino, the software generally can be considered parametric (kind of) but the scripting language is far removed in many cases from generative parameters.

Here is the example I was faced with: some identifiers I know reference rectangular volumes (but actually they are 6 linked surfaces). For the purposes of transforming (ie, packing algorithm mentioned above) and analysis (like calculating surface area) it is necessary to have regular access to basic geometric properties. I have thus created a kind of class structure for blocks. I called them "smartblocks" without really thinking... I regret that name now because its really wrong and stupid but its really too late to go back and change all instances. Ben warned against using actual classes so I created a basic array structure that I can reference like a class:
smartBlock
[0] string : object id of rectangular volume
[1] array(2) : anchor point
[2] double : length (x)
[3] double : width (y)
[4] double : height (z)
[5] double : area
[6] double : volume

so now I can pass the entire array to represent a block. I can then access any of the above properties in any process. I'm sure I will mirror this pseudo-class system for many other types of objects in the future.... Marek, I see something like this in your silo-future.

some functions that make use of this class:
createSmartBlock()
testIntesect(arrSmartblock1, arrSmartblock2)
numerous sort functions
pack(arrArrSmartBlock)

etc, etc.

structure+program

2007-12-08T19:45:00.000-05:00

investigating the image of structural armature supporting mutable program...

skinning:animation

2007-12-08T10:14:00.000-05:00

two primary relationships:
1)elements related to surface geometry
2)elements related to solar orientation

tweaking the algorithm to modify source shape based on position on surface:

site design:animation

2007-12-07T12:05:00.000-05:00

diagraming process

2007-11-09T18:19:00.001-05:00

Around the same time some [other] work I had done with scripting was dismissed for being pure diagram (and therefore unsatisfactory, irrelevant) I came to the realization that in this case actually the opposite is true.

observation: the animations I presented for last meeting had a tendency to look real.. At the time I had noted this was a potential pitfall of the process. I still think it was, given my intentions at the time. this was considered previously a representational problem as I was trying not to represent a building but rather a condition.

how much value can the digital aesthetic push a design process? Maybe some... I still believe that it will manifest in built proposal but i' beginning to doubt its value as a driving force.

my goal for the next few weeks will be to continue exploring what I have learned about this process in terms of media. However, I will put aside the "part/whole" series of investigations in favor of some parameters that are literal, explicit and directly relevant for a NASA administrative headquarters in Washington, DC. Rather than shy away from the discovered condition of these scripted animations looking too real I will embrace this representational result and begin to simply animate the parameters that will have the most impact on building form first, and immediately (or in the very near future anyway)

I am posting here two diagrams.

This puts what I have done so far in the context of my intended process over the course of thesis... This is incomplete and is reading to linear (though it is multi-linear)... The main point I am trying to get at is that my intention is to oscillate between digital media and architecture (as opposed to branching out then focusing back in later in the process)... At the same time I think this process SHOULD allow some constant, direct, forward motion in a building design... the "architectural proposal" is clearly my end goal. the '+' represents building proposal...

This next diagram is an effort to make visual a new algorithm for approaching animating parameters. First of all, there exists for me a goal of visualizing algorithms. The previous scripts began to be overly specific.... in other words each script was designed to produce one kind of operational effect. Like all scripting they are of course scalable and expandable to a certain extent. My goal though is to develop a neutral shell script for animation.... this will become the canvas of the project and essentially will be the most general form of the animation algorithm.... this will allow me to engage in animation research but still push forward with a building design. Each parameter will be explored as a function. The functions will be called as necessary from the animation function. Besides being a more sustainable process this will help make explicit the relationship between parameters and will promote experimentations in overlaying/separating parameters.

part/whole 4

2007-10-24T00:42:00.001-04:00

note in the script below where partial credit goes to Ben Callam. Array element on surface funciton is adapted from his design.

Option Explicit

Call animateSurfaceVolume()
Sub animateSurfaceVolume()
'this function adjusts surfaces over time and generates an animation
Dim arrLine1(), arrLine2()
ReDim arrLine1(4), arrLine2(4), arrLine1midGoal(4), arrLine2midGoal(4), arrIncrement1(4), arrIncrement2(4)
Dim line1, line2, line1b, line2b
Dim srfPlane1(3), srfplane2(3), srfplaneLoft1(3), srfplaneLoft2(3)
Dim arrObjects()
Dim thickness : thickness=10.0
Dim frames : frames = 144

arrline1(0)=Array(0,20,0)
arrline1(1)=Array(50,30,20)
arrline1(2)=Array(130,30,0)
arrline1(3)=Array(130,-30,0)
arrline1(4)=Array(0,-30,0)

arrline2(0)=Array(0,0,75)
arrline2(1)=Array(40,40,100)
arrline2(2)=Array(110,40,75)
arrline2(3)=Array(110,-40,75)
arrline2(4)=Array(0,-40,75)

arrLine1midGoal(0)=Array(10, -10, 100)
arrLine1midGoal(1)=Array(30, -10, 100)
arrLine1midGoal(2)=Array(40, -40, 100)
arrLine1midGoal(3)=Array(35, -50, 100)
arrLine1midGoal(4)=Array(-20, -50, 100)

arrLine2midGoal(0)=Array(-30, 30, -20)
arrLine2midGoal(1)=Array(15, 35, -20)
arrLine2midGoal(2)=Array(60, -60, -24)
arrLine2midGoal(3)=Array(55, -50, -5)
arrLine2midGoal(4)=Array(-20, -50, 0)

Dim w
For w=0 To 4
arrIncrement1(w)=Array((arrLine1midGoal(w)(0)-arrline1(w)(0))/frames, (arrLine1midGoal(w)(1)-arrline1(w)(1))/frames, (arrLine1midGoal(w)(2)-arrline1(w)(2))/frames)
arrIncrement2(w)=Array((arrLine2midGoal(w)(0)-arrline2(w)(0))/frames, (arrLine2midGoal(w)(1)-arrline2(w)(1))/frames, (arrLine2midGoal(w)(2)-arrline2(w)(2))/frames)
Next

Dim f
For f=0 To frames*1.5

srfPlane1(0)=Rhino.AddCurve(Array(arrline1(0),arrline1(1)), 3)
srfPlane1(1)=Rhino.AddCurve(Array(arrline1(1),arrline1(2)), 3)
srfPlane1(2)=Rhino.AddCurve(Array(arrline1(2),arrline1(3)), 3)
srfPlane1(3)=Rhino.AddCurve(Array(arrline1(3),arrline1(4)), 3)
'line1b=Rhino.JoinCurves (Rhino.OffsetCurve(line1, Array(0,0,0), 10,,0) , vbTrue)

srfPlane2(0)=Rhino.AddCurve(Array(arrline2(0),arrline2(1)), 3)
srfPlane2(1)=Rhino.AddCurve(Array(arrline2(1),arrline2(2)), 3)
srfPlane2(2)=Rhino.AddCurve(Array(arrline2(2),arrline2(3)), 3)
srfPlane2(3)=Rhino.AddCurve(Array(arrline2(3),arrline2(4)), 3)
'line2=Rhino.AddCurve(arrline2, 20)
'line2b=Rhino.JoinCurves (Rhino.OffsetCurve(line2, Array(0,0,0), 10,,0) , vbTrue)

'srfPlane1=(Rhino.AddLoftSrf(Array(line1,line2)))
srfplaneLoft1(0)=(Rhino.AddLoftSrf(Array(srfplane1(0),srfplane2(0))))(0)
srfplaneLoft1(1)=(Rhino.AddLoftSrf(Array(srfplane1(1),srfplane2(1))))(0)
srfplaneLoft1(2)=(Rhino.AddLoftSrf(Array(srfplane1(2),srfplane2(2))))(0)
srfplaneLoft1(3)=(Rhino.AddLoftSrf(Array(srfplane1(3),srfplane2(3))))(0)

srfplaneLoft2(0)=Rhino.OffsetSurface (srfplaneLoft1(0), thickness)
srfplaneLoft2(1)=Rhino.OffsetSurface (srfplaneLoft1(1), thickness)
srfplaneLoft2(2)=Rhino.OffsetSurface (srfplaneLoft1(2), thickness)
srfplaneLoft2(3)=Rhino.OffsetSurface (srfplaneLoft1(3), thickness)

'////////////////CREATE OBJECTS TO REPEAT
ReDim arrObjects(0)
Dim tempLine
tempLine=Rhino.AddLine(Array(0,0,0), Array(0,0,1.5))
Dim tempLinePoints
tempLinePoints=Array(Array(0,0,0), Array(0,0,1.5))
Dim tempCircle
tempCircle= Rhino.AddCircle(Rhino.WorldXYPlane, 2)
arrObjects(0)=Rhino.extrudeCurve(tempCircle, tempLine)
Call ornamentSkin(srfPlaneLoft1, srfplaneLoft2, arrObjects, arrObjects, tempLinePoints)

Dim d
For d=0 To UBound(srfplaneLoft1)
Rhino.deleteObject(srfplaneLoft1(d))
Next

For d=0 To UBound(srfplaneLoft2)
Rhino.deleteObject(srfplaneLoft2(d))
Next

Rhino.Command("render")
Call Rhino.Command("_-SaveRenderWindowAs"&" pw4_g" & "_" & CStr(f)& ".jpg")
'If ((f Mod 12)=0) Then
' Rhino.Command("_-SaveAs"&" pw4_"&CStr(f)&".3dm")
'End If
'step each element of point arrays
For d=0 To 4
arrline1(d)(0)=arrline1(d)(0)+arrIncrement1(d)(0)
arrline2(d)(0)=arrline2(d)(0)+arrIncrement2(d)(0)

arrline1(d)(1)=arrline1(d)(1)+arrIncrement1(d)(1)
arrline2(d)(1)=arrline2(d)(1)+arrIncrement2(d)(1)

arrline1(d)(2)=arrline1(d)(2)+arrIncrement1(d)(2)
arrline2(d)(2)=arrline2(d)(2)+arrIncrement2(d)(2)
Next

Call Rhino.DeleteObjects (Rhino.AllObjects)

Next

End Sub

Function ornamentSkin(byVal arrInnerSurfaces, byVal arrExtSurfaces, byval arrInnerObjects, byval arrOuterObjects, byVal guideLine)
Dim cols, rows, point
Dim arrNormal, strNewObject, arrNormalEnd
cols=15
rows=15
Dim U, V, t(1)
Dim a, b,c
For a=0 To UBound(arrInnerSurfaces)
'the stuff in this loop is addapted from Ben Callam's place and orient objects on surface script
U = Rhino.SurfaceDomain(arrInnerSurfaces(a), 0)
V = Rhino.SurfaceDomain(arrInnerSurfaces(a), 1)
For b=0 To rows
t(0) = U(0) + (((U(1) - U(0)) / rows) * b)
For c=0 To cols
t(1) = V(0) + (((V(1) - V(0)) / cols) * c)
point = Rhino.EvaluateSurface(arrInnerSurfaces(a), t)
arrNormal = Rhino.SurfaceNormal(arrInnerSurfaces(a), t)
If (IsArray(arrNormal))Then
arrNormalEnd = Rhino.VectorAdd(arrNormal, point)
strNewObject = Rhino.OrientObject (arrInnerObjects(0), guideLine, Array(point,arrNormalEnd), 1)
Else
Rhino.print("error. arrNormal not an array")
End If
Next
Next
Next

For a=0 To UBound(arrExtSurfaces)
U = Rhino.SurfaceDomain(arrExtSurfaces(a), 0)
V = Rhino.SurfaceDomain(arrExtSurfaces(a), 1)
For b=0 To rows
t(0) = U(0) + (((U(1) - U(0)) / rows) * b)
For c=0 To cols
t(1) = V(0) + (((V(1) - V(0)) / cols) * c)
point = Rhino.EvaluateSurface(arrExtSurfaces(a), t)
arrNormal = Rhino.SurfaceNormal(arrExtSurfaces(a), t)
If (IsArray(arrNormal))Then
arrNormalEnd = Rhino.VectorAdd(arrNormal, point)
strNewObject = Rhino.OrientObject (arrOuterObjects(0), guideLine, Array(point,arrNormalEnd), 1)
End If
Next
Next
Next

End Function

site model

2007-10-18T01:57:00.000-04:00

part/whole 3.2

2007-10-03T21:20:00.001-04:00

updated some of the values (see comment at the end of previous version) to get this where it should be...

program diagram

2007-10-02T08:31:00.001-04:00

this has begun to evolve into a "flow of information diagram" instead of a "NASA structure" diagram. Still very much in progress

part/whole 3.. active subtractive figure

2007-10-02T01:17:00.000-04:00

This video-generation algorithm I've been developing is continuing to excite me about a lot of different related conditions. Right now I'm trying to focus on how this can be different from my previous work with animations... Namely that I can now animate by manually establishing parameters in the script. In other words, I am no longer limited to tweaking objects overtime given the editable parameters of said object (which were at some point limiting)...

One thing that has been on my mind for a long time is animating the figural void... an "active subtractive figure." This condition now becomes relatively straightforward to animate as the forms are regenerated with each new frame.

while the hard part with this script is done I still need to tweak the values/rates at which the voids transform... the cube is too much there too much of the time.

the script:
Option Explicit

partwhole3()
Sub partwhole3()

Dim tempVol(0)
Dim tempSurf
Dim templine
Dim intframeCounter
Dim arrRect1(3)
Dim arrRect2(3)
Dim arrRect3(3)
Dim arrCubeSolid(0)
Dim arrCubeVoid(1)
'x
Dim intWidthCube1
Dim intWidthCube2
Dim intWidthCube3
'y
Dim intLengthCube1
Dim intLengthCube2
Dim intLengthCube3
'z
Dim intHeightCube1
Dim intHeightCube2
Dim intHeightCube3
'position modifiers
Dim intTransCube1(2)
Dim intTransCube2(2)
Dim intTransCube3(2)
'set initial values
intFrameCounter=0
intTransCube1(0)=0
intTransCube1(1)=0
intTransCube1(2)=0
intTransCube2(0)=0
intTransCube2(1)=0
intTransCube2(2)=0
intTransCube3(0)=200
intTransCube3(1)=200
intTransCube3(2)=50
'1
intWidthCube1=300
intLengthCube1=300
intHeightCube1=300
'2
intWidthCube2=50
intLengthCube2=100
intHeightCube2=400
'3
intWidthCube3=500
intLengthCube3=500
intHeightCube3=20
Do While (intFrameCounter<300)
'draw initial shapes
arrRect1(0)=Array(0+intTransCube1(0),0+intTransCube1(1),0+intTransCube1(2))
arrRect1(1)=Array(intWidthCube1+intTransCube1(0),0+intTransCube1(1),0+intTransCube1(2))
arrRect1(2)=Array(intWidthCube1+intTransCube1(0),intLengthCube1+intTransCube1(1),0+intTransCube1(2))
arrRect1(3)=Array(0+intTransCube1(0),intLengthCube1+intTransCube1(1),0+intTransCube1(2))
tempsurf=Rhino.AddSrfPt(arrRect1)
tempLine=Rhino.Addline(Array(0+intTransCube1(0),0+intTransCube1(1),0+intTransCube1(2)), Array(0+intTransCube1(0),0+intTransCube1(1),intHeightCube1+intTransCube1(2)))
arrCubeSolid(0)=Rhino.ExtrudeSurface(tempSurf, tempLine)
arrRect2(0)=Array(0+intTransCube2(0),0+intTransCube2(1),0+intTransCube2(2))
arrRect2(1)=Array(intWidthCube2+intTransCube2(0),0+intTransCube2(1),0+intTransCube2(2))
arrRect2(2)=Array(intWidthCube2+intTransCube2(0),intLengthCube2+intTransCube2(1),0+intTransCube2(2))
arrRect2(3)=Array(0+intTransCube2(0),intLengthCube2+intTransCube2(1),0+intTransCube2(2))
tempsurf=Rhino.AddSrfPt(arrRect2)
tempLine=Rhino.Addline(Array(0+intTransCube2(0),0+intTransCube2(1),0+intTransCube2(2)), Array(0+intTransCube2(0),0+intTransCube2(1),intHeightCube2+intTransCube2(2)))
arrCubeVoid(0)=Rhino.ExtrudeSurface(tempSurf, tempLine)
arrRect3(0)=Array(0+intTransCube3(0),0+intTransCube3(1),0+intTransCube3(2))
arrRect3(1)=Array(intWidthCube3+intTransCube3(0),0+intTransCube3(1),0+intTransCube3(2))
arrRect3(2)=Array(intWidthCube3+intTransCube3(0),intLengthCube3+intTransCube3(1),0+intTransCube3(2))
arrRect3(3)=Array(0+intTransCube3(0),intLengthCube3+intTransCube3(1),0+intTransCube3(2))
tempsurf=Rhino.AddSrfPt(arrRect3)
tempLine=Rhino.Addline(Array(0+intTransCube3(0),0+intTransCube3(1),0+intTransCube3(2)), Array(0+intTransCube3(0),0+intTransCube3(1),intHeightCube3+intTransCube3(2)))
arrCubeVoid(1)=Rhino.ExtrudeSurface(tempSurf, tempLine)

Rhino.DeleteObject (tempLine)
Rhino.DeleteObject (tempSurf)
'tempVol(0)=Rhino.CopyObject (arrCube3(0))
Call Rhino.BooleanDifference(arrCubeSolid,arrCubeVoid,True)
'Call Rhino.BooleanDifference(arrCube2,tempVol,True)

'generate frame
Rhino.Command("render")
'Call Rhino.sleep(3000)
Call Rhino.Command("_-SaveRenderWindowAs"&" m" & "_" & CStr(intframecounter)& ".jpg")

intFrameCounter=intFrameCounter+2
'print(Sin(Rhino.ToRadians (intFrameCounter)))
Rhino.Command("all")
Rhino.Command("delete")

'set new values for next round of generation
'still need to tweak these to maintain overlap

intWidthCube2=300+(600*Sin(Rhino.ToRadians (intFrameCounter*4)))
intLengthCube2=100+(380*Sin(Rhino.ToRadians (intFrameCounter*3)))
intHeightCube2=400+(1100*Sin(Rhino.ToRadians (intFrameCounter*5)))
intTransCube2(0)=0+30*Sin(Rhino.ToRadians(intFrameCounter/2))
intTransCube2(1)=50+10*Sin(Rhino.ToRadians(intFrameCounter/2))

intWidthCube3=500+(800*Sin(Rhino.ToRadians (intFrameCounter*4)))
intLengthCube3=500+(800*Sin(Rhino.ToRadians (intFrameCounter*3)))
intHeightCube3=100+(400*Sin(Rhino.ToRadians (intFrameCounter*5)))
intTransCube3(0)=0+30*Sin(Rhino.ToRadians(intFrameCounter/2))
intTransCube3(1)=50+10*Sin(Rhino.ToRadians(80+intFrameCounter/2))
intTransCube3(2)=50+35*Sin(Rhino.ToRadians(100+intFrameCounter/2))
Loop
End Sub
also coming soon: animating a "wrapping surface" based on some kind of evolving innards... also on th

part/whole video 2

2007-09-25T02:24:00.000-04:00

This is first attempt at video generation entirely from script.... the part/whole experiments still have a long way to go but I think this is a valid proof of concept...
Here is the Rhinoscrpit:
Option Explicit

partwhole1()
Sub partwhole1()
Dim arrRect(3)
Dim strCurRect
Dim heightGuide
Dim strCurBlock
Dim newX
Dim newY
Dim newZ
Dim intcounter
Dim intframecounter
Dim density

intframecounter=0
Do While intframecounter<55
intcounter=0
heightGuide=Rhino.Addline(Array(0,0,0), Array(0,0,1))
intframecounter=intframecounter+1
Do While intcounter<(intframecounter*12)
intcounter=intcounter+1
density=1+(intframecounter/14)
newX=Rnd()*density*Rnd()*density*Rnd()*density
newY=Rnd()*density*Rnd()*density*Rnd()*density
newZ=Rnd()*density*Rnd()*density*Rnd()*density
arrRect(0)=Array(0,0,0)
arrRect(1)=Array(0,2,0)
arrRect(2)=Array(1,2,0)
arrRect(3)=Array(1,0,0)
strCurRect=Rhino.AddSrfPt(arrRect)
strCurBlock=Rhino.ExtrudeSurface(strCurRect, heightGuide)
Call Rhino.MoveObject(strCurBlock, Array(0,0,0), Array(newX,newY,newZ))
Call Rhino.SurfaceIsocurveDensity(strCurBlock, -1)
Loop
Rhino.Command("render")
Call Rhino.sleep(3000)
Call Rhino.Command("_-SaveRenderWindowAs"&" d" & "_" & CStr(intframecounter)& ".jpg")
Rhino.Command("all")
Rhino.Command("delete")
Loop

End Sub

another potential site

2007-09-23T00:44:00.000-04:00

14th St. and D St. SW

program

2007-09-22T10:59:00.000-04:00

part/whole video 1

2007-09-22T10:44:00.000-04:00

EDIT: I realize that this exercise demands at least some explanation/comment. This was the first in what has become (and what I hope will expand further) a series of animations that straddle the line between art and representation. The goal, beyond those which are explicit in the series title is to simultaneously structure objects represented in the frame (in this case as a shifting but recognizable perspective grid marked by cubes) and the pixel-based, 2d graphics of the composition itself.

This version leans more toward the latter. Part/whole 2 on the other hand almost exclusively relies on representation of objects in the frame (a result at least partly of the script generating objects)

A note about methodology... the motion of this video is generated entirely by the modification of camera settings (position, FOV, angle). The 3d objects are entirely stationary in the virtual space of the model.

office volume relationship test1

2007-09-21T16:47:00.000-04:00

preliminary table of contents

2007-09-04T08:32:00.000-04:00

Selecting the test case

Representation and Image Precedent Analysis
Crawford house drawings
Cecil Balmond drawings

Animation and graphic arts Precedent Analysis

Built precedents: a focus on spatial clarity in complex cultural contexts
Prada Store
San Francisco Federal Building
….

Scripting Concept

Visualizing NASA

Visualizing Washington, DC

Visualizing Visualization

Fashion/Coolness and virtue in Architecture

Continuity of Image, variation in frame of reference in translation to building

Representation, poetry and concept

working abstract

2007-09-04T08:31:00.000-04:00

Information presented graphically and treated as an image can represent emergent effects and qualities that can be translated into building. Especially of interest is the graphic aggregation of complex data. Clarity and graphic sustainability are achieved by exaggeration, simultaneity, translation and derivation rather than simplification or regulation. This attitude involves a process of animation, mapping and charting.

This thesis explores the translations of these representations into built form as well as the role of information, data and image in society. “Coolness” and popularity, acknowledged barometers of fluency in the collective language and resonance with the collective consciousness of a society that operates largely based on complex networks of information and communication.

As applied to a selected test case, the NASA administrative headquarters in Washington, DC, this process-oriented thesis tests the application of information visualization on a program and site embedded themselves with information-based contexts and image-based parameters.

working introduction

2007-08-30T10:44:00.001-04:00

Image +Motion
This thesis explores how animation can be broadly and specifically applied to architectural design and discourse. Issues of simultaneity, fashion and the clarity with which imagery fades into and out of our societal consciousness will be explored in animate terms. This and other variable parameters can then be expressed directly, in architecture and in representation / process.
This thesis will explore:
The links between :
image and animation,
image and architecture
architecture and animation

Investigations into animation will cross into the parallel realms of cinema and graphic arts and regularly and rigidly inform this proposal for a government office building in Washington, DC. This “reaching approach” to architectural design will seek to expand and enhance the usual process of designing architecture by revealing more direct and less symbolic representations of the human perceptual experience in architecture. Graphics will be treated as artifact, representative of a recorded process, a currently proposed built form and future experiments. Methods and syntax from film/cinema/video art/TV/commercials, including montage, cutting, etc will be applied to architecture.

An animate process must be non-linear. In this sense, animations will be generated from established architectural parameters as well as ideals of animation itself. The animation as artifact will promote an agenda of representational primacy.

Program+Site
This thesis proposes that animation, as an approach to process, need not require a specific condition to be useful, fruitful or interesting. The government office building, specifically for the Administrative headquarters for the National Aeronautics and Space Administration will provide a suitably varied set of temporal, image-based requirements-- functional, communicative and social. NASA’s image, in the context of society’s singular, collective identification of its role and value, as eroded away from the glory years surrounding the moon landing. On a larger conceptual scale, it is appropriate to note that “government” itself has in image problem in our society’s own terms.

The primary administrative portion of NASA, that portion which is here in Washington, DC is, in large part, private. Most public interaction with NASA appropriately occurs on the sites of mission launches and the like. What is very public is NASA administration’s linking with these other sites (thousands of miles away in some cases). Making explicit this connection will be a visible goal. Simultaneously, this architecture must record appropriate nostalgia for a time when computers filled rooms and NASA was novel and represent enthusiastic technological potential of NASA in the present.

The selected site behind the National Air and Space museum at 6th St. SW and Independence Avenue will provide the appropriate stage set for the proposed architecture: visible through one layer of architecture from the national mall , dimensionally restrictive and varied in the naturally of the edge. The site also acknowledges the likely hood of treating neighboring buildings as states in an already animate condition, ripe for distortion, growth and adaptation.

NASA has a rich, urban fabric of research facilities, their density entirely virtual as they are physically quite sprawling. A functional goal will be to promote visual connections between and through this “NASA network city.” Vastness, quantity and complexity of information inherent in this environment will be expressed overtly while physical distance will be suppressed through use of animate devices (frame, illusion, etc) to promote phenomenal transparency. Quite literally here, NASA administrators will require representations framed into the architecture directly connecting them to the other facilities.

This thesis will make NASA popular, hip, edgy and cool while proving that coolness and popularity are indeed virtuous qualities.

Site

2007-08-30T10:40:00.000-04:00

Independence and 6th SW

NASA

2007-08-30T10:35:00.000-04:00

So the structure of NASA might be able to serve as kind of an urban/virtual/conceptual context

view from across mall

2007-08-30T10:25:00.000-04:00

I had the opportunity to visit the newseum under construction which is across the mall... Got some great shots of the site, or part of it that is. Here is one

Concept Diagram

2007-08-30T10:17:00.001-04:00

I'm starting a diagram which will serve as conceptual diagram/bibliography/something I can script to help me see trends and focus the investigation. Right now I have allowed the arrangement to be variable while the links are set... so concepts that are allegedly important ad link to more other things tend toward the center.