Super_Surface Fabrication @ AA Project Review Exhibition

A few pictures of the models from the workshop displayed at this year final review at the Architectural Association.
(Thanks to Theerapat Jirathiyut for the pictures and Goli Jalali for modeling)

WORKSHOP FINAL REVIEW

Just a few shots of the final review..

Spiral population

Populating a unit with ability to vary within itself on 1) a surface 2) a spiral

1) UNIT ON A SURFACE

import rhinoscriptsyntax as rs

import random

radius=10

circles=[]

def geometry(center,radius,factor):

    circle=rs.AddCircle(center,radius)

    divpts=rs.DivideCurve(circle,3,create_points=True)

    line=rs.AddInterpCurve([center,divpts[0],divpts[1],divpts[2],center],3)

    vector=rs.VectorCreate(center,divpts[1])

    length=rs.VectorLength(vector)

    scaledvector=rs.VectorScale(vector,length*factor)

    mid=rs.VectorAdd(center,scaledvector)

    middle=rs.AddPoint(mid)

    trans=radius*2

    movedmid=rs.MoveObject(middle,[0,0,trans])

    piece=rs.ExtrudeCurvePoint(line,movedmid)

    numberofelements=random.randint(5,15)

    for i in range (0,numberofelements):

        rotatepiece=rs.RotateObject(piece,movedmid,(360/numberofelements)*i,copy=True)

        rs.ScaleObject(rotatepiece,middle,[1+0.01*i,01+0.01*i,1+0.01*i])

def center (pointlist):

    x=0

    y=0

    z=0

    for i in range (0,len(pointlist)):

        x = x + pointlist[i][0]

        y = y + pointlist[i][1]

        z = z + pointlist[i][2]

    x=x/len(pointlist)

    y=y/len(pointlist)

    z=z/len(pointlist) 

    return [x,y,z]

def samplesurface(strSrf, intUdivisions,intVdivisions):

    listUdomain = rs.SurfaceDomain(strSrf,0)

    listVdomain = rs.SurfaceDomain(strSrf,1)

    floatUstep = (listUdomain[1]-listUdomain[0])/intUdivisions

    floatVstep = (listVdomain[1]-listVdomain[0])/intVdivisions

    listofrows = []

    for i in rs.frange(listUdomain[0],listUdomain[1],floatUstep):

        columnlist = []

        for j in rs.frange(listVdomain[0],listVdomain[1]+floatVstep,floatVstep):

            columnlist.append(rs.EvaluateSurface(strSrf,i,j))

        listofrows.append(columnlist)

    return listofrows

strSrf = rs.GetObject("surface",8)

intUdivisions = 10

intVdivisions = 10

listofpoints = samplesurface(strSrf,intUdivisions,intVdivisions)

circles=[]

midpoints=[]

vectorlist=[]

for i in range (0,len(listofpoints)-1):

    for j in range (0,len(listofpoints[i])-1):

        pointlist=[]

        pointlist.extend([listofpoints[i][j],listofpoints[i][j+1],listofpoints[i+1][j+1],listofpoints[i+1][j]])       

        midpoint=center(pointlist)

        midpoints.append(rs.AddPoint(midpoint))

radius=random.randint(5,15)

for i in range (0,len(midpoints)-1):

    center=midpoints[i]

    factor=-.2*(i/100)

    radius=10*(1+0.01*i)

    geom=geometry(center,radius,factor)

2)UNIT ON A SPIRAL

import rhinoscriptsyntax as rs

import math

import random

def geometry(center,radius,factor):

    circle=rs.AddCircle(center,radius)

    divpts=rs.DivideCurve(circle,3,create_points=True)

    line=rs.AddInterpCurve([center,divpts[0],divpts[1],divpts[2],center],3)

    vector=rs.VectorCreate(center,divpts[1])

    length=rs.VectorLength(vector)

    scaledvector=rs.VectorScale(vector,length*factor)

    mid=rs.VectorAdd(center,scaledvector)

    middle=rs.AddPoint(mid)

    trans=radius*2

    movedmid=rs.MoveObject(middle,[0,0,trans])

    piece=rs.ExtrudeCurvePoint(line,movedmid)

    numberofelements=random.randint(5,15)

    for i in range (0,numberofelements):

        rs.RotateObject(piece,movedmid,(360/numberofelements)*i,copy=True)

radius=10

bigpoints=[]

pointlist=[]

for i in range(0,20):

    r=i+1

    x=7*r*math.sin(i)

    y=7*r*math.cos(i)

    points=rs.AddPoint(x,y,i*5)

    bigpoints.append(points)

    for j in range(0,20):

        r=j+1

        x=r*math.sin(j)

        y=r*math.cos(j)

        points=rs.AddPoint(x,y,j)

        pointlist.append(points)

        trans=rs.VectorCreate(pointlist[0],bigpoints[i])

        pointlist.extend(rs.CopyObjects(points,translation=-trans))

        for k in range (0,len(pointlist)-1):

            center=pointlist[k]

            factor=-.3*(i/70)

            geom=geometry(center,radius,factor)

Differential Depth and Aperture population of a Mobius Strip

import rhinoscriptsyntax as rs

import math

from System.Drawing import Color

#define a mobius strip surface

xy =(10,10)

o=-0.5

p=0.5

op=1/(xy[0])

vp =2*math.pi

vpstep=vp/(xy[1])

points = []

a=2

for i in rs.frange(-0.5,0.5,op):

    for j in rs.frange(0,vp,vpstep):

        b=j/2

        x=math.cos(j)*(a+i*math.cos(b))

        y=math.sin(j)*(a+i*math.cos(b))

        z=i*math.sin(b)

        pt = x,y,z

        points.append(pt)

xy=(xy[0]+1,xy[1]+1)

rs.AddLayer('surface',Color.Black)

srf=rs.AddSrfPtGrid(xy, points)

rs.ObjectLayer(srf,'surface')

rs.EnableRedraw(False)

#divide the srf

uDom = rs.SurfaceDomain(srf,0)

vDom = rs.SurfaceDomain(srf,1)

uDivide = 10

vDivide = 40

Ustep = (uDom[1]-uDom[0])/int(uDivide)

Vstep = (vDom[1]-vDom[0])/int(vDivide)

ptLt = []

ptNorm=[]

for i in rs.frange(uDom[0],uDom[1],Ustep):

    pts = []

    normLt=[]

    for j in rs.frange(vDom[0],vDom[1],Vstep):

        evalpt=rs.EvaluateSurface(srf,i,j)

        norm=rs.SurfaceNormal(srf,(i,j))

        norm=rs.VectorUnitize(norm)

        norm=norm*.1

        pts.append(evalpt)

        normLt.append(norm)

    ptNorm.append(normLt)

    ptLt.append(pts)

crvLt=[]

crvcentLt=[]

rs.AddLayer('curves',Color.DarkRed)

crvsTP=[]

centTP=[]

cellNormsLt=[]

cellcrvsLt=[]

cellPtsLt=[]

for i in range(uDivide):

    crvcent=[]

    crvs=[]

    cellpt=[]

    for j in range((vDivide)):

        pt1=ptLt[i][j]

        ptn1=ptNorm[i][j]

        pt2=ptLt[i+1][j]

        ptn2=ptNorm[i+1][j]

        pt3=ptLt[i][j+1]

        ptn3=ptNorm[i][j+1]

        pt4=ptLt[i+1][j+1]

        ptn4=ptNorm[i+1][j+1]

        cellPts=[pt1,pt2,pt4,pt3,pt1]

        cellNorms=[ptn1,ptn2,ptn4,ptn3,ptn1]

        cellNormsLt.append(cellNorms)

        cellcrv=rs.AddPolyline(cellPts)

        crv=rs.AddCurve(cellPts,3)

        cellcrvsLt.append(cellcrv)

        rs.ObjectLayer(crv,'curves')

        crvs.append(crv)

        crvsTP.append(crv)

        cent=rs.CurveAreaCentroid(crv)

        centTP.append(cent[0])

        crvcent.append(cent[0])

        cellPtsLt.append(cellPts)

    crvcentLt.append(crvcent)

#define multiple attractor points and define weighting of each pt on surface to closest attractor point

def closestpt(attpts,pt):

    distLt=[]

    count=0

    for u in attpts:

        count=count+1

        dist=rs.Distance(u,pt)

        distLt.append(dist)

    mindist=min(distLt)

    lenLt=len(distLt)

    for j in range(0,lenLt):

        if distLt[j]==mindist:

            return distLt[j]

attpts=rs.GetPoints('pick pts')

lineLt=[]

dist=[]

for u in crvcentLt:

    liLt=[]

    for j in u:

        di=closestpt(attpts,j)

        liLt.append(di)

        dist.append(di)

    lineLt.append(liLt)

#create apertures and define depth of surface in accordance to weighting of pt

mindist=min(dist)

maxdist=max(dist)

listLen=len(crvsTP)

mindepth=0.1

maxdepth=3

offptsLt=[]

offptsreLt=[]

offcrvLt=[]

offcrvreLt=[]

loftsqLt=[]

offcrvcentLt=[]

offcrvrecentLt=[]

offlineLt=[]

offlinereLt=[]

for i in range(listLen):

    scale=(dist[i]-mindist)/(maxdist-mindist)*(maxdepth-mindepth)+mindepth

    offpts=[]

    offptsre=[]

    listlen=len(cellNormsLt[i])

    for j in range(listlen):

        pt =cellNormsLt[i][j]*scale

        ptvect=rs.VectorAdd(pt,cellPtsLt[i][j])

        ptvectrev=rs.VectorAdd(-pt,cellPtsLt[i][j])

        offpts.append(ptvect)

        offptsre.append(ptvectrev)

   

    offline=rs.AddPolyline(offpts)

    offlineLt.append(offline)

    offcrv=rs.AddCurve(offpts,3)

    offcrvcent=rs.CurveAreaCentroid(offcrv)

    offcrvcentLt.append(offcrvcent[0])

    offcrvLt.append(offcrv)

   

    offlinere=rs.AddPolyline(offptsre)

    offlinereLt.append(offlinere)

    offcrvre=rs.AddCurve(offptsre,3)

    offcrvrecent=rs.CurveAreaCentroid(offcrvre)

    offcrvreLt.append(offcrvre)

    offcrvrecentLt.append(offcrvrecent[0])

   

    offptsLt.append(offpts)

    loftsq=rs.AddLoftSrf([offline,cellcrvsLt[i],offlinere])

    loftsqLt.append(loftsq)

    offptsreLt.append(offptsre)

#scale apertures and create lofted surfaces

minscale=0.2

maxscale=1.0

for i in range(listLen):

    scale=(dist[i]-mindist)/(maxdist-mindist)*(maxscale-minscale)+minscale

    mid=rs.ScaleObject(crvsTP[i],centTP[i],(scale,scale,scale),False)

    top=rs.ScaleObject(offcrvLt[i],offcrvcentLt[i],(scale,scale,scale),False)

    bot=rs.ScaleObject(offcrvreLt[i],offcrvrecentLt[i],(scale,scale,scale),False)

   

    par=rs.CurveClosestPoint(top,offptsLt[i][0])

    parre=rs.CurveClosestPoint(bot,offptsreLt[i][0])

    parmid=rs.CurveClosestPoint(mid,offptsreLt[i][0])

   

    #adjust seam to loft smoothly

    rs.CurveSeam(bot,parre)

    rs.CurveSeam(top,par)

    rs.CurveSeam(mid,parmid)

   

    rs.AddLoftSrf([offlinereLt[i],bot])

    rs.AddLoftSrf([offlineLt[i],top])

   

    lofttube=rs.AddLoftSrf([bot,mid,top])

rs.LayerVisible('surface',False)

rs.EnableRedraw(True)

multiple attractor points set points of shallow component depth and aperture size