S.S.S.S.

Processing with Class

2009-08-23T21:03:00.000-07:00


//---------------------------------------
ArrayList veinpopulation;
ArrayList leafpopulation;

void setup(){
 size(1200, 700);
 //background(241);
 smooth();
 int w = 60;
 veinpopulation = new ArrayList();
 for( int i=0; i<11; i++ ){
  veinpopulation.add( new vein( int(random(w, width-w)), int(random(7, 51)) ));
 }
}

void draw(){
 background(241);
 noLoop();
 for( int i=0; i<veinpopulation.size(); i++ ){
  vein v = (vein) veinpopulation.get(i);
  v.render();
  for( int j=0; j<leafpopulation.size(); j++ ){
   leaf f = (leaf) leafpopulation.get(j);
   f.render();
  }
 }
}
//---------------------------------------


//---------------------------------------
class vein{
//variables
int x, leafNum;
int strokeColor = color( int(random(150,221)), int(random(71,180)), 0, int(random(69,255)) );
//constructor
vein( int _x, int _leafNum ){
 x = _x;
 leafNum = _leafNum;
}

void render(){
 strokeWeight(1);
 stroke( strokeColor );
 line( x, 0, x, height );
 int gap = height /leafNum;
 int r = int(random(gap));
 int direction = 1;
 leafpopulation = new ArrayList();
 for( int i=0; i<leafNum; i++ ){
  int fillColor = color( int(random(150,221)), int(random(71,180)), 0,   int(random(69,255)) );
  leafpopulation.add( new leaf( x, gap*i +r, int(random(7, 41)), direction, fillColor ));
  direction = -direction;
 }
}
}
//---------------------------------------


//---------------------------------------
class leaf{
//variables
int x, y, leafSize, leafDir, leafSpeed, leafColor;
//constructor
leaf( int _x, int _y, int _leafSize, int _leafDir, int _leafColor ){
 x = _x;
 y = _y;
 leafSize = _leafSize;
 leafDir = _leafDir;
 leafColor = _leafColor;
}

void render(){
 noStroke();
 fill( leafColor );
 pushMatrix();
 translate(x, y);   //move to position
 scale( leafSize );   //scale to size
 beginShape();   //draw the shape
 vertex( leafDir, -0.6875 );
 bezierVertex( leafDir, -0.6875, leafDir*0.4375, -1.03125, 0, 0 );
 bezierVertex( 0, 0, leafDir, 0.375, leafDir, -0.6875 );
 endShape();
 popMatrix();
}
}
//---------------------------------------

Processing with Function

2009-08-23T20:57:00.000-07:00


//---------------------------------------
void setup(){
 size(1200, 700);
 smooth();
 background(241);
 noLoop();
}

void draw(){
 for( int i=0; i<9; i++){
  int s = int(random(7, 51));
  int w = 2*s;
  int n = int(random(9, 51));
  drawVine(  int(random(w, width-w)), n, s );
 }
}
//---------------------------------------


//---------------------------------------
void drawVine( int x, int numLeaves, int leafSize ){
 strokeWeight(1);
 stroke( 0, int(random(0, 71)), int(random(71, 180)));
 line( x, 0, x, height );
 strokeWeight( 1/leafSize );
 int gap = height /numLeaves;
 int direction = 1;
 for( int i=0; i<numLeaves; i++ ){
  int colorR = 0;
  int colorG = int(random(0, 71));
  int colorB = int(random(71, 180));
  noStroke();
  fill( colorR, colorG, colorB, random(99, 255) ); //random color for fill
  int r = int(random(gap));
  drawLeaf( x, gap*i +r, leafSize, direction );
  direction = -direction;
 }
}
//---------------------------------------


//---------------------------------------
void drawLeaf( int x, int y, int size, int dir ){
 pushMatrix();
 translate(x, y);   //move to position
 scale(size);   //scale to size
 beginShape();   //draw the shape
 vertex( dir, -0.6875 );
 bezierVertex( dir, -0.6875, dir*0.4375, -1.03125, 0, 0 );
 bezierVertex( 0, 0, dir, 0.375, dir, -0.6875 );
 endShape();
 popMatrix();
}
//---------------------------------------

Hexagon Panelization

2009-03-17T23:45:00.000-07:00

Panelization casestydy: Santa Caterina Market.

Each panel is flat, leaving slight gap to its neighbors. I started with hexagon-shape grid on surface as in the last image. Six points are identified and stored in array per one panel. Then to produce flat panels, I projected each vector to each normal plane (red). Vector projection is simple VectorAdd method except that I needed to flip the normals (blue) depending on the beginning angle between normals and direct vectors (white) on surface.

PowerCopy Automation

2008-10-18T23:29:00.000-07:00

Fabric pattern completed via powerCopy Automation. Method is the following three steps →

STEP1. BeginInstanceFactory: to initialize the InstanceFactory with the reference and the document where it is stored. This step must be called once at the beginning whatever the number of instantiations are done.

STEP2. It is composed of five methods that must be called in the order. This set of five methods can be called in a loop in order to make several instantiations.

a. The method BeginInstantiate: to initialize all data of the reference.
b. The method PutInputData: to set a value to any input.
c. The method GetParameter: to retrieve published parameter.
d. The method Instantiate: to recreate the reference.
e. The method EndInstantiate: to indicate the instantiation is done.

STEP3. EndInstantiateFactory: to end instantiation and cleaning the InstanceFactory. When doing several instantiations in a loop, this step must be called just once at the end of all instantiations.

boundary cone

2008-10-11T22:44:00.000-07:00

Option Explicit
'Author: YukiukiH
'Date: 10/08/2008
'compatibility: Rhino4
''boundary CONE
'----------------------------------------------------------------------------------------------
Dim strTrgPt, arrTrgPt
strTrgPt = Rhino.GetObject ("select a target point", 1)
Dim strALLRefPts
strALLRefPts = Rhino.GetObjects ("select reference points", 1)
Dim strPtDir, arrPtDir, arrDirVector
strPtDir = Rhino.GetObject ("select a point for direction", 1)
Dim strRefPts
strRefPts = boundaryCone (strTrgPt, strALLRefPts, strPtDir, 400, 30)

'color
Dim intR, intG, intB
Dim i
For i = 0 To UBound(strRefPts)
intR =255
intG =25+i*Rnd()*2
intB =0
Call Rhino.ObjectColor (strRefPts(i), RGB(intR, intG, intB))
Next
Call Rhino.print("execution completed")

'----------------------------------------------------------------------------------------------
'----------------------------------------------------------------------------------------------
Function boundaryCone (strTrgPt, strALLRefPts, strPtDir, dblBoundCos, dblBoundAngle)
Dim arrResult

'coordinate extraction
'----------------------------------------------------------------------------------------------
Dim arrTrgPt
arrTrgPt = Rhino.PointCoordinates (strTrgPt)
Dim arrALLRefPts()
Dim i
For i = 0 To UBound(strALLRefPts)
ReDim Preserve arrALLRefPts(i)
arrALLRefPts(i) = Rhino.PointCoordinates (strALLRefPts(i))
Next
Dim arrPtDir
arrPtDir = Rhino.PointCoordinates (strPtDir)

'set boundary
'---------------------------------------
Dim arrLine1(1), arrLine2(1)
Dim dblAngles, dblVectorLength, dblDist
Dim arrREFPts(), strRefPts()
Dim n, m
n = 0
For m = 0 To UBound(arrALLRefPts)
arrLine1(0) = arrPtDir
arrLine1(1) = arrTrgPt
arrLine2(0) = arrALLRefPts(m)
arrLine2(1) = arrTrgPt
dblAngles = Rhino.Angle2 (arrLine1, arrLine2)

If dblAngles(0) < dblBoundAngle Then
dblVectorLength = Rhino.Distance (arrALLRefPts(m), arrTrgPt)
dblDist = dblVectorLength *Cos(dblAngles(0)*2*dblPi/360) 'cone
If dblDist < dblBoundCos Then
Call Rhino.Print ("through point: " & CStr(n+1))
ReDim Preserve arrRefPts(n)
arrRefPts(n) = arrALLRefPts(m)
ReDim Preserve strRefPts(n)
strRefPts(n) = strALLRefPts(m)
n = n+1
End If
End If

Next
'---------------------------------------
arrResult = strRefPts
boundaryCone = arrResult
End Function
'----------------------------------------------------------------------------------------------
'----------------------------------------------------------------------------------------------

boundary partial sphere

2008-10-11T10:42:00.000-07:00

Option Explicit
'Author: YukiukiH
'Date: 10/08/2008
'compatibility: Rhino4
''boundary PARTIAL SPHERE
'----------------------------------------------------------------------------------------------
Dim strTrgPt, arrTrgPt
strTrgPt = Rhino.GetObject ("select a target point", 1)
Dim strALLRefPts
strALLRefPts = Rhino.GetObjects ("select reference points", 1)
Dim strPtDir, arrPtDir, arrDirVector
strPtDir = Rhino.GetObject ("select a point for direction", 1)
Dim strRefPts
strRefPts = boundaryPartialSphere (strTrgPt, strALLRefPts, strPtDir, 450, 30)

'color
Dim intR, intG, intB
Dim i
For i = 0 To UBound(strRefPts)
intR =255
intG =25+i*Rnd()*2
intB =0
Call Rhino.ObjectColor (strRefPts(i), RGB(intR, intG, intB))
Next
Call Rhino.print("execution completed")

'----------------------------------------------------------------------------------------------
'----------------------------------------------------------------------------------------------
Function boundaryPartialSphere (strTrgPt, strALLRefPts, strPtDir, dblBoundR, dblBoundAngle)
Dim arrResult

'coordinate extraction
'---------------------------------------
Dim arrTrgPt
arrTrgPt = Rhino.PointCoordinates (strTrgPt)
Dim arrALLRefPts()
Dim i
For i = 0 To UBound(strALLRefPts)
ReDim Preserve arrALLRefPts(i)
arrALLRefPts(i) = Rhino.PointCoordinates (strALLRefPts(i))
Next
Dim arrPtDir
arrPtDir = Rhino.PointCoordinates (strPtDir)

'set boundary
'---------------------------------------
Dim dblDist, dblAngles, arrDir
Dim arrLine1(1), arrLine2(1)
Dim arrREFPts(), strRefPts()
Dim n, m
n = 0
For m = 0 To UBound(arrALLRefPts)
dblDist = Rhino.Distance (arrTrgPt, arrALLRefPts(m))

If dblDist < dblBoundR Then
arrLine1(0) = arrPtDir
arrLine1(1) = arrTrgPt
arrLine2(0) = arrALLRefPts(m)
arrLine2(1) = arrTrgPt
dblAngles = Rhino.Angle2 (arrLine1, arrLine2)
If dblAngles(0) < dblBoundAngle Then
Call Rhino.Print ("through point: " & CStr(n+1))
ReDim Preserve arrRefPts(n)
arrRefPts(n) = arrALLRefPts(m)
ReDim Preserve strRefPts(n)
strRefPts(n) = strALLRefPts(m)
n = n+1
End If
End If

Next
'---------------------------------------
arrResult = strRefPts
boundaryPartialSphere = arrResult
End Function
'----------------------------------------------------------------------------------------------
'----------------------------------------------------------------------------------------------

boundary sphere

2008-10-11T10:40:00.000-07:00

Option Explicit
'Author: YukiukiH
'Date: 10/08/2008
'compatibility: Rhino4
''boundary SPHERE
'----------------------------------------------------------------------------------------------
Dim strTrgPt
strTrgPt = Rhino.GetObject ("select a target point", 1)
Dim strALLRefPts
strALLRefPts = Rhino.GetObjects ("select reference points", 1)
Dim strRefPts
strRefPts = boundarySphere (strTrgPt, strALLRefPts, 250)

'color
Dim intR, intG, intB
Dim i
For i = 0 To UBound(strRefPts)
intR =255
intG =25+i*Rnd()*2
intB =0
Call Rhino.ObjectColor (strRefPts(i), RGB(intR, intG, intB))
Next
Call Rhino.print("execution completed")

'----------------------------------------------------------------------------------------------
'----------------------------------------------------------------------------------------------
Function boundarySphere (strTrgPt, strALLRefPts, dblBoundR)
Dim arrResult

'coordinate extraction
'---------------------------------------
Dim arrTrgPt
arrTrgPt = Rhino.PointCoordinates (strTrgPt)
Dim arrALLRefPts()
Dim i
For i = 0 To UBound(strALLRefPts)
ReDim Preserve arrALLRefPts(i)
arrALLRefPts(i) = Rhino.PointCoordinates (strALLRefPts(i))
Next

'set boundary
'---------------------------------------
Dim dblDist, arrREFPts(), strRefPts()
Dim n, m
n = 0
For m = 0 To UBound(arrALLRefPts)
dblDist = Rhino.Distance (arrTrgPt, arrALLRefPts(m))

If dblDist < dblBoundR Then
Call Rhino.Print ("through point: " & CStr(n+1))
ReDim Preserve arrRefPts(n)
arrRefPts(n) = arrALLRefPts(m)
ReDim Preserve strRefPts(n)
strRefPts(n) = strALLRefPts(m)
n = n+1
End If

Next
'---------------------------------------
arrResult = strRefPts
boundarySphere = arrResult
End Function
'----------------------------------------------------------------------------------------------
'----------------------------------------------------------------------------------------------

boundary cylinder

2008-10-11T10:38:00.000-07:00

Option Explicit
'Author: YukiukiH
'Date: 10/08/2008
'compatibility: Rhino4
''boundary CYLINDER
'----------------------------------------------------------------------------------------------
Dim strTrgPt
strTrgPt = Rhino.GetObject ("select a target point", 1)
Dim strALLRefPts
strALLRefPts = Rhino.GetObjects ("select reference points", 1)
Dim strRefPts
strRefPts = boundaryCylinder (strTrgPt, strALLRefPts, 200, 400)

'color
Dim intR, intG, intB
Dim i
For i = 0 To UBound(strRefPts)
intR =255
intG =25+i*Rnd()*2
intB =0
Call Rhino.ObjectColor (strRefPts(i), RGB(intR, intG, intB))
Next
Call Rhino.print("execution completed")

'----------------------------------------------------------------------------------------------
'----------------------------------------------------------------------------------------------
Function boundaryCylinder (strTrgPt, strALLRefPts, dblBoundR, dblBoundZ)
Dim arrResult

'coordinate extraction
'---------------------------------------
Dim arrTrgPt
arrTrgPt = Rhino.PointCoordinates (strTrgPt)
Dim arrALLRefPts()
Dim i
For i = 0 To UBound(strALLRefPts)
ReDim Preserve arrALLRefPts(i)
arrALLRefPts(i) = Rhino.PointCoordinates (strALLRefPts(i))
Next

'set boundary
'---------------------------------------
Dim arrFlatPt, arrFlatRefPt, dblDist, dblmaxZ, dblminZ
Dim arrREFPts(), strRefPts()
dblmaxZ = arrTrgPt(2) + dblBoundZ
dblminZ = arrTrgPt(2)

Dim n, m
n = 0
For m = 0 To UBound(arrALLRefPts)
arrFlatPt = Array(arrTrgPt(0), arrTrgPt(1), 0)
arrFlatRefPt = Array(arrALLRefPts(m)(0),arrALLRefPts(m)(1), 0)
dblDist = Rhino.Distance (arrFlatPt, arrFlatRefPt)
If dblDist < dblBoundR Then
If dblmaxZ>arrALLRefPts(m)(2) And arrALLRefPts(m)(2)>dblminZ Then

Call Rhino.Print ("through point: " & CStr(n+1))
ReDim Preserve arrRefPts(n)
arrRefPts(n) = arrALLRefPts(m)
ReDim Preserve strRefPts(n)
strRefPts(n) = strALLRefPts(m)
n = n+1

End If
End If
Next
'---------------------------------------
arrResult = strRefPts
boundaryCylinder = arrResult
End Function
'----------------------------------------------------------------------------------------------
'----------------------------------------------------------------------------------------------

bounday cube

2008-10-11T10:35:00.001-07:00

Option Explicit
'Author: YukiukiH
'Date: 10/08/2008
'compatibility: Rhino4
''boundary CUBE
'----------------------------------------------------------------------------------------------
Dim strTrgPt
strTrgPt = Rhino.GetObject ("select a target point", 1)
Dim strALLRefPts
strALLRefPts = Rhino.GetObjects ("select reference points", 1)
Dim strRefPts
strRefPts = boundaryCube (strTrgPt, strALLRefPts, 300, 300, 400)

'color
Dim intR, intG, intB
Dim i
For i = 0 To UBound(strRefPts)
intR =255
intG =25+i*Rnd()*2
intB =0
Call Rhino.ObjectColor (strRefPts(i), RGB(intR, intG, intB))
Next
Call Rhino.print("execution completed")

'----------------------------------------------------------------------------------------------
'----------------------------------------------------------------------------------------------
Function boundaryCube (strTrgPt, strALLRefPts, dblBoundX, dblBoundY, dblBoundZ)
Dim arrResult

'coordinate extraction
'---------------------------------------
Dim arrTrgPt
arrTrgPt = Rhino.PointCoordinates (strTrgPt)
Dim arrALLRefPts()
Dim i
For i = 0 To UBound(strALLRefPts)
ReDim Preserve arrALLRefPts(i)
arrALLRefPts(i) = Rhino.PointCoordinates (strALLRefPts(i))
Next

'set boundary
'---------------------------------------
Dim dblmaxX, dblminX, dblmaxY, dblminY, dblmaxZ, dblminZ
Dim arrREFPts(), strRefPts()
dblmaxX = arrTrgPt(0) +(dblBoundX/2)
dblminX = arrTrgPt(0) -(dblBoundX/2)
dblmaxY = arrTrgPt(1) +(dblBoundY/2)
dblminY = arrTrgPt(1) -(dblBoundY/2)
dblmaxZ = arrTrgPt(2) +(dblBoundZ/2)
dblminZ = arrTrgPt(2) -(dblBoundZ/2)

Dim n, m
n = 0
For m = 0 To UBound(arrALLRefPts)
If dblmaxX>arrALLRefPts(m)(0) And arrALLRefPts(m)(0)>dblminX Then
If dblmaxY>arrALLRefPts(m)(1) And arrALLRefPts(m)(1)>dblminY Then
If dblmaxZ>arrALLRefPts(m)(2) And arrALLRefPts(m)(2)>dblminZ Then

Call Rhino.Print ("through point: " & CStr(n+1))
ReDim Preserve arrRefPts(n)
arrRefPts(n) = arrALLRefPts(m)
ReDim Preserve strRefPts(n)
strRefPts(n) = strALLRefPts(m)
n = n+1

End If
End If
End If
Next
'---------------------------------------
arrResult = strRefPts
boundaryCube = arrResult
End Function
'----------------------------------------------------------------------------------------------
'----------------------------------------------------------------------------------------------

makeTree Revision

2008-09-28T09:51:00.000-07:00

Option Explicit
'Author: YukiukiH
'Date: 08/10/03
'compatibility: Rhino4
''branching using vector

'first things first...
'----------------------------------------------------------------------------------------------
Dim strRtPts
strRtPts = Rhino.GetObjects ("select root points", 1)
Call Rhino.AddLayer ("ptCloudRT", RGB(0,0,0)) 'black
Call Rhino.ObjectLayer (strRtPts, "ptCloudRT")
Dim strALLREFPts
strALLREFPts = Rhino.GetObjects ("select reference points", 1)
Call Rhino.AddLayer ("ptCloudREF", RGB(105,105,105)) 'gray
Call Rhino.ObjectLayer (strALLREFPts, "ptCloudREF")
Dim dblNumber
dblNumber = 7 '4
Dim dblBoundary
dblBoundary = 100 '100
Call Rhino.Print ("minimize rhino window")

'call function
Dim arrResultBranchs
arrResultBranchs = branch (strRtPts, strALLREFPts, dblNumber, dblBoundary)

Dim arrResultTrees, i, j
For j = 0 To UBound(arrResultBranchs)
'call function
ReDim Preserve arrResultTrees(j)
arrResultTrees(j) = tree (20, arrResultBranchs(j))
Dim arrResult01, arrResult02, dblS, dblT

If dblNumber Mod 2 = 1 Then
dblS = dblNumber/2+0.5
dblT = dblNumber-dblS
Else
dblS = dblNumber/2
dblT = dblNumber/2
End If

ReDim arrResult01(dblS-1)
ReDim arrResult02(dblT-1)
Rhino.print("dblS = " & CStr(dblS))
Rhino.print("dblT = " & CStr(dblT))
For i = 0 To (dblS-1)
arrResult01(i) = arrResultTrees(j)(i)
Next
For i = 0 To (dblT-1)
arrResult02(i) = arrResultTrees(j)(i+dblS)
Next

'call function
Call tree (10, arrResult01)
Call tree (10, arrResult02)
Next
Call Rhino.print("execution completed")

'----------------------------------------------------------------------------------------------
'----------------------------------------------------------------------------------------------
Function branch (strRtPts, strALLREFPts, dblNumber, dblBoundary)
refer branch function
End Function
'----------------------------------------------------------------------------------------------
'----------------------------------------------------------------------------------------------

'----------------------------------------------------------------------------------------------
'----------------------------------------------------------------------------------------------
Function tree (dblStemLength, arrBranches)
Dim arrResult()

'length of given branches
'---------------------------------------
Dim i
Dim blnFlag
blnFlag = False

For i=0 To UBound(arrBranches)
Dim dblCurveLength
dblCurveLength = Rhino.CurveLength (arrBranches(i))
Call Rhino.print("length = "& CStr(dblCurveLength))
If dblCurveLength > dblStemLength Then
blnFlag = True
End If
Next

'get average if branches are too long,
'---------------------------------------
If blnFlag Then
Rhino.print("blnFlag = true")
Dim arrEdPt, arrStPt
Dim arrAvgPt(2), dblX, dblY, dblZ
dblX = 0
dblY = 0
dblZ = 0
For i = 0 To UBound(arrBranches)
arrEdPt = Rhino.CurveEndPoint (arrBranches(i))
dblX = dblX + arrEdPt(0)
dblY = dblY + arrEdPt(1)
dblZ = dblZ + arrEdPt(2)
Next

arrAvgPt(0) = dblX /(UBound(arrBranches)+1)
arrAvgPt(1) = dblY /(UBound(arrBranches)+1)
arrAvgPt(2) = dblZ /(UBound(arrBranches)+1)
arrStPt = Rhino.CurveStartPoint (arrBranches(0))
Dim arrDiff
arrDiff = Rhino.VectorSubtract (arrAvgPt, arrStPt)
Dim dblDiff
dblDiff = Rhino.VectorLength (arrDiff)
Dim k
k = dblStemLength / dblDiff
arrDiff = Rhino.VectorScale (arrDiff, k)
Dim arrSeed
arrSeed = Rhino.VectorAdd (arrStPt, arrDiff)

'shorter branches
'---------------------------------------
Dim strNewBranches
ReDim strNewBranches(UBound(arrBranches))
For i = 0 To UBound(arrBranches)
Dim arrLeaf
arrLeaf = Rhino.CurveEndPoint(arrBranches(i))
Dim strLine
strLine = Rhino.AddLine(arrSeed, arrLeaf)
ReDim Preserve arrResult(i)
arrResult(i) = strLine
Next

Dim strStem
strStem = Rhino.AddLine (arrStPt, arrSeed)
Call Rhino.DeleteObjects (arrBranches)
Else
Rhino.print("blnFlag = false")
End If
'---------------------------------------

Call Rhino.CurrentLayer ("0")
tree = arrResult
End Function
'----------------------------------------------------------------------------------------------
'----------------------------------------------------------------------------------------------

makeBranch Revision

2008-09-28T09:31:00.000-07:00

Option Explicit
'Author: YukiukiH
'Date: 08/10/03
'compatibility: Rhino4
''branching using vector

'first things first...
'----------------------------------------------------------------------------------------------
Dim strRtPts
strRtPts = Rhino.GetObjects ("select root points", 1)
Call Rhino.AddLayer ("ptCloudRT", RGB(0,0,0)) 'black
Call Rhino.ObjectLayer (strRtPts, "ptCloudRT")
Dim strALLREFPts
strALLREFPts = Rhino.GetObjects ("select reference points", 1)
Call Rhino.AddLayer ("ptCloudREF", RGB(105,105,105)) 'gray
Call Rhino.ObjectLayer (strALLREFPts, "ptCloudREF")
Dim dblNumber
dblNumber = 8 '4
Dim dblBoundary
dblBoundary = 100 '100
Call Rhino.Print ("minimize rhino window")

Call branch (strRtPts, strALLREFPts, dblNumber, dblBoundary)
Call Rhino.print("execution completed")

'----------------------------------------------------------------------------------------------
'----------------------------------------------------------------------------------------------
Function branch (strRtPts, strALLREFPts, dblNumber, dblBoundary)
Dim arrResult()

'coordinate extraction
'----------------------------------------------------------------------------------------------
Dim i, arrRtPts(), arrALLREFPts()
For i = 0 To UBound(strRtPts)
ReDim Preserve arrRtPts(i)
arrRtPts(i) = Rhino.PointCoordinates (strRtPts(i))
Next
For i = 0 To UBound(strALLREFPts)
ReDim Preserve arrALLREFPts(i)
arrALLREFPts(i) = Rhino.PointCoordinates (strALLREFPts(i))
Next

'for each RootPoint,
'----------------------------------------------------------------------------------------------
Dim dblmaxX, dblminX, dblmaxY, dblminY
Dim arrREFPts(), arrMinLength(), dblMinLength
Dim strShortests()
Dim j
For j = 0 To UBound(arrRtPts)
Call Rhino.Print ("Round " & CStr(j+1))

'set boundary
'---------------------------------------
dblmaxX = arrRtPts(j)(0) +dblBoundary
dblminX = arrRtPts(j)(0) -dblBoundary
dblmaxY = arrRtPts(j)(1) +dblBoundary
dblminY = arrRtPts(j)(1) -dblBoundary
Dim n, m
n = 0
For m = 0 To UBound(arrALLREFPts)
If dblmaxX>arrALLREFPts(m)(0) And arrALLREFPts(m)(0)>dblminX And dblmaxY>arrALLREFPts(m)(1) And arrALLREFPts(m)(1)>dblminY Then
ReDim Preserve arrREFPts(n)
arrREFPts(n) = arrALLREFPts(m)
n = n+1
End If
Next
'---------------------------------------

'find dblNumber shortest
'---------------------------------------
Dim arrVectorTemp, dblLengthTemp
Dim arrVector01, dblLength01
Dim arrPrevShortest, dblPrevShortest
Dim arrCurrShortest, dblCurrShortest
dblMinLength = 0

For i = 0 To dblNumber-1
'make one to begin comparison with
arrVectorTemp = Rhino.VectorCreate (arrREFPts(0), arrRtPts(j))
dblLengthTemp = Rhino.VectorLength (arrVectorTemp)
arrPrevShortest = arrVectorTemp
dblPrevShortest = dblLengthTemp

If dblPrevShortest <= dblMinLength Then
dblPrevShortest = dblPrevShortest * 100
End If

For n = 0 To UBound(arrREFPts)
arrVector01 = Rhino.VectorCreate (arrREFPts(n), arrRtPts(j))
dblLength01 = Rhino.VectorLength (arrVector01)

If dblLength01 <= dblPrevShortest And dblLength01 > dblMinLength Then
arrCurrShortest = arrVector01
dblCurrShortest = dblLength01
Else
arrCurrShortest = arrPrevShortest
dblCurrShortest = dblPrevShortest
End If

'prepare for next round
arrPrevShortest = arrCurrShortest
dblPrevShortest = dblCurrShortest

Next 'arrREFPts
ReDim Preserve arrMinLength(i)
arrMinLength(i) = arrCurrShortest
dblMinLength = dblCurrShortest
Call Rhino.Print (CStr(i+1) & " shortest:" & " " & CStr(dblMinLength))

Call Rhino.AddLayer (CStr(i+1) & " shortest", RGB(255-i*20, 50+i*24, 0))
Call Rhino.CurrentLayer (CStr(i+1) & " shortest")

ReDim Preserve strShortests(i)
strShortests(i) = Rhino.Addline (arrRtPts(j), Rhino.VectorAdd (arrRtPts(j), arrMinLength(i)))

Next 'i
ReDim Preserve arrResult(j)
arrResult(j) = strShortests
'---------------------------------------
Next 'j

Call Rhino.CurrentLayer ("0")
branch = arrResult
End Function
'----------------------------------------------------------------------------------------------
'----------------------------------------------------------------------------------------------

makeBridge Revision

2008-09-28T08:16:00.000-07:00

Option Explicit
'Author: YukiukiH
'Date: 08/10/03
'compatibility: Rhino4
''draw normal at each division point using vector
''then create bridge structure

'first things first...
'----------------------------------------------------------------------------------------------
Call Rhino.AddLayer ("splineCenter", RGB(255,0,0)) 'black
Call Rhino.AddLayer ("centerPt", RGB(0,0,0)) 'black
Call Rhino.AddLayer ("normalAxis", RGB(0,0,0)) 'black
Call Rhino.AddLayer ("normal01", RGB(255,161,0)) 'gold
Call Rhino.AddLayer ("normal02", RGB(255,127,0)) 'orange
Call Rhino.AddLayer ("side01", RGB(0,0,0)) 'black
Call Rhino.AddLayer ("side02", RGB(0,0,0)) 'black
Call Rhino.AddLayer ("Pt", RGB(0,0,0)) 'black
Call Rhino.AddLayer ("Line011", RGB(63,191,191)) 'turquoise
Call Rhino.AddLayer ("Line022", RGB(63,191,191)) 'turquoise
Call Rhino.AddLayer ("Line033", RGB(0,0,0)) 'black
Call Rhino.AddLayer ("Line044", RGB(0,0,0)) 'black
Call Rhino.AddLayer ("Line055", RGB(255,0,0)) 'red

Dim strSpline
strSpline = Rhino.GetObject ("select a spline curve", 4)
Call Rhino.ObjectLayer (strSpline , "splineCenter")
Call Rhino.LayerVisible ("splineCenter", False)
Dim dblsegLength
dblsegLength = 1500 '1500
Dim dblWidth
dblWidth = 2000 '2000
Dim dblSideAngle
dblSideAngle = 100 '100
Dim dblSideHeight
dblSideHeight = 900 '900
Dim dblDiagLength
dblDiagLength = dblSideHeight*Sec(dblSideAngle-90)
Call Rhino.Print (dblDiagLength) '913.884

Function Sec(x)
Dim dblPi
dblPi = Rhino.Pi
Sec = 1 / Cos(x*2*dblPi/360)
End Function

Call ribaBridge (strSpline, dblSegLength, dblWidth, dblSideAngle, dblDiagLength)
Call Rhino.print("execution completed")

'----------------------------------------------------------------------------------------------
'----------------------------------------------------------------------------------------------
Function ribaBridge (strSpline, dblSegLength, dblWidth, dblSideAngle, dblDiagLength)

'division points
'---------------------------------------
Dim arrCenPts, strCenPt
Dim a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z

If Rhino.IsCurve(strSpline) Then
'by length segment
arrCenPts = Rhino.DivideCurveLength(strSpline, dblSegLength)
'by segments
'intSegments = 130
'arrPoints = Rhino.DivideCurve(strSpline, intSegments)
Call Rhino.CurrentLayer ("centerPt")
For i = 0 To UBound(arrCenPts)
strCenPt = Rhino.AddPoint (arrCenPts(i))
Next
End If

'normal
'---------------------------------------
Dim dblParam, arrTangents(), arrNormals()
Dim strNormalSides01(), strNormalSides02()

For i = 0 To UBound(arrCenPts)
dblParam = Rhino.CurveClosestPoint(strSpline, arrCenPts(i))
ReDim Preserve arrTangents(i)
arrTangents(i) = Rhino.CurveTangent(strSpline, dblParam)
ReDim Preserve arrNormals(i)
arrNormals(i) = Rhino.VectorCrossProduct(arrTangents(i), Array(0,0,1))
ReDim Preserve arrNormals(i)
arrNormals(i) = Rhino.VectorUnitize(arrNormals(i))
ReDim Preserve arrNormals(i)
arrNormals(i) = Rhino.VectorScale(arrNormals(i), dblWidth)

Call Rhino.CurrentLayer ("normal01")
ReDim Preserve strNormalSides01(i)
strNormalSides01(i) = Rhino.addLine(arrCenPts(i), Rhino.VectorAdd(arrCenPts(i), arrNormals(i)))
ReDim Preserve strNormalSides02(i)
strNormalSides02(i) = Rhino.RotateObject (strNormalSides01(i), arrCenPts(i), 180, Array(0,0,1), True)
Call Rhino.ObjectLayer (strNormalSides02(i), "normal02")
Next

'prepare vector for 3d rotation
'---------------------------------------
Dim arrAxiss(), arrSides(), dilDiagLength(), strSides01, strSides02
Dim arrSides01EdPts(), arrSides02EdPts()
Dim arrSides01TpPts(), arrSides02TpPts()

For i = 0 To UBound(arrCenPts)
ReDim Preserve arrSides01EdPts(i)
arrSides01EdPts(i) = Rhino.CurveEndPoint (strNormalSides01(i))
ReDim Preserve arrSides02EdPts(i)
arrSides02EdPts(i) = Rhino.CurveEndPoint (strNormalSides02(i))

ReDim Preserve arrAxis(i)
arrAxis(i) = Rhino.VectorRotate (arrNormals(i), -90, Array(0,0,1))
ReDim Preserve arrSides(i)
arrSides(i) = Rhino.VectorRotate (arrNormals(i), 180-dblSideAngle, arrAxis(i))
ReDim Preserve arrSides(i)
arrSides(i) = Rhino.VectorUnitize (arrSides(i))
ReDim Preserve arrSides(i)
arrSides(i) = Rhino.VectorScale (arrSides(i), dblDiagLength)

Call Rhino.CurrentLayer ("side01")
strSides01 = Rhino.addLine (arrSides01EdPts(i), Rhino.VectorAdd(arrSides01EdPts(i), arrSides(i)))
ReDim Preserve arrSides(i)
arrSides(i) = Rhino.VectorRotate (arrSides(i), (dblSideAngle-90)*2, arrAxis(i))
Call Rhino.CurrentLayer ("side02")
strSides02 = Rhino.addLine (arrSides02EdPts(i), Rhino.VectorAdd(arrSides02EdPts(i), arrSides(i)))

'add points
ReDim Preserve arrSides01TpPts(i)
arrSides01TpPts(i) = Rhino.CurveEndPoint (strSides01)
ReDim Preserve arrSides02TpPts(i)
arrSides02TpPts(i) = Rhino.CurveEndPoint (strSides02)

Call Rhino.CurrentLayer ("Pt")
Call Rhino.AddPoint (arrSides01EdPts(i))
Call Rhino.AddPoint (arrSides02EdPts(i))
Call Rhino.AddPoint (arrSides01TpPts(i))
Call Rhino.AddPoint (arrSides02TpPts(i))
Next

'create lines between (i) and (i+1)
'---------------------------------------
Dim strLine011, strLine022, strLine033, strLine044, strLine055

For i = 0 To UBound(arrCenPts)-1
Call Rhino.CurrentLayer ("Line011")
strLine011 = Rhino.AddLine (arrSides01EdPts(i), arrSides01EdPts(i+1))
Call Rhino.CurrentLayer ("Line022")
strLine022 = Rhino.AddLine (arrSides02EdPts(i), arrSides02EdPts(i+1))
Call Rhino.CurrentLayer ("Line033")
strLine033 = Rhino.AddLine (arrSides01TpPts(i), arrSides01TpPts(i+1))
Call Rhino.CurrentLayer ("Line044")
strLine044 = Rhino.AddLine (arrSides02TpPts(i), arrSides02TpPts(i+1))
Call Rhino.CurrentLayer ("Line055")
strLine055 = Rhino.AddLine (arrCenPts(i), arrCenPts(i+1))
Next

End Function
'----------------------------------------------------------------------------------------------
'----------------------------------------------------------------------------------------------

Beginners Samples

2008-08-31T01:14:00.000-07:00

Some useful CATIA vba samples, since v5Automation was overwhelming for newbies like me.

'opening statement /intersectionPt
'---------------------------------------
Dim partDocument1 As PartDocument
Set partDocument1 = CATIA.ActiveDocument
Dim part1 As Part
Set part1 = partDocument1.Part
'add geom set here
Dim hybridBody1 As HybridBody
Set hybridBody1 = part1.HybridBodies.Add()
hybridBody1.Name = "Geometrical Set.New"
part1.Update
'used geom set
Dim hybridBody2 As HybridBody
Set hybridBody2 = part1.HybridBodies.Item("Geometrical Set.1")
Dim hybridBody3 As HybridBody
Set hybridBody3 = part1.HybridBodies.Item("Geometrical Set.2").HybridBodies.Item("Multi Output.1 (Intersect)")
'---------------------------------------

'selection set /color
'---------------------------------------
Dim colorCount
colorCount = hybridBody1.HybridShapes.Count
For i = 1 To colorCount
Call partDocument1.Selection.Add(hybridBody1.HybridShapes.Item(i))
Dim visProperties1 As VisPropertySet
Set visProperties1 = partDocument1.Selection.VisProperties
visProperties1.SetRealColor 255, 255, 0, 1 'yellow(255,255,0)
partDocument1.Selection.Clear
Next i
'---------------------------------------

'measurable, parameter, formula
'---------------------------------------
'create line WITHOUT parameter first
Dim line1 As HybridShapeLineAngle
Set line1 = part1.HybridShapeFactory.AddNewLineAngle( , , , , , , , )
Dim angleFormula01 As Formula
Set angleFormula01 = part1.relations.CreateFormula( , , line1.Angle, )
hybridBody1.AppendHybridShape line1
part1.InWorkObject = line1

Dim TheMeasurable01 As Measurable
Set TheMeasurable01 = CATIA.ActiveDocument.GetWorkbench("SPAWorkbench").GetMeasurable( )
Dim lineMeasurable01 As Double
lineMeasurable01 = TheMeasurable01.Length
Dim MeasurableRealStOff01 As RealParam
Set MeasurableRealStOff01 = part1.Parameters.CreateReal("Real.measurable stOff", lineMeasurable01)
Dim MeasurableRealEdOff01 As RealParam
Set MeasurableRealEdOff01 = part1.Parameters.CreateReal("Real.measurable edOff", lineMeasurable01)

Dim lengthFormula011 As Formula
Set lengthFormula011 = part1.relations.CreateFormula( , , line1.BeginOffset, )
Dim lengthFormula012 As Formula
Set lengthFormula012 = part1.relations.CreateFormula( , , line1.EndOffset, )
'---------------------------------------

CATIA scripting

2008-08-16T16:07:00.001-07:00

Finally got hands on CATIA scripting. Most confusing thing about CATIA vba is the tree structure. Within Part Document only, CATIA has the following structure.

+-- PartDocument
+---- Part
+------ HybridShapeFactory
+-------- HybridBodies
+---------- HybridBody
+------------ HybridShapes
+-------------- HybridShape

And also, since CATIA has multiple ways to create a geometry,
"Dim ...... As ......" lines get a little tricky. Point Geometry for example, has 9 types including intersection point.

HybridShapePointBetween
HybridShapePointCenter
HybridShapePointCoord
HybridShapePointExplicit
HybridShapePointOnCurve
HybridShapePointOnPlane
HybridShapePointOnSurface
HybridShapePointTangent
HybridShapeInterSection

'Module h_planeM (THIS IS ONE MODULE ONLY !!!)

Option Explicit
'Author: YukiukiH
'Date: 10/18/2008
'compatibility: CATIA V5R18
'----------------------------------------------------------------------------------------------
Sub CATMain()
'opening statement
Dim partDocument1 As PartDocument
Set partDocument1 = CATIA.ActiveDocument
Dim part1 As Part
Set part1 = partDocument1.Part
'add geom set here
Dim hybridBody1 As HybridBody
Set hybridBody1 = part1.HybridBodies.Add()
hybridBody1.Name = "D_planeM"
part1.Update
'useg geom set
Dim hybridBody2 As HybridBody
Set hybridBody2 = part1.HybridBodies.Item("D_MidL")
Dim hybridBody3 As HybridBody
Set hybridBody3 = part1.HybridBodies.Item("D_normalM")

Dim i As Integer
Dim j As Integer
j = 0
Dim k As Integer

'Loop
'----------------------------------------------------------------------------------------------
'----------------------------------------------------------------------------------------------
Dim lineCount As Integer
lineCount = hybridBody2.HybridShapes.Count

For i = 1 To lineCount Step 9

'input
Dim line01 As HybridShapeLinePtPt
Set line01 = hybridBody2.HybridShapes.Item(i)
Dim lineNormal01 As HybridShapeLineNormal
Set lineNormal01 = hybridBody3.HybridShapes.Item(i + j)
'output
Dim plane01 As HybridShapePlane2Lines
Set plane01 = part1.HybridShapeFactory.AddNewPlane2Lines(line01, lineNormal01)
hybridBody1.AppendHybridShape plane01
part1.InWorkObject = plane01

'---------------------------------------
For k = 1 To 8
'input
Set line01 = hybridBody2.HybridShapes.Item(i + k)
Set lineNormal01 = hybridBody3.HybridShapes.Item(i + j + k)
'output
Set plane01 = part1.HybridShapeFactory.AddNewPlane2Lines(line01, lineNormal01)
hybridBody1.AppendHybridShape plane01
part1.InWorkObject = plane01
Next k
'---------------------------------------

j = j + 1
Next i
'----------------------------------------------------------------------------------------------
'----------------------------------------------------------------------------------------------
part1.Update 'has to be before SetRealColor

'color
'---------------------------------------
Dim colorCount
colorCount = hybridBody1.HybridShapes.Count
For i = 1 To colorCount
Call partDocument1.Selection.Add(hybridBody1.HybridShapes.Item(i))
Dim visProperties1 As VisPropertySet
Set visProperties1 = partDocument1.Selection.VisProperties
visProperties1.SetRealColor 0, 0, 0, 1 'blk(0, 0, 0)
partDocument1.Selection.Clear
Next i
'---------------------------------------
End Sub

Hanabi

2008-07-13T11:53:00.001-07:00

With a few arrangements, trees become Hanabi! (fireworks in Japanese) They are all generated from the same script, only by changing input numbers. The pointcloud on the left corner is geometrical inputs.

Evolution

2008-07-12T16:37:00.000-07:00

Playing around with the find closest script I posted previously, I have been growing bunch of trees. If I look only the final result, it looks sort of intimidating. But I start with the simple code like find closest, and kept adding more functions and intelligence. I also work this way when I have to figure out complicated powercopy.

If you look close, tangency of branches appear more smoothly in type02. This regards the order that code generates branches. It makes sense that more points the code takes into consideration in the beginning (like in type02), the more naturally tangency can grow.

I have to learn how to call function for some part of the script, otherwise, scripts I write are getting too long to post... If somebody is interested, please let me know.

Branching

2008-07-04T07:31:00.000-07:00

** Updated Branching Script

Very simple operation to find closest point out of point cloud. I have some more work to do on this script, so I wanted to post it up before I make it too complicated.

Each Loop finds first closest, second closest, third closest, so on and so forth. I thought it would be cool to set a variable that defines how many closest point each target has to find, but I couldn't figure out. Let's just start with recycling the same Loop over and over again.

It looks like I can make this script much shorter if
Call Rhino.PointArrayClosestPoint (arrPoints( ), arrPoint)
works... This sample appears in monkey, yet somehow Rhino Script Method is not available.

'----------------------------------------------------------------------------------------------
'----------------------------------------------------------------------------------------------
Option Explicit
'Author: YukiukiH
'Date: 06/04/2008
'compatibility: Rhino4
'memo: boundary is variable in plan

Branching()
Sub Branching()
Dim a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z

Dim arrstrStPt, arrStPt()
Dim arrstrEdPt(), arrEdPt()
Dim arrstrALLEdPt, arrALLEdPt()

'user selection
arrstrStPt = Rhino.GetObjects ("select root points", 1)
arrstrALLEdPt = Rhino.GetObjects ("select reference points", 1)
Rhino.Print "MINIMIZE RHINO WHINDOW TO SAVE TIME !!!"

For i = 0 To UBound(arrstrStPt)
ReDim Preserve arrStPt(i)
arrStPt(i) = Rhino.PointCoordinates (arrstrStPt(i))
Next

For i = 0 To UBound(arrstrALLEdPt)
ReDim Preserve arrALLEdPt(i)
arrALLEdPt(i) = Rhino.PointCoordinates (arrstrALLEdPt(i))
Next

'set boundary
'----------------------------------------------------------------------------------------------
Dim dblmaxX, dblminX, dblmaxY, dblminY

'Ultimate Loop
b = 100
For j = 0 To UBound(arrStPt)

dblmaxX = arrStPt(j)(0) +b
dblminX = arrStPt(j)(0) -b
dblmaxY = arrStPt(j)(1) +b
dblminY = arrStPt(j)(1) -b

n = 0
For m = 0 To UBound(arrstrALLEdPt)
If dblmaxX > arrALLEdPt(m)(0) And arrALLEdPt(m)(0) > dblminX And dblmaxY > arrALLEdPt(m)(1) And arrALLEdPt(m)(1) > dblminY Then
ReDim Preserve arrstrEdPt(n)
arrstrEdPt(n) = Rhino.CopyObject (arrstrALLEdPt(m))
ReDim Preserve arrEdPt(n)
arrEdPt(n) = Rhino.PointCoordinates (arrstrEdPt(n))
n = n+1
End If

Next
Call Rhino.DeleteObjects (arrstrEdPt)
'----------------------------------------------------------------------------------------------

'comparison
Dim strLine01, dblDist01
Dim strLine02, dblDist02
Dim strPrevShortest, dblPrevShortest
Dim strCurrShortest, dblCurrShortest

'find shortest
'----------------------------------------------------------------------------------------------
i = 0 'make one to begin comparison with
strLine01 = Rhino.AddLine (arrStPt(j), arrEdPt(i))
dblDist01 = Rhino.CurveLength (strLine01)
strPrevShortest = strLine01
dblPrevShortest = dblDist01

For i = 0 To UBound(arrEdPt)
strLine02 = Rhino.AddLine (arrStPt(j), arrEdPt(i))
dblDist02 = Rhino.CurveLength (strLine02)

If dblDist02 <= dblPrevShortest Then
strCurrShortest = strLine02
dblCurrShortest = dblDist02
Rhino.DeleteObject strPrevShortest
Else
strCurrShortest = strPrevShortest
dblCurrShortest = dblPrevShortest
Rhino.DeleteObject strLine02
End If

'prepare for next round
strPrevShortest = strCurrShortest
dblPrevShortest = dblCurrShortest
'Rhino.Sleep 10
Next
'----------------------------------------------------------------------------------------------

'find second
'----------------------------------------------------------------------------------------------
Rhino.AddLayer "1st shortest", RGB(0,255,255) 'cyan
Rhino.ObjectLayer strCurrShortest, "1st shortest"
Dim dbl1stShortest, str1stShortest
dbl1stShortest = Rhino.CurveLength (strPrevShortest)
str1stShortest = strPrevShortest

i = 0 'make one to begin comparison with
strLine01 = Rhino.AddLine (arrStPt(j), arrEdPt(i))
dblDist01 = Rhino.CurveLength (strLine01)

If dblDist01 <= dbl1stShortest Then
dblDist01 = dblDist01 * 10
End If

strPrevShortest = strLine01
dblPrevShortest = dblDist01

For i = 0 To UBound(arrEdPt)
strLine02 = Rhino.AddLine (arrStPt(j), arrEdPt(i))
dblDist02 = Rhino.CurveLength (strLine02)

If dblDist02 <= dblPrevShortest And dblDist02 > dbl1stShortest Then
strCurrShortest = strLine02
dblCurrShortest = dblDist02
Rhino.DeleteObject strPrevShortest
Else
strCurrShortest = strPrevShortest
dblCurrShortest = dblPrevShortest
Rhino.DeleteObject strLine02
End If

'prepare for next round
strPrevShortest = strCurrShortest
dblPrevShortest = dblCurrShortest
'Rhino.Sleep 10
Next
'----------------------------------------------------------------------------------------------

'find third
'----------------------------------------------------------------------------------------------
Rhino.AddLayer "2nd shortest", RGB(0,0,191) 'dark blue
Rhino.ObjectLayer strCurrShortest, "2nd shortest"
Dim dbl2ndShortest, str2ndShortest
dbl2ndShortest = Rhino.CurveLength (strPrevShortest)
str2ndShortest = strPrevShortest

i = 0 'make one to begin comparison with
strLine01 = Rhino.AddLine (arrStPt(j), arrEdPt(i))
dblDist01 = Rhino.CurveLength (strLine01)

If dblDist01 <= dbl2ndShortest Then
dblDist01 = dblDist01 * 10
End If
strPrevShortest = strLine01
dblPrevShortest = dblDist01

For i = 0 To UBound(arrEdPt)
strLine02 = Rhino.AddLine (arrStPt(j), arrEdPt(i))
dblDist02 = Rhino.CurveLength (strLine02)

If dblDist02 <= dblPrevShortest And dblDist02 > dbl2ndShortest Then
strCurrShortest = strLine02
dblCurrShortest = dblDist02
Rhino.DeleteObject strPrevShortest
Else
strCurrShortest = strPrevShortest
dblCurrShortest = dblPrevShortest
Rhino.DeleteObject strLine02
End If

'prepare for next round
strPrevShortest = strCurrShortest
dblPrevShortest = dblCurrShortest
'Rhino.Sleep 10
Next
'----------------------------------------------------------------------------------------------

'find fourth
'----------------------------------------------------------------------------------------------
Rhino.AddLayer "3rd shortest", RGB(127,255,191) 'Aquamarine
Rhino.ObjectLayer strCurrShortest, "3rd shortest"
Dim dbl3rdShortest, str3rdShortest
dbl3rdShortest = Rhino.CurveLength (strPrevShortest)
str3rdShortest = strPrevShortest

i = 0 'make one to begin comparison with
strLine01 = Rhino.AddLine (arrStPt(j), arrEdPt(i))
dblDist01 = Rhino.CurveLength (strLine01)

If dblDist01 <= dbl3rdShortest Then
dblDist01 = dblDist01 * 10
End If
strPrevShortest = strLine01
dblPrevShortest = dblDist01

For i = 0 To UBound(arrEdPt)
strLine02 = Rhino.AddLine (arrStPt(j), arrEdPt(i))
dblDist02 = Rhino.CurveLength (strLine02)

If dblDist02 <= dblPrevShortest And dblDist02 > dbl3rdShortest Then
strCurrShortest = strLine02
dblCurrShortest = dblDist02
Rhino.DeleteObject strPrevShortest
Else
strCurrShortest = strPrevShortest
dblCurrShortest = dblPrevShortest
Rhino.DeleteObject strLine02
End If

'prepare for next round
strPrevShortest = strCurrShortest
dblPrevShortest = dblCurrShortest
'Rhino.Sleep 10
Next
'----------------------------------------------------------------------------------------------

'paste above here
'----------------------------------------------------------------------------------------------
Rhino.AddLayer "final shortest", RGB(255,255,255) 'white
Rhino.ObjectLayer strCurrShortest, "final shortest"
Dim dblFinalShortest, strFinalShortest
dblFinalShortest = Rhino.CurveLength (strPrevShortest)
strFinalShortest = strPrevShortest

Next
'----------------------------------------------------------------------------------------------

Call Rhino.Print ("script complete")
End Sub

Finite Element Analysis

2008-06-28T12:31:00.001-07:00

Creating geometry for Finite Element Analysis (FEA). FEA is a computer simulation technique used in engineering analysis (straight from Wiki...) It requires all the line geometries to be meeting at points. If you are Osnap-ing manually, there is high chance that you miss a couple. So, here it is. Out of spline and two offset splines, this script creates basic structure for a bridge.

User has to provide with manually-built normals at each division point. Length doesn't matter. It is to show direction only, and will be deleted by the end of the script.

Challenge:
_Confusion between stringPt and arrPt
_Playing with Layer method
_In Loop, lines require to refer a point from previous round

'----------------------------------------------------------------------------------------------
'----------------------------------------------------------------------------------------------
Option Explicit
'Author: YukiukiH
'Date: 06/28/2008
'compatibility: Rhino4
'memo: watch arrPt and strPt

'before run...
'1. given spline.
'2. divide spline.
'3. draw normal at each points. (use perpendicular to curve/ from first point)

bridgeSt
Sub bridgeSt

'first things first...
Rhino.AddLayer "splineCenter", RGB(255,0,0) 'black
Rhino.AddLayer "centerPt", RGB(0,0,0) 'black
Rhino.AddLayer "normalAxis", RGB(0,0,0) 'black
Rhino.AddLayer "normal01", RGB(255,161,0) 'gold
Rhino.AddLayer "normal02", RGB(255,127,0) 'orange
Rhino.AddLayer "side01", RGB(0,0,0) 'black
Rhino.AddLayer "side02", RGB(0,0,0) 'black
Rhino.AddLayer "Pt", RGB(0,0,0) 'black

Rhino.AddLayer "Line011", RGB(63,191,191) 'turquoise
Rhino.AddLayer "Line022", RGB(63,191,191) 'turquoise
Rhino.AddLayer "Line033", RGB(0,0,0) 'black
Rhino.AddLayer "Line044", RGB(0,0,0) 'black
Rhino.AddLayer "Line055", RGB(255,0,0) 'red

'organizing object layers
Dim strSpline, arrstrCenPt, arrstrNormalAxis
Dim arrPt, arrPts, strCenPt, dblLength

strSpline = Rhino.GetObject ("select a spline curve", 4)
Rhino.ObjectLayer strSpline , "splineCenter"
Rhino.LayerVisible "splineCenter", False

arrstrCenPt = Rhino.GetObjects ("select center points", 1)
Rhino.ObjectLayer arrstrCenPt , "centerPt"
Rhino.CurrentLayer ("CenterPt")
Rhino.DeleteObjects arrstrCenPt

'by length segment
dblLength = 1500
arrPts = Rhino.DivideCurveLength(strSpline, dblLength)

'by segments
'intSegments = 130
'arrPoints = Rhino.DivideCurve(strSpline, intSegments)

For Each arrPt In arrPts
strCenPt = Rhino.AddPoint (arrPt)
Next

arrstrNormalAxis = Rhino.GetObjects ("select normal lines IN ORDER", 4)
Rhino.ObjectLayer arrstrNormalAxis , "normalAxis"

'at each point...

Dim i, arrNormalAxisStPt, arrNormalAxisEdPt
Dim strLine01, strLine02, arrSt(2), arrEd(2), arrReference(1), arrTarget(1)

arrSt(0) = 0
arrSt(1) = 0
arrSt(2) = 0
arrEd(0) = 2000 'bridge width
arrEd(1) = 0
arrEd(2) = 0

For i = 0 To UBound (arrstrNormalAxis)

'create vector out of string normal, and orient lines
arrNormalAxisStPt = Rhino.CurveStartPoint (arrstrNormalAxis(i))
arrNormalAxisEdPt = Rhino.CurveEndPoint (arrstrNormalAxis(i))
Rhino.LayerVisible "normalAxis", False

arrReference(0) = arrSt
arrReference(1) = arrEd
arrTarget(0) = arrNormalAxisStPt
arrTarget(1) = arrNormalAxisEdPt

Rhino.CurrentLayer ("normal01")
strLine01 = Rhino.AddLine (arrSt, arrEd)
Rhino.OrientObject strLine01, arrReference, arrTarget

Rhino.CurrentLayer ("normal02")
strLine02 = Rhino.AddLine (arrSt, arrEd)
Rhino.OrientObject strLine02, arrReference, arrTarget
Rhino.RotateObject strLine02, arrNormalAxisStPt, 180

'prepare vector for 3d rotation
Dim arrLine01EdPt, arrLine02EdPt
Dim strLine01axis, strLine02axis
Dim arrLine01StPt, arrLine02StPt, arrAxis01, arrAxis02
Dim strLine01vrt, strLine02vrt

arrLine01EdPt = Rhino.CurveEndPoint (strLine01)
arrLine02EdPt = Rhino.CurveEndPoint (strLine02)

strLine01axis = Rhino.RotateObject (strLine01, arrLine01EdPt, 90,, True)
strLine02axis = Rhino.RotateObject (strLine02, arrLine02EdPt, 90,, True)

arrLine01StPt = Rhino.CurveStartPoint (strLine01axis)
arrLine02StPt = Rhino.CurveStartPoint (strLine02axis)

arrAxis01= Rhino.VectorCreate (arrLine01EdPt, arrLine01StPt)
arrAxis02= Rhino.VectorCreate (arrLine02EdPt, arrLine02StPt)

strLine01vrt = Rhino.CopyObject(strLine01)
Rhino.ObjectLayer strLine01vrt, "side01"
Rhino.RotateObject strLine01vrt, arrLine01EdPt, 100, arrAxis01

strLine02vrt = Rhino.CopyObject(strLine02)
Rhino.ObjectLayer strLine02vrt, "side02"
Rhino.RotateObject strLine02vrt, arrLine02EdPt, 100, arrAxis02

Rhino.DeleteObject (strLine01axis)
Rhino.DeleteObject (strLine02axis)

'add string points
Dim arrStPtLine01vrt, arrStPtLine02vrt, arrEdPtLine01vrt, arrEdPtLine02vrt
Dim strStPtLine01vrt, strStPtLine02vrt, strEdPtLine01vrt, strEdPtLine02vrt

Rhino.CurrentLayer ("Pt")

arrStPtLine01vrt = Rhino.CurveStartPoint (strLine01vrt)
arrStPtLine02vrt = Rhino.CurveStartPoint (strLine02vrt)
strStPtLine01vrt = Rhino.AddPoint (arrStPtLine01vrt)
strStPtLine02vrt = Rhino.AddPoint (arrStPtLine02vrt)

arrEdPtLine01vrt = Rhino.CurveEndPoint (strLine01vrt)
arrEdPtLine02vrt = Rhino.CurveEndPoint (strLine02vrt)
strEdPtLine01vrt = Rhino.AddPoint (arrEdPtLine01vrt)
strEdPtLine02vrt = Rhino.AddPoint (arrEdPtLine02vrt)

'create lines between current(B) and previous(A)
Dim strLine011, arrLine011PtA, arrLine011PtB, arrpt011PtAtemp
Dim strLine022, arrLine022PtA, arrLine022PtB, arrpt022PtAtemp
Dim strLine033, arrLine033PtA, arrLine033PtB, arrpt033PtAtemp
Dim strLine044, arrLine044PtA, arrLine044PtB, arrpt044PtAtemp
Dim strLine055, arrLine055PtA, arrLine055PtB, arrpt055PtAtemp
Dim strEdPtVrt03, strEdPtVrt04

'prepare current(B) and previous(A)points
If i = 0 Then

'BTM line (Line011, 022)
arrLine011PtA = arrLine01EdPt
arrLine022PtA = arrLine02EdPt

'TP line (Line 033, 044)
arrLine033PtA = Rhino.CurveStartPoint (strLine01vrt)
arrLine044PtA = Rhino.CurveStartPoint (strLine02vrt)

'MD line (Line 055)
arrLine055PtA = arrPts(i)

Else

'BTM line (Line011, 022)
arrpt011PtAtemp = arrLine01EdPt
arrpt022PtAtemp = arrLine02EdPt
arrLine011PtB = arrpt011PtAtemp
arrLine022PtB = arrpt022PtAtemp

'TP line (Line 033, 044)
arrpt033PtAtemp = Rhino.CurveStartPoint (strLine01vrt)
arrpt044PtAtemp = Rhino.CurveStartPoint (strLine02vrt)
arrLine033PtB = arrpt033PtAtemp
arrLine044PtB = arrpt044PtAtemp

'MD line (Line 055)
arrpt055PtAtemp = arrPts(i)
arrLine055PtB = arrpt055PtAtemp

'add line (Line 011, 022, 033, 044, 055)
Rhino.CurrentLayer ("Line011")
strLine011 = Rhino.AddLine (arrLine011PtA, arrLine011PtB)

Rhino.CurrentLayer ("Line022")
strLine022 = Rhino.AddLine (arrLine022PtA, arrLine022PtB)

Rhino.CurrentLayer ("Line033")
strLine033 = Rhino.AddLine (arrLine033PtA, arrLine033PtB)

Rhino.CurrentLayer ("Line044")
strLine044 = Rhino.AddLine (arrLine044PtA, arrLine044PtB)

Rhino.CurrentLayer ("Line055")
strLine055 = Rhino.AddLine (arrLine055PtA, arrLine055PtB)

' prepare for next round
'BTM line (Line011, 022)
arrLine011PtA = arrLine011PtB
arrLine022PtA = arrLine022PtB

'TP line (Line033, 044)
arrLine033PtA = arrLine033PtB
arrLine044PtA = arrLine044PtB

'MD line (Line055)
arrLine055PtA = arrLine055PtB

End If

Next
End Sub

Normal to Curve

2008-06-21T11:52:00.000-07:00

Having hard time with drawing normal (of the main spline) at each division point I ended up intersecting circle and offset splines. So when I first offset the main spline, I had to set offset tolerance high, at least more than default otherwise intersection fails.

'----------------------------------------------------------------------------------------------
'----------------------------------------------------------------------------------------------
Option Explicit
'Author: YukiukiH
'Date: 06/21/2008
'compatibility: Rhino4
'memo: watch arrPt and strPt

bridgeSt
Sub bridgeSt

'first things first...
Rhino.AddLayer "centerPt", RGB(0,0,0) 'black
Rhino.AddLayer "circle", RGB(105,105,105) 'darl gray
Rhino.AddLayer "normal01", RGB(255,161,0) 'gold
Rhino.AddLayer "normal02", RGB(255,127,0) 'orange
Rhino.AddLayer "Pt", RGB(0,0,0) 'black
Rhino.CurrentLayer ("centerPt")

'divide bridge spline into segments (by length or segments)
Dim strSpline, dblLength, intSegments
Dim strOffset01, strOffset02
Dim arrPts, arrPt, strCenPt

strSpline = Rhino.GetObject("Select a curve")
strOffset01 = Rhino.GetObject("Select the first offset curve")
strOffset02 = Rhino.GetObject("Select the second offset curve")
Call Rhino.LayerVisible ("splineCenter", False)
Call Rhino.LayerVisible ("splineOffset", False)

If Rhino.IsCurve(strSpline) Then
'by length segment
dblLength = 1500
arrPts = Rhino.DivideCurveLength(strSpline, dblLength)
'by segments
'intSegments = 130
'arrPoints = Rhino.DivideCurve(strSpline, intSegments)
For Each arrPt In arrPts
strCenPt = Rhino.AddPoint (arrPt)
Next
End If

'Ultimate Loop
'----------------------------------------------------------------------------------------------
'----------------------------------------------------------------------------------------------
Dim i, k
For i = 0 To UBound(arrPts)

'intersection (circle and offset spline) finds normal
Dim strCircle, arrPlane, arrInterPt01, arrInterPt02

arrPlane = Rhino.WorldXYPlane
strCircle = Rhino.AddCircle (arrPlane, 2000)
Call Rhino.ObjectLayer (strCircle, "circle")
Rhino.MoveObject strCircle, Array(0,0,0), arrPts(i)

Rhino.CurrentLayer ("Pt")
arrInterPt01 = Rhino.CurveCurveIntersection(strOffset01, strCircle)

If Not IsArray(arrInterPt01) Then
Rhino.Print "Selected curves do not intersect"
Exit Sub
End If

If arrInterPt01(k,0) = 1 Then
Rhino.Print "Intersection point on first curve: " & Rhino.Pt2Str(arrInterPt01(k,1))
Rhino.AddPoint arrInterPt01(k,1)
Else
Rhino.Print "Overlap"
Exit Sub
End If

arrInterPt02 = Rhino.CurveCurveIntersection(strOffset02, strCircle)
If Not IsArray(arrInterPt02) Then
Rhino.Print "Selected curves do not intersect"
Exit Sub
End If

If arrInterPt02(k,0) = 1 Then
Rhino.Print "Intersection point on first curve: " & Rhino.Pt2Str(arrInterPt02(k,1))
Rhino.AddPoint arrInterPt02(k,1)
Else
Rhino.Print "Overlap"
Exit Sub
End If

'add normal line
Dim strLine01, strLine02, strLine01axis, strLine02axis
Dim arrStPtLine01, arrStPtLine02, arrAxis01, arrAxis02
Dim strLine01vrt, strLine02vrt

Rhino.CurrentLayer ("normal01")
strLine01 = Rhino.AddLine (arrPts(i), arrInterPt01(k,1))
Rhino.CurrentLayer ("normal02")
strLine02 = Rhino.AddLine (arrPts(i), arrInterPt02(k,1))

Next
'----------------------------------------------------------------------------------------------
'----------------------------------------------------------------------------------------------

Call Rhino.LayerVisible ("splineCenter", True)
Call Rhino.LayerVisible ("splineOffset", True)
Call Rhino.print ("script complete")
End Sub

Ball Tracking

2008-03-16T20:00:00.001-07:00

Recently finished Nick Pisca's MEL scripting workshop and found MEL is a lot of fun. Seems much smarter than Rhino in a lot of ways. Things like declarations and arrays are much easier although the case sensitive stuff gets me all the time. We didn't cover procedures in the workshop but got to hit a lot of ground including scripting material assignment and rendering.

Here's a simple tracking script where planes duplicate and deform while following an animated object. I'll post the video sometime in the future.

//Tracking script
//
//Written by: Sky Milner
//Date: 3-03-08
//Contributor: Nick Pisca
//
//This script duplicates selected objects based on the
//location of a target.
//
//Setup:
//First make an object and call it "Target", Animate target as you like, make 6 nurbsPlanes
//
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

string $Selection[] = {"nurbsPlane1", "nurbsPlane2", "nurbsPlane2", "nurbsPlane3", "nurbsPlane3","nurbsPlane4","nurbsPlane4","nurbsPlane5","nurbsPlane5","nurbsPlane6", "nurbsPlane6","nurbsPlane1"};
int $SelSize = size($Selection);
int $SquareCounter = 0;

for ($i = 0; $i < currentnumber =" 0;" selectioncounter =" 0;" firstobject =" $Selection[$CurrentNumber];" secondobject =" $Selection[$CurrentNumber+1];" vecfirst =" <<$XYZfirst[0],">> ;

float $XYZsecond[] = `pointPosition ($SecondObject + ".cv [0] [0]")` ;
vector $VecSecond = <<$XYZsecond[0], $XYZsecond[1], $XYZsecond[2]>> ;

float $XYZtarget[] = `pointPosition ("Target.cv [0] [0]")`;
vector $VecTarget = <<$XYZtarget[0], $XYZtarget[1], $XYZtarget[2]>>;

$Between = $VecFirst - $VecSecond;

//Duplicate and move into position

duplicate -rr -n ("series"+$i+"square"+$SquareCounter) $Selection[($CurrentNumber)];

string $Duplicate = ("series"+$i+"square"+$SquareCounter);

//setAttr ($Duplicate+ ".translate") ($XYZfirst[0] + $Between.x/(-2)) ($XYZfirst[1] + $Between.y / (-2) ) ($XYZfirst[2] + $Between.z / (-2));

xform -r -t ($Between.x/(-2)) ($Between.y / (-2)) ($Between.z / (-2)) $Duplicate;

float $XYZduplicate[] = `pointPosition ($Duplicate + ".cv [0] [0]")`;
vector $Vecduplicate = <<$XYZduplicate[0], $XYZduplicate[1], $XYZduplicate[2]>>;

$Between2 = $VecTarget - $Vecduplicate;

//setAttr ($Duplicate+ ".translate") ($XYZduplicate[0] + $Between2.x/4) ($XYZduplicate[1] + $Between2.y/2) ($XYZduplicate[2] + $Between2.z/4);

xform -r -t ($Between2.x/4) ($Between2.y/2) ($Between2.z/4) $Duplicate;

//Scale Duplicate

float $scalefactor = ((mag($Between2)*.01)+.75);

//setAttr ($Duplicate+ ".scaleX") $scalefactor;
//setAttr ($Duplicate+ ".scaleY") $scalefactor;
//setAttr ($Duplicate+ ".scaleZ") $scalefactor;

//Manipulate cv[0]

float $PointX = `getAttr ($Duplicate + ".cv[0].xValue")`;
float $PointY = `getAttr ($Duplicate + ".cv[0].yValue")`;
float $PointZ = `getAttr ($Duplicate + ".cv[0].zValue")`;

vector $VecPoint = <<$PointX, $PointY, $PointZ>>;

$Between3 = $VecTarget - $VecPoint;

setAttr ($Duplicate+ ".cv[0].xValue") ($PointX + $Between3.x/(10));
setAttr ($Duplicate+ ".cv[0].yValue") ($PointY + $Between3.y/(10));
setAttr ($Duplicate+ ".cv[0].zValue") ($PointZ + $Between3.z/(10));

//setAttr ($Duplicate + ".objectColor") $SquareCounter;

$TempSelection [$SelectionCounter] = $FirstObject;
$TempSelection [$SelectionCounter+1] = $Duplicate;
$TempSelection [$SelectionCounter+2] = $SecondObject;
$TempSelection [$SelectionCounter+3] = $Duplicate;

$CurrentNumber = $CurrentNumber+2;
$SelectionCounter = $SelectionCounter + 4;
$SquareCounter++;
} while ($CurrentNumber < $SelSize); currentTime $i; $Selection = $TempSelection; $SelSize = size($Selection); if ($SelSize > 100) {
for ($s = 0; $s < selsize =" 100;" iii =" 0;" sizejump =" size($jump);" nicklambert = "nicklambert" nicklambertsg = "nicklambert" nicklambertoutcolor = "nicklambert" nicklambertsgss = "nicklambert" nicklamberttrans = "nicklambert" iiiend =" $iii" iiiend2 =" $iii" iii="$iii" i="0;" seriessize =" size($series);" s =" 0;" curshader =" $Shader[0];">

Next up is MEL!!!

2008-03-05T03:56:00.000-08:00

Nicholas Pisca's workshop at SCI-Arc. I guess MEL is more forgiving than rvb. No Option Explicit, no Dim, and so forth... Sky, Ye, I'm waiting for your scripts too, ok?

The following is a basic script to display certain information from multiple existing geometries. The challenge was to figure out the closest object for each one. I had to use two "integer counters" ($HCounter and $JCounter) and the orange portion (in the script) was the key for completing this script.

//----------------------------------------------------------------
//----------------------------------------------------------------
// print information and the closest obj for each obj

//Author: yukie hirashima
//Contributor: sky
//Date: 03/05/2008
//compatibility: Maya8.5

SelectAll; //don't have to select manually

string $Sel[] = `ls-sl` ;
int $SelSize = `size($Sel)` ; //Max Array
int $JCounter = 0;

do {

string $closest ;
string $CurrentRef = $Sel[$JCounter] ;

float $ValScaleX = `getAttr ($Sel[$JCounter] + ".scaleX")` ;
print ("\n" ) ;
print ("\n" ) ;
print ($Sel[$JCounter] + " Attribute" + "/" + "\n") ;
print ("Objext name: " + $Sel[$JCounter] + " has an scaleX value of " + $ValScaleX + "\n" ) ;

float $ValRotateY = `getAttr ($Sel[$JCounter] + ".rotateY")` ;
print ("Objext name: " + $Sel[$JCounter] + " has an rotateY value of " + $ValRotateY + "\n" ) ;

float $ValTranslateZ = `getAttr ($Sel[$JCounter] + ".translateZ")` ;
print ("Objext name: " + $Sel[$JCounter] + " has an translateZ value of " + $ValTranslateZ + "\n" ) ;

//comparig the closest for each one
int $HCounter = 1;

//creating mini array
SelectAll; //don't have to select manually
select -tgl $CurrentRef ;
string $miniSel[] = `ls-sl` ;
int $miniSelSize = `size($miniSel)` ; //max array

//creating $PreviousDist for the first round
float $XYZVals01[] = `getAttr ($CurrentRef + ".translate")` ;
vector $XYZVec01 = <<$XYZVals01[0], $XYZVals01[1], $XYZVals01[2]>> ;

float $XYZVals02[] = `getAttr ($miniSel[$HCounter-1] + ".translate")` ;
vector $XYZVec02 = <<$XYZVals02[0], $XYZVals02[1], $XYZVals02[2]>> ;

$DiffVec = $XYZVec01 - $XYZVec02 ;
float $PreviousDist = mag($DiffVec) ;
//print ($PreviousDist + "\n") ; //TESTPRINT $PreviousDist

do {

//creating mini array for each round EXCLUDING $CurrentRef

SelectAll; //don't have to select manually
select -tgl $CurrentRef ;
string $miniSel[] = `ls-sl` ;
int $miniSelSize = `size($miniSel)` ; //Max Array
print (" now vs. " + $miniSel[$HCounter-1] + ": "); //TESTPRINT comparison

//get a distance from vector

float $XYZVals01[] = `getAttr ($CurrentRef + ".translate")` ;
vector $XYZVec01 = <<$XYZVals01[0], $XYZVals01[1], $XYZVals01[2]>> ;

float $XYZVals02[] = `getAttr ($miniSel[$HCounter-1] + ".translate")` ;
vector $XYZVec02 = <<$XYZVals02[0], $XYZVals02[1], $XYZVals02[2]>> ;

$DiffVec = $XYZVec01 - $XYZVec02 ;
float $CurrentDist = mag($DiffVec) ;
print ("Distance btw " + $CurrentRef + " & " + $miniSel[$HCounter-1] + " is " + $CurrentDist + "\n") ;

if ($CurrentDist <= $PreviousDist) {
$closest = $miniSel[$HCounter-1] ;
//print ("\n" + $CurrentDist) ; //TESTPRINT $CurrentDist
$PreviousDist= $CurrentDist ; // prepareing for the next round

}

$HCounter++ ;
} while ($HCounter < $SelSize);
print ($CurrentRef + " is closest to " + $closest + "\n") ;

$JCounter++ ;
} while ($JCounter < $SelSize) ; // ----------------------------------------------------------------
// ----------------------------------------------------------------

Ready for Another Lattice?

2008-02-12T23:53:00.001-08:00

Here is another practical script for making physical models. I have to explode polylines manually first, then select the segment curves in order to layout for print (with little markers). Since "orient curve" command keeps working in a Loop, I have to Esc out the script, or simply reDim "i" manually for every round.

Option Explicit

layoutPolyline
Sub layoutPolyline

Dim strLine01, strLine02, strLineSave, i, j, arrReference, arrTarget
Dim arrCurve01S, arrCurve01E, arrCurve02S, arrCurve02E
Dim arrTarget1, arrTarget2, strMarker
i = 4
j = i + 0.75

'select an initial line to duplicate and hide
strLine01 = Rhino.GetObject ("select a line", 4)
strLineSave = Rhino.CopyObject (strLine01)
Call Rhino.HideObject(strLineSave)

'orient the line
arrCurve01S = Rhino.CurveStartPoint (strLine01)
arrCurve01E = Rhino.CurveEndPoint (strLine01)

arrReference = Array (arrCurve01S,arrCurve01E)
arrTarget1 = Array (0,-i, 0)
arrTarget2 = Array (99999,-i, 0)
arrTarget = Array (arrTarget1,arrTarget2)

strLine01 = Rhino.OrientObject (strLine01, arrReference, arrTarget)
strMarker = Rhino.AddLine (arrTarget1, Array(0,-j,0))

'select the succeding lines in order
Do
'duplicate and hide
strLine02 = Rhino.GetObject ("select the next line", 4)
strLineSave = Rhino.CopyObject (strLine02)
Call Rhino.HideObject(strLineSave)

'orient lines
arrCurve02S = Rhino.CurveStartPoint (strLine02)
arrCurve02E = Rhino.CurveEndPoint (strLine02)

arrReference = Array (arrCurve02S,arrCurve02E)
arrTarget1 = Array (0,-i, 0)
arrTarget2 = Array (99999,-i, 0)
arrTarget = Array (arrTarget1,arrTarget2)

strLine02 = Rhino.OrientObject (strLine02, arrReference, arrTarget)

arrCurve01S = Rhino.CurveStartPoint (strLine01)
arrCurve01E = Rhino.CurveEndPoint (strLine01)
arrCurve02S = Rhino.CurveStartPoint (strLine02)
arrCurve02E = Rhino.CurveEndPoint (strLine02)

Call Rhino.MoveObject (strLine02, arrCurve02S, arrCurve01E)
Call Rhino.CopyObject (strMarker, arrTarget1, arrCurve01E)

strLine01 = strLine02
Loop

End Sub

Something Flowerly

2008-02-05T21:36:00.000-08:00

Recent progress in rvb. As it's explained in script,
1. create sphere in spiral, and scale accordingly
2. draw 2d line, rotate, and move
3. rotate sphere in 3D

thats all. Enjoy.

Option Explicit

addVector()
Sub addVector()

Dim arrCoordinate(2), arrPoint(), arrSphere(), arrScaleSphere()
Dim arrLine(), arrSt(2), arrEd(2), arrRotateLine(), dblAngle
Dim arrFinSphere(), arrAxis(), arrLineEd()
Dim i, t, pi, arrScale
Dim A, B, C
i = 0
dblAngle = 30

For t = -5 To 6 Step 0.05

'create sphere in spiral, and scale accordingly ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
A = 1
B = 1
C = t+5
arrScale = Array(A, B, C)

arrCoordinate(0) = t*Sin(5*t)
arrCoordinate(1) = t*Cos(5*t)
arrCoordinate(2) = t

'ReDim Preserve arrPoint(i)
'arrPoint(i) = Rhino.AddPoint(arrCoordinate) 'don't need a string of point to draw a sphere

ReDim Preserve arrSphere(i)
arrSphere(i) = Rhino.AddSphere(arrCoordinate, 0.25)

ReDim Preserve arrScaleSphere(i)
arrScaleSphere(i) = Rhino.ScaleObject(arrSphere(i), arrCoordinate, arrScale)

'draw 2d line, rotate, and move ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
arrSt(0) = arrCoordinate(0)
arrSt(1) = arrCoordinate(1)
arrSt(2) = 0
arrEd(0) = 0
arrEd(1) = 0
arrEd(2) = 0

ReDim Preserve arrLine(i)
arrLine(i) = Rhino.AddLine(arrSt, arrEd)

ReDim Preserve arrRotateLine(i)
arrRotateLine(i) = Rhino.RotateObject(arrLine(i), arrSt, 90)

Call Rhino.MoveObject (arrLine(i), arrSt, arrCoordinate)

'rotate sphere in 3d '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
ReDim Preserve arrLineEd(i)
arrLineEd(i) = Rhino.CurveEndPoint (arrLine(i))

ReDim Preserve arrAxis(i)
arrAxis(i)= Rhino.VectorCreate (arrCoordinate, arrLineEd(i))

ReDim Preserve arrFinSphere(i)
arrFinSphere(i) = Rhino.RotateObject (arrScaleSphere(i), arrCoordinate, dblAngle, arrAxis(i))

i = i+1
Next

End Sub

orientCurve

2007-11-26T17:27:00.000-08:00

The following is the script to construct this mess. I modeled a polygon lattice in Maya with multiple deformer. In Rhino, the script allows me to select those lines in order to lay them out. I printed those lines and cut wood sticks accordingly.

NO measuring! Saved my ass.

Option Explicit
Sub orientCurve

Dim strLine, i, arrReference, arrTarget
Dim strCurveS, strCurveE, strTarget1, strTarget2
i = 4

Do

'select lines in order
strLine = Rhino.GetObject ("select a line", 4)

'orient lines
strCurveS = Rhino.CurveStartPoint (strLine)
strCurveE = Rhino.CurveEndPoint (strLine)

arrReference = Array (strCurveS,strCurveE)
strTarget1 = Array (0,-i, 0)
strTarget2 = Array (99999,-i, 0)
arrTarget = Array (strTarget1,strTarget2)

i = i + 0.25
Call Rhino.OrientObject (strLine, arrReference, arrTarget)

Loop

End Sub
orientCurve

Population Script

2007-10-15T19:34:00.000-07:00

This Script takes a bunch of lines and populates another curve to them. Recommended for lasercut.

Option Explicit

Call Populate()
Sub Populate()

Dim Object, ArrLines, i, Popstart, PopEnd, RefPoints, strScale, strOptions, RefObject

strOptions = Array ("y", "n")

Object = Rhino.GetObject ("Select Populate Object", 4)
RefObject = Rhino.GetObject ("Select Reference line for Population", 4)
ArrLines = Rhino.GetObjects ("Select target Curves", 4)
strScale = Rhino.GetString ("Do you want to Scale", "y", strOptions)

Popstart = Rhino.CurveStartPoint(RefObject)
PopEnd = Rhino.CurveEndPoint(RefObject)
RefPoints = Array(Popstart, Popend)

For i = 0 To UBound(arrLines)
Call Copypop(Object, arrlines(i), Refpoints, strScale)
Call Rhino.DeleteObject(arrlines(i))
Next

End Sub

Function CopyPop(Object, Target, Refpoints, strScale)

Dim startPoint, endPoint, TargetPoint, PopCurve, tempCrv, refDist

startPoint = Rhino.CurveStartPoint(target)
endPoint = Rhino.CurveEndPoint(target)
TargetPoint = Array(startPoint, endPoint)
refDist = Rhino.Distance (Refpoints(0), RefPoints(1))

If strScale = "n" Then
Dim targetDist, scalefactor
targetDist = Rhino.Distance(TargetPoint(0), TargetPoint(1))
scalefactor = TargetDist/Refdist
tempCrv = Rhino.ScaleObject(Object, RefPoints(0),Array(scalefactor,1,1) ,vbTrue)
PopCurve = Rhino.OrientObject(TempCrv, RefPoints, TargetPoint)

Else
PopCurve = Rhino.OrientObject(Object, RefPoints, TargetPoint, 3)
End If

End Function

Still having a bug

2007-10-04T23:43:00.000-07:00

Ok Sky, I removed the bug, no more error message, but when I try hiding objects, command cannot grab anything. Array after sorting is name-string array, not object-string array.

Another problem is that since SortStrings reads CurveLength number as string...
Array (32, 9,12,11, 25)
Sorted Array (11, 12, 25, 32, 9)

I guess I'll go back to my studio now...

Option Explicit

ShowCurve ()
Sub ShowCurve ()

Dim arrCurve, arrSorted, strTemp, i

'Get The Curves
arrCurve = Rhino.GetObjects ("select curves to rename", 4)

'Assign Curves to new array and rename objects
For i = 0 To UBound(arrCurve)
If Rhino.IsCurve(arrCurve(i)) Then

strTemp = Rhino.CurveLength(arrCurve(i))
arrCurve(i) = Rhino.ObjectName (arrCurve(i), "Curve" & CStr(strTemp))
Rhino.Print (arrCurve(i))
Rhino.Sleep 300

End If
Next

'Sort lengths in ascending order
arrSorted = Rhino.SortStrings(arrCurve, True)

'Hide all Objects
'Rhino.Command ("SelAll")
'Rhino.Command ("Hide")
Rhino.HideObjects (arrSorted)

'Show the Objects in curve length order
For i = 0 To UBound(arrSorted)

strTemp = arrSorted(i)
Rhino.ShowObject (strTemp)
Rhino.Print "sorted:" & (arrSorted(i))
Rhino.Sleep 300

Next

End Sub

SineWave

2007-10-04T23:36:00.000-07:00

Today's Script: Generate a sine wave, create spheres and scale them in order.

Option Explicit
'draw a sine wave using points

SineWave()
Sub SineWave()

Dim x, y, dblA, dblB, arr, dblStep, arrPoint(), arrSphere(), i, A, B, C
dblA = 0
dblB = 12
dblStep = 0.25
i = 0

For x = dblA To dblB Step dblStep
y = 2*Sin(x)

A = 0.02*i
B = 0.02*i
C = 0.03*i
arr = Array(A, B, C)

Call Rhino.AddPoint (Array (x,y,0))
ReDim Preserve arrPoint(i)
arrPoint(i) = Array (x,y,0)

ReDim Preserve arrSphere(i)
arrSphere(i) = Rhino.AddSphere (Array (x,y,0), 0.25)

Call Rhino.ScaleObject (arrSphere(i), arrPoint(i), arr)

Call Rhino.Sleep(30)
i = i+1
Next

End Sub

Show Curves in Order of Length

2007-10-02T17:45:00.000-07:00

For some reason I can't debug this code. Has problems with sortnumber variable type. Can anyone figure this out?

Option Explicit

ShowCurve ()

Sub ShowCurve ()

Dim arrCurve, i, arr(), temp, arr2()

'Get The Curves
arrCurve = Rhino.GetObjects ("select a curves to evaluate", 4)

'Assign Curves to new array and rename objects
For i = 0 To UBound(arrCurve)
If Rhino.IsCurve(arrCurve(i)) Then
temp = Rhino.CurveLength(arrCurve(i))
Rhino.Print (temp)
ReDim Preserve arr(i)
arr(i) = temp
Rhino.ObjectName arrCurve(i), "Curve" & CStr(temp)
End If
Next

'Sort lengths in ascending order
arr2 = Rhino.SortNumbers(arr, vbTrue)

'Hide all Objects
Rhino.Command ("SelAll")
Rhino.Command ("Hide")

'Show the Objects in curve length order
For i = 0 To UBound(arr2)
Temp = CStr(arr2(i))
Rhino.ShowObject "Curve" & Temp
Rhino.Sleep 1000
Next

End Sub

CurveToFitArea

2007-10-01T21:41:00.000-07:00

On the right is a script I wrote to scale down a curve to fit in certain area. The original is CurveToFitLength in Rhino scripting tutorial. Knowing both INPUTs

Rhino.CurveLength (strObject)
Rhino.CurveArea (strObject)

were available in Scripting Method, I thought it would be easy to write the same script but Area-based scaling instead of Length-based scaling. But I just realized Scripting Method also requires me to refer the OUTPUT. Unfortunately, CurveLength has dbl OUTPUT while CurveArea has arr OUTPUT.

Checkout the difference in above jpg.

Array To Select Multiple Curves

2007-09-30T18:08:00.000-07:00

Selecting multiple objects is easy, just use the Rhino.GetObjects method which returns an array, then cycle through the array to check each curve

Dim arrCurve, intShort

intShort = Rhino.GetReal ("min. length to keep?", 0.1)
arrCurve = Rhino.GetObjects ("select a curves to evaluate", 4)

Dim i

For i = 0 to Ubound(arrCurve)
If Rhino.CurveLength (arrCurve(i)) > intShort Then
Call Rhino.ObjectLayer (arrCurve(i), "Curve")
Else
Call Rhino.DeleteObject (arrCurve(i))
End If
Next

Newbie's struggle

2007-09-30T13:44:00.000-07:00

Inspired from the script Sky wrote last night, I would like to write a script that lets user select many curves and decides the min. length to keep, and deletes shorter-than-the-min. curves. My struggle is that CurveLength (script method) seems to evaluate only ONE curve at a time. If someone know how to do it better, please let me know. array still confuses me.

Option Explicit

EvaluateCurve ()
Sub EvaluateCurve ()

Call Rhino.AddLayer ("Curve")

Dim strCurve, intShort
intShort = Rhino.GetReal ("min. length to keep?", 0.1)
strCurve = Rhino.GetObject ("select a curve to evaluate", 4)

If Rhino.CurveLength (strCurve) > intShort Then
Call Rhino.ObjectLayer (strCurve, "Curve")
Else
Call Rhino.DeleteObject (strCurve)
End If

End Sub

Pattern Generation

2007-09-30T02:17:00.000-07:00

What was seemingly a simple script took me all night to figure out. It takes any curve and divides it up into alternating sets of cut lines to be pulled out into perforated structures.

Option Explicit

Call CutPattern ()

Sub CutPattern ()

Dim blspace, varcut, arrOddCrv, arrEvenCrv, offset, temp

'get User Input

blspace = Rhino.GetReal ("size of space",.1, 0, .5)
varCut = Rhino.GetInteger ("Number of cuts",20)
offset = Rhino.GetReal ("Offset Amount", 1, 0, 1)
arrOddCrv = Rhino.GetObjects ("Pick Odd Curves", 4)
arrEvenCrv = Rhino.GetObjects ("Pick Even Curves", 4)
temp = 0

Dim k

For k = 0 To UBound(arrOddCrv)
Call Generate(arrOddCrv(k), blspace, varcut, temp)
Next

For k = 0 To UBound(arrEvenCrv)
Call Generate(arrEvenCrv(k), blspace, varcut, offset)
Next

End Sub

Function Generate(strCrv, BetweenCuts, CutNum, offset)

Dim Counter : Counter = 0
Dim Dist : Dist = 0
Dim ArrPoints(), ArrDomain, currentDist, adjSpace, adjCut
arrDomain = Rhino.CurveDomain(strCrv)
adjSpace = 1/CutNum*BetweenCuts
adjCut = ((1/CutNum)-adjSpace)*.5
dist = dist + (adjcut*offset)
'Rhino.Print "Curve domain: " & CStr(arrDomain(0)) & " to " & CStr(arrDomain(1))

Do While Dist < 1
ReDim Preserve arrPoint(counter)
currentDist = adjPar(arrDomain, dist)
arrPoint(counter) = Rhino.EvaluateCurve(strCrv, currentDist)
dist = dist + adjCut
Counter = counter + 1

ReDim Preserve arrPoint(counter)
currentDist = adjPar(arrDomain, dist)
arrPoint(counter) = Rhino.EvaluateCurve(strCrv, currentDist)
dist = dist + adjCut
Counter = counter +1

ReDim Preserve arrPoint(counter)
currentDist = adjPar(arrDomain, dist)
arrPoint(counter) = Rhino.EvaluateCurve(strCrv, currentDist)
dist = dist + adjSpace
Counter = counter +1
Loop

Dim i : i = 0
Dim LineArray(2)

'Add Lines
Do While i < UBound(arrPoint)
LineArray(0) = arrPoint(i)
i=i+1
LineArray(1) = arrPoint(i)
i=i+1
LineArray(2) = arrPoint(i)
i=i+1
Rhino.AddCurve LineArray
Loop

End Function

Function adjPar(crvDomain, dist)
adjPar = crvDomain(0) + dist * (crvDomain(1) -crvDomain(0))
End Function

pariSSSS, france

2007-09-15T09:29:00.001-07:00

Last spring, while attending a semester at the Ecole Speciale D'Architecture the studio was introduced to rhino scripting techniques at a workshop conducted by Edmondo Occhipinti. The studio ; Eco-Logical High-rise, focused around the idea of utilizing various computational methods and software for design performance, evaluation, and optimization.

This script was developed in collaboration with Martin. It creates a series of 12 points from equations derived for the construction of a unit circle, implements a directional deviation of either a single or double point, and draws a closed curve through the set of points. The script was used to generate floor plates that respond to prevalent wind direction, either by developing a 'bulge factor' in the direction of the wind or against it. It was imagined that the implementation of this method in the design could be used to have parts of the building that were capturing the wind for energy-generation purposes and others that were repelling the wind for structural reasons.

Voici le script et quelques images:

Option Explicit
'base floor curve from points'

Call DrawCurve

Sub DrawCurve

Dim r
Dim bulgefactor
Dim i
Dim j
Dim arrpt1, arrpt2, arrpt3, arrpt4, arrpt5, arrpt6, arrpt7, arrpt8, arrpt9, arrpt10, arrpt11, arrpt12
Dim arrpts
Dim arrcrvpts
Dim crv1

bulgefactor= Rhino.getreal ("choose bulge ratio")
r= 1.0477787091366303436714165968148*Rhino.getreal ("identify RADIUS", 1,0)
i= ((3/2)*Rhino.getreal ("choose the inflatement ratio for ETE", bulgefactor,-2))/1.0477787091366303436714165968148
j= ((3/2)*Rhino.getreal ("choose the inflatement ratio for HIVER", -bulgefactor,-2))/1.0477787091366303436714165968148

arrpt1= array (0,r)
arrpt2= array ((r+i*r)/2,(r+i*r)*Sqr(3)/2)
arrpt3= array (r*Sqr(3)/2, r/2)
arrpt4= array (r,0)
arrpt5= array (r*Sqr(3)/2, -r/2)
arrpt6= array (r/2, -r*Sqr(3)/2)
arrpt7= array (0,-(r+j*r))
arrpt8= array (-r/2, -r*Sqr(3)/2)
arrpt9= array (-r*Sqr(3)/2, -r/2)
arrpt10= array (-r,0)
arrpt11= array (-r*Sqr(3)/2, r/2)
arrpt12= array (-r/2, r*Sqr(3)/2)

arrpts= array (arrpt11, arrpt12, arrpt1, arrpt2, arrpt3, arrpt4, arrpt5, arrpt6, arrpt7, arrpt8, arrpt9, arrpt10, arrpt11)

'arrcrvpts= Rhino.addpoints (arrpts)

crv1= Rhino.AddCurve (arrpts,3)

End Sub

Advanve Structure

2007-02-28T05:42:00.000-08:00

Power Copying...

Here are some iterations of origami surfaces. The challenge was (except the manual powerCopying...) how to set up spikes NORMAL to the surface. Basically, those are done by manipulating sin curve functions (to control the curvature of surfaces). Deformation nodes are the followings.

-the span of sin curve
-number of waves
-repetition of waves
-height of the creases
-acceleration of curvature angle (by law)

The next step is to apply scaling to those creases. Well, actually those steps are similar to the physical origami studies from my 3A studio.

By the way, I think FoG stands for Function of Graph. Better guess than Frank O Gehry...

Exporting Points

2007-02-13T21:28:00.000-08:00

Right now my job at Arup is to do solar gain calculations on a house. In order to do this I have to model the window and the shading devices in the Arup engineering software. Unfortunately engineering software is not very visual, meaning that all the shading planes have to be entered via coordinates like x, y, z. The project I'm working on has hundreds of these shading planes, to do the job manually would take several days of tedious calculations and data entry. So I wrote a little script to export all the points from a 3d rhino model to a spreadsheet in which the whole thing can be pasted into the program with one button. This saves hours of tedious time and gives me the benefit of using Rhino to make the 3d model which is extremely fast.

Here's the script:

Option Explicit

PrintSurfacePoints

Sub PrintSurfacePoints

Dim strSurface, arrObjects
arrObjects = Rhino.GetObjects("Select surfaces", 8)
If IsNull(arrObjects) Then Exit Sub

Dim i : i = 0
Dim surfaceArray()

If IsArray(arrObjects) Then

For Each strSurface In arrObjects

Dim arrPoints
arrPoints = Rhino.SurfacePoints(strSurface)
If Not IsArray(arrPoints) Then Exit Sub

ReDim Preserve surfaceArray(i)
surfaceArray(i) = arrPoints
i = i+1

Next

End If

Dim objXL
Set objXL = CreateObject("Excel.Application")

objXL.Visible = True
objXL.WorkBooks.Add

objXL.Columns(1).ColumnWidth = 10
objXL.Columns(2).ColumnWidth = 10
objXL.Columns(3).ColumnWidth = 10
objXL.Columns(4).ColumnWidth = 10
objXL.Columns(5).ColumnWidth = 10
objXL.Columns(6).ColumnWidth = 10
objXL.Columns(7).ColumnWidth = 10

objXL.Cells(1, 2).Value = "Base X"
objXL.Cells(1, 3).Value = "Base Y"
objXL.Cells(1, 4).Value = "Base Z"
objXL.Cells(1, 5).Value = "Top X"
objXL.Cells(1, 6).Value = "Top Y"
objXL.Cells(1, 7).Value = "Top Z"

objXL.Range("A1:G1").Select
objXL.Selection.Font.Bold = True
objXL.Selection.Interior.ColorIndex = 1
objXL.Selection.Interior.Pattern = 1 'xlSolid
objXL.Selection.Font.ColorIndex = 2

objXL.Columns("B:B").Select
objXL.Selection.HorizontalAlignment = &hFFFFEFDD ' xlLeft

Dim intIndex
intIndex = 2

Dim d
For d = 0 To i-1 Step 1

Dim strPoint, arrPt
Dim counter: counter = 0

For counter = 0 To 2 Step 2
arrPt = surfaceArray(d)(counter)
objXL.Cells(intIndex, 2).Value = Round(arrPt(0),4)
objXL.Cells(intIndex, 3).Value = Round(arrPt(1),4)
objXL.Cells(intIndex, 4).Value = Round(arrPt(2),4)
arrPt = surfaceArray(d)(counter+1)
objXL.Cells(intIndex, 5).Value = Round(arrPt(0),4)
objXL.Cells(intIndex, 6).Value = Round(arrPt(1),4)
objXL.Cells(intIndex, 7).Value = Round(arrPt(2),4)
objXL.Cells(intIndex, 8).Value = 100
objXL.Cells(intIndex, 9).Value = 0

objXL.Cells(intIndex, 1).Value = "surface " & d+1
intIndex = intIndex + 1
Next

objXL.UserControl = True

End Sub

DrawLineFromCurve

2007-01-27T23:30:00.000-08:00

The following is pretty basic script to take a curve to generate a straight line that has the same length with the original curve.

Option Explicit
'this script is created to unroll sphere
'so that hopefully I chould unroll little bit advanced shape.

UnrollSphere()
Sub UnrollSphere()

'Shpere should be ready
' -Circumference Max is 8'
' -Trimmed with 0 and 45 degree lines
' -Rebuilt Vertical Surf to U2, Vt
' -Extract wireframe

'Number of Division
Dim t
t = 8

Dim arrOrigin
arrOrigin = array(0,0,0)

'Get Length
Dim halfSphereCircumference1, dblLength

halfSphereCircumference1 = Rhino.GetObject("Select a circumference curve", 4)
If IsNull(halfSphereCircumference1) Then Exit Sub

dblLength = Rhino.CurveLength(halfSphereCircumference1)
Rhino.Print "Curve length: " & CStr(dblLength)

'Draw Line and Divide
Dim strStraight, arrCircumferenceCurvePoints

strStraight = Rhino.AddLine (arrOrigin, array(0,dblLength,0))

End Sub

Script Samples

2007-01-26T20:59:00.001-08:00

If you are trying to veryfy whether or not the selected object is curve, don't use IsCurve.

Rhino.IsCurve (strObject [, intIndex])

It would be much faster if you use GetObject instead.

Rhino.GetObject ([strMessage [, intType [, blnPreSelect [, blnSelect [, arrObjects ]]]]])

The Second option [, intType lets you limit the type of object you can select.
The object types are the following

0
1
2
4
8
16
32
256
512
4096

Digital Project

2007-01-15T22:49:00.000-08:00

Hope the Rhinoscripting is going good. I just sat through a presentation of Digital project. The program seems amazing and is totally compatible with visual basic, which is good for all of us that started learning. From what Nick Pisca said the plus of Digital Project is its stability, and of course real time parametric updating that rhino doesn't have. Also turns out a lot of other programs can be accessed through windows platform. I don't know the specifics of it but really its this real-time, network, cross-program workflow that is fascinating.

All Things BIM has a post about Digital Project.

minimal surface script

2007-01-12T18:29:00.000-08:00

// minimum surface creator.
// copyright 2005 Theo Calvin
// free to use for educational purposes.
// for any other use please contact theo@mediumlite.com

minSurfUI;

/////////////////////////////////////////////////////////////////////////////////////

proc string[] parseName (string $input) {
string $return[];
string $next;
string $currentString = "";
int $strCount = 0;
for ($i=2; $i<=`size($input)`; $i++) { $next = `substring ($input) $i $i `; if ($next == "|") { $return[$strCount] = $currentString; $currentString = ""; $strCount++; } else { $currentString = $currentString + $next; } if ($i == `size($input)`) { $return[`size($return)`] = $currentString; } } return $return; } ///////////////////////////////////////////////////////////////////////////////////// proc vector getLocV(string $one){ float $currentpos[] = `xform -ws -q -t ($one)`; return <<$currentpos[0],$currentpos[1],$currentpos[2]>>;
}

// ================================================================================
//
// minSurf
//
// ================================================================================

global proc minSurf() {
waitCursor -state on;
float $curveMin;
float $curveMax;
float $curveSpan;
int $updatePercentage ;
float $smoothLoops;
float $updateAmmount;

progressWindow
-title "Creating Surface"
-status ("Complete: "+$updatePercentage+"%")
-isInterruptable true;
;

//........................
// get selection
//........................
string $curves[] = `ls -sl -l`;
string $path[] = parseName ($curves[0]);

//........................
// create polySurface
//........................
int $minSXarray[] = `intFieldGrp -q -v polySubX_field`;
int $minSYarray[] = `intFieldGrp -q -v polySubY_field`;
int $minSX = $minSXarray[0];
int $minSY = $minSYarray[0];
string $minSholder[] = `polyPlane -w 1 -h 1 -sx $minSX -sy $minSY -ax 0 1 0 -tx 1 -ch 0 -n "minSurface"`;
string $minS = $minSholder[0];

//...............................
// place edges on borders (x1)
//...............................
$curveMin = `getAttr ($curves[0]+".min")`;
$curveMax = `getAttr ($curves[0]+".max")`;
$curveSpan = `abs $curveMax`-`abs $curveMin`;
float $subSpan = $curveSpan/$minSX;

float $currentU;
float $pointLoc[];
for ($i=0; $i<=$minSX; $i++) { $currentU = $curveMin + ( $subSpan*$i); $pointLoc = `pointOnCurve -pr $currentU $curves[0]`; select -r ($minS+ ".vtx["+$i+"]") ; move $pointLoc[0] $pointLoc[1] $pointLoc[2] ; //currentTime 0; } //............................... // place edges on borders (y1) //............................... $curveMin = `getAttr ($curves[1]+".min")`; $curveMax = `getAttr ($curves[1]+".max")`; $curveSpan = `abs $curveMax`-`abs $curveMin`; float $subSpan = $curveSpan/$minSY; int $vtx; for ($i=1; $i<$minSY; $i++) { $vtx = $minSX +($i*($minSX+1)); //print ("vtx: " + $vtx + "\n"); $currentU = $curveMin + ( $subSpan*$i); $pointLoc = `pointOnCurve -pr $currentU $curves[1]`; select -r ($minS+ ".vtx["+$vtx+"]") ; move $pointLoc[0] $pointLoc[1] $pointLoc[2] ; //currentTime 0; } //............................... // place edges on borders (x2) //............................... $curveMin = `getAttr ($curves[2]+".min")`; $curveMax = `getAttr ($curves[2]+".max")`; $curveSpan = `abs $curveMax`-`abs $curveMin`; float $subSpan = $curveSpan/$minSX; for ($i=0; $i<=$minSX; $i++) { $vtx = ((($minSX+1)*($minSY+1))-1)-$i; $currentU = $curveMin + ( $subSpan*$i); $pointLoc = `pointOnCurve -pr $currentU $curves[2]`; select -r ($minS+ ".vtx["+$vtx+"]") ; move $pointLoc[0] $pointLoc[1] $pointLoc[2] ; //currentTime 0; } //............................... // place edges on borders (y2) //............................... $curveMin = `getAttr ($curves[3]+".min")`; $curveMax = `getAttr ($curves[3]+".max")`; $curveSpan = `abs $curveMax`-`abs $curveMin`; float $subSpan = $curveSpan/$minSY; for ($i=1; $i<$minSY; $i++) { $vtx = ((($minSX+1)*($minSY)))-($i*($minSX+1)); $currentU = $curveMin + ( $subSpan*$i); $pointLoc = `pointOnCurve -pr $currentU $curves[3]`; select -r ($minS+ ".vtx["+$vtx+"]") ; move $pointLoc[0] $pointLoc[1] $pointLoc[2] ; //currentTime 0; } //...................................... // place vertices into initial position //...................................... vector $v1; vector $v2; vector $v3; vector $v4; vector $new1; vector $new2; vector $pos; int $row; for ($i=($minSX+2); $i< ((($minSX+1)*$minSY)-1); $i++) { int $vMod = $i%($minSX+1); if ($vMod>0 && $vMod < $minSX) { $v1 = getLocV($minS+ ".vtx["+($i-$vMod)+"]"); $v2 = getLocV($minS+ ".vtx["+($i-$vMod+$minSX)+"]"); $v3 = getLocV($minS+ ".vtx["+($vMod)+"]"); $v4 = getLocV($minS+ ".vtx["+($vMod+(($minSX+1)*$minSY))+"]"); $new1 = (($v1*($minSX-$vMod))+($v2*$vMod))/$minSX; $row = $i/($minSX+1); $new2 = (($v3*($minSY-$row))+($v4*$row))/$minSY; $pos = ($new1 + $new2)*.5; select -r ($minS+ ".vtx["+$i+"]") ; move ($pos.x) ($pos.y) ($pos.z); //currentTime 0; } } int $vMod; $smoothLoops = `intSliderGrp -q -v maxIterationsField`; for ($loop=0; $loop<$smoothLoops ; $loop++) { for ($i=($minSX+2); $i< ((($minSX+1)*$minSY)-1); $i++) { $vMod = $i%($minSX+1); if ($vMod>0 && $vMod < $minSX) { //print (" " + $i); $v1 = getLocV($minS+ ".vtx["+($i-1)+"]"); $v2 = getLocV($minS+ ".vtx["+($i+1)+"]"); $v3 = getLocV($minS+ ".vtx["+($i-1-$minSX)+"]"); $v4 = getLocV($minS+ ".vtx["+($i+1+$minSX)+"]"); $pos = ($v1 + $v2 + $v3 + $v4)/4; select -r ($minS+ ".vtx["+$i+"]") ; move ($pos.x) ($pos.y) ($pos.z); } } select -r $minS; //print ("$loop: "+$loop+"\n"); if ( `progressWindow -query -isCancelled` ) break; $updateAmmount = ($loop/$smoothLoops )*100; $updatePercentage= $updateAmmount; //print ("$updatePercentage: " + ($updateAmmount) + "\n"); progressWindow -edit -progress ($updatePercentage) -status ("Complete: "+$updatePercentage+"%") ; if (`checkBox -q -v UIshowSurface`) { refresh -cv; } } progressWindow -endProgress; //print ("curveSpan: " + $curveSpan); select -r $minS; xform -cp; if (`size($path)`>2) {
parent ($minS) ($path[0]+"|"+$path[1]+"|"+$path[2]) ;
}
waitCursor -state off;
}

// ================================================================================
//
// minSurfUI
//
// ================================================================================

global proc minSurfUI () {
if (`window -exists minSurfUIWin` == 1) {
deleteUI minSurfUIWin;
}

string $minSurfUIWin = `window
-title "Minimum Surface Builder"
-menuBar 0
-mxb 0
-rtf 1
minSurfUIWin`;

//scrollLayout;
columnLayout;
separator -h 15 -w 400 -st "none";// whitespace
intFieldGrp -numberOfFields 1
-label "PolyDivisions X" -value1 15
polySubX_field; //`intFieldGrp -q -v polySubX_field`

intFieldGrp -numberOfFields 1
-label "PolyDivisions Y" -value1 15
polySubY_field; //`intFieldGrp -q -v polySubY_field`

// smoothing ITERATIONS
intSliderGrp -label "Smooth Iterations" -field true
-minValue 0 -maxValue 20
-fieldMinValue 0 -fieldMaxValue 100
-value 20
maxIterationsField; //`intSliderGrp -q -v maxIterationsField`

// show updates
separator -h 15 -w 400 -st "none";// whitespace
checkBox -label "Show Surface During Creation" -v 0 UIshowSurface;
/*
separator -h 15 -w 400 -st "in";// whitespace

text -l "0% Complete" UIupdateText;
*/

separator -h 15 -w 400 -st "in";// whitespace
// BUTTONS
//--------------
rowLayout
-nc 2
-cat 1 "both" 0
-cat 2 "both" 0
-columnWidth 1 100
-columnWidth 2 100
;

button -label "Create" -align "center" -command "minSurf";
button -label "Cancel" -align "center" -command "deleteUI minSurfUIWin";

showWindow $minSurfUIWin;
}

FitCurvetoLength Modified

2007-01-05T18:06:00.000-08:00

Here's Yuki's earlier script modified to identify the centerpoint of the curve with the method Rhino.BoundingBox

Option Explicit
'title: FitCurveToLength
'this script is to loop scaling a curve until it fits certain length

FitCurveToLength ()
Sub FitCurveToLength ()
Dim strCurveID
strcurveID = Rhino.GetObject("Select a curve to fit to length", 4, True, True)
If IsNull(strCurveID) Then Exit Sub

Dim arrBoundingBox
arrBoundingBox = Rhino.BoundingBox(strCurveID)

Dim arrCtr
Dim dblx, dbly, dblz
dblx =0.5*(arrBoundingBox(0)(0)+arrBoundingBox(1)(0))
dbly =0.5*(arrBoundingBox(1)(1)+arrBoundingBox(2)(1))
dblz =0.5*(arrBoundingBox(1)(2)+arrBoundingBox(5)(2))

arrCtr = array(dblx, dbly, dblz)

Dim dblLength
dblLength = Rhino.CurveLength(strCurveID)

Dim dblLengthLimit
dblLengthLimit = Rhino.GetReal("Length limit", 0.5*dblLength, 0.01*dblLength, dblLength)
If IsNull(dblLengthLimit) Then Exit Sub

Do
If Rhino.CurveLength(strCurveID) <= dblLengthLimit Then Exit Do
strCurveID = Rhino.ScaleObject(strCurveID, arrCtr, Array(0.95,0.95,0.95),True)
If IsNull(strCurveID) Then
Rhino.Print "Something went wrong..."
Exit Sub
End If
Loop

Rhino.Print "New curve length: " & Rhino.CurveLength(strCurveID)

End Sub

Architectural Critique: Scripting Misuse

2007-01-04T00:41:00.000-08:00

I found some Rhinoscripting studies while surfing the web that I was particularly disheartened with. The website shows a studio from Rensselaer Polytechnic Institute and what appears to be student projects in which math functions are the basis for structure/home design. Here are examples of what I DON'T want to do.

Here we have math functions in their purity and complexity making singular forms that get transformed into buildings that simply don't work very well or would work much better if they were developed in different ways. Not to be too harsh but the above example simply works against the very premise of wild parametric design by including distinctly uniform and standard floor slabs. In addition, despite the variations that each student shows faded into the background the math functions aren't flexible for local conditions. What it amounts to is form exploration for its own sake, not for better design.

Granted this is all my superficial reaction to this work in that I haven't taken the time to read the studio premise or any individuals goal. But this is a blog and I get to say what I like. So step off.

DivideCurve ( ) _yuki

2007-01-01T20:34:00.000-08:00

Here is my first script I wrote from scratch. User can pick two curves, divide into the number s/he wants, and draw lines accordingly. Array was complicated, but I'm getting hang of it.

Option Explicit
'S.S.S.S. sciarcsmac first challenge #2

DivideCurve()
Sub DivideCurve()
Dim strFirstCurve
strFirstCurve = Rhino.GetObject("Select the first curve", 4)
If IsNull(strFirstCurve) Then Exit Sub

Dim strSecondCurve
strSecondCurve = Rhino.GetObject("Select the second curve", 4)
If IsNull(strSecondCurve) Then Exit Sub

Dim t
t = Rhino.GetInteger("Number of division?", 10, 2, 100)
If IsNull (t) Then Exit Sub

Dim arrFirstCurvePoints
arrFirstCurvePoints = Rhino.DivideCurve(strFirstCurve, t, True)

Dim arrSecoudCurvePoints
arrSecoudCurvePoints = Rhino.DivideCurve(strSecondCurve, t, True)

Dim strAddedLines
Dim i

For i = 0 To t Step 1
strAddedLines = Rhino.AddLine(arrFirstCurvePoints(i), arrSecoudCurvePoints(i))

Next

Dim strSayYes
strSayYes = Rhino.GetString ("Continue? ", "Y")
If Not strSayYes = "Y" Then Exit Sub

Rhino.Print "Well done! "

End Sub

FitCurveToLength ( ) _yuki

2007-01-01T20:25:00.000-08:00

So far, I just copied tutorial, but my challenge is to scale down the curve within the original. The example on the right is my goal. Now, the scale origin is set to (0,0,0). I have to change the scale origin to the center of gravity. I don't even know if there is a way to specify it.

Option Explicit
'title: FitCurveToLength
'this script is to loop scaling a curve until it fits certain length

FitCurveToLength ()
Sub FitCurveToLength ()
Dim strCurveID
strcurveID = Rhino.GetObject("Select a curve to fit to length", 4, True, True)
If IsNull(strCurveID) Then Exit Sub

Dim dblLength
dblLength = Rhino.CurveLength(strCurveID)

Dim dblLengthLimit
dblLengthLimit = Rhino.GetReal("Length limit", 0.5*dblLength, 0.01*dblLength, dblLength)
If IsNull(dblLengthLimit) Then Exit Sub

Do
If Rhino.CurveLength(strCurveID) <= dblLengthLimit Then Exit Do strCurveID = Rhino.ScaleObject(strCurveID, Array(0,0,0), Array(0.95,0.95,0.95),True)
If IsNull(strCurveID) Then
Rhino.Print "Something went wrong..."
Exit Sub
End If
Loop

Rhino.Print "New curve length: " & Rhino.CurveLength(strCurveID)

End Sub

Area Script

2006-12-31T18:07:00.000-08:00

Here's a small script I wrote for calculating the area of panels in 3d. In the end I'd like to be able to send the information to a spreadsheet that will also flatten the panels and dimension them automatically.

Option Explicit

main()

Sub main()

Dim arrObjects

arrObjects = Rhino.GetObjects ("select a objects", 8)

Dim i
For i = 0 To UBound(arrObjects)
If Rhino.IsSurface(arrObjects(i)) Then
Dim arrArea : arrArea = Rhino.SurfaceArea(arrObjects(i))
Dim arrPoints : arrPoints = Rhino.SurfacePoints(arrObjects(i))
Rhino.AddText "Panel "& i+1 & " Area: " & CStr (arrArea(0)), arrPoints(0)
End If

Next

End Sub

Challenge #2 Method List (Please Update)

2006-12-31T01:32:00.000-08:00

So following up on Yuki's proposal for Challenge #2 here is a list of methods we must use at least once in our script. Other restrictions are that we cannot use any other methods than the ones given. The goal should be to make the most useful/interesting/fun script using all the methods. Before the Challenge begins we should all contribute a method or two we'd like to use.

note *methods are built in commands and can be accessed by going to help - plugin - rhinoscript (in folder called methods)*

Method List for Challenge #2 (Maximum of 10)

Rhino.AddSrfPoint (Sky)
Rhino.GetPointOnSurface (Sky)

Rhino.CurveLength (Yuki)
Rhino.ScaleObject (Yuki)
Rhino.DivideCurve (Yuki)

Solution #1 (Sky)

2006-12-31T01:18:00.000-08:00

I hope everyone's gotten started on your scripts. Here's my take on Challenge #1. Instead of starting with a panel I started with two curves. The user gets to input how many panels they want from 2 to 500 with the default value set at 10. To make this I used the tutorials along with the searching the method helpfiles. Working out the bugs with the nested arrays took a while. My original intent was to work in 2d and make ellipses that would span the two points on the curves with varying thickness. In the end I couldn't think of any other way than Rhino.command and that was giving me trouble.

Here's the script:

Option Explicit

Call Main()

Sub Main
Dim t
Dim strCurve1, strCurve2
Dim arrCurve1Points(), arrCurve2Points()

t = Rhino.GetInteger("Number of Divisions",10,2,500)

Do
strCurve1 = Rhino.GetObject("Select First Curve",4)
If IsCurve(strCurve1) Then Exit Do
Loop

Do
strCurve2 = Rhino.GetObject("Select Second Curve", 4)
If IsCurve(strCurve2) Then Exit Do
Loop

Call AddPoints(strCurve1, t, arrCurve1Points)
Call AddPoints(strCurve2, t, arrCurve2Points)

Dim r
Dim arrTemp

For r = 0 To t-1 'line30
arrTemp = Array(arrCurve1Points(r), arrCurve1Points(r+1), arrCurve2Points(r+1), arrCurve2Points(r))
Call Rhino.AddSrfPt(arrTemp)
'Call Rhino.AddLine(arrCurve1Points(r), arrCurve2Points(r))
Next

End Sub

'This function makes an array of points on the selected curve
Function AddPoints(StrCurve, t, ByRef CurvePoints)

Dim arrDomain, dblParam, arrPoint

arrDomain = Rhino.CurveDomain(StrCurve)
dblParam = arrDomain(1)/t

Dim i
For i = 0 To t
arrPoint = Rhino.EvaluateCurve(StrCurve, dblParam * i)
ReDim Preserve CurvePoints(i)
CurvePoints(i) = arrPoint
'Call Rhino.AddPoint (arrPoint)
Next

End Function

The Rhinoscript Challenge #2

2006-12-30T22:07:00.000-08:00

How about the following problem as a first challenge?

Instead of solving one problem with everybody, each of us come up to 3 to 5 RhinoScript Methods we can use, and write one or more scripts.

Like we started learning AutoCAD only with
"L" "Pl" "O" "Co" "Tr"
Those 5 RhinoScript Methods will be our basic tools. Then everything else will follow!

You can find RhinoScripting Methods in Rhino
Rhino Help/ plug-ins/ RhinoScript plug-in
Then open RhinoScript Methods

A list of VBscript functions can be found here:
http://www.w3schools.com/vbscript/vbscript_ref_functions.asp

newbie thoughts

2006-12-30T19:55:00.000-08:00

I finally started messing around with vbScript. It's like learning another language.
I was having a little trouble comprehending the McNeel Rhinoscript PDF's without having any scripting experiences.

I would recommend the PDF tutorial that Devyn gave us in our 3A.
Reconstructivism:
http://www.reconstructivism.net/PDF/Scripting_Handout.pdf

The Rhinoscript Challenge #1

2006-12-23T18:57:00.000-08:00

Given that we're all Rhinoscript beginners the challenge was set up so that we could all work on one problem and compare our solutions.

Everyone got mad at me for making the first challenge several months ago so to make this as fair of a process let's all make suggestions to what the first challenge should be.

Why we need to learn Rhinoscript: A manifesto of sorts

2006-12-23T18:16:00.000-08:00

Scripting in architecture, also known as computational design seems to be the current trend. So what's the big deal and why should we be a part of it?

In answering this question I'd like for us to come up with a new relevance for scripting in architecture, one that goes beyond form generation, or unique structure as we see at Sciarc. Already the division between scripting, parametric modeling, and B.I.M. software is going away to where they are all being connected into one big organizational software such as Generative Components, or Digital Project. This is very exciting in that never before has the designer played as much of a role as the designing software as they are now. Through scripting we are able to create the tools we want to use rather than picking from what the available software has to offer.

This is all good and as architects it will be necessary for us to know this stuff. My real beef is with what the prominent architects are doing with this new freedom. Around school what I see is a leaning toward complexity, complexity far beyond the capabilities of construction. What this means is that designs are visionary at best, mental masturbation at worst. You be the judge but it's safe to say that most of the projects proposed at Sciarc cannot be built tomorrow. This in as of itself is not a problem and I love to think in these big terms, but as a practical measure I want to also pursue scripting in terms of what it takes to get the job done. For those of you that saw the lecture by Roberto in 4A you know what I mean. Using scripting as a tool to simplify and automate the process. In the practicing environment this economy of speed and labour results in real savings, a way for us to actually make lots of money with our knowledge. This makes people that can script, i.e. us, a major component of any design & construction process.

I'd like to hear from those of you in Evan Douglas' studio to see your take on this stuff.

Here are several links to people already thinking about this.

The Yale Symposium <-- this is very interesting
The Gehry Method
A lecture that introduces concepts of BIM and Parametric Design

About the S.S.S.S.

2006-12-23T18:09:00.000-08:00

The S.S.S.S. was formed as a way to help all of us exchange information about things pertaining to scripting, in particular Rhinoscripting. This blog is open for all members to post, update and edit, not only things about Rhinoscript but anything remotely related should be brought up.

For clarity we should put our name in the label of the post. That way we'll know who to respond to about certain topics.