option explicit 										'DECLARATION OF VARIABLES & OBTAINING FROM USER CERTAIN "ARBITRARY" CONSTANTS
	dim centerCrv				'selected curve
	dim boundCrv1,boundCrv2		'boundary curves
	
	dim diam													'NUMBER OF TRELLIS DIAMONDS TO CREATE ALONG CURVES
	dim nodes													'POINTS ALONG CURVE
	dim h1,h2													'HEIGHT OF DIAMONDS ABOVE (h1) AND BELOW (h2) THE CURVE
	dim member_width											'FOR CUT SHEET
	dim memberLength											'FOR CUT SHEET
	
	dim pi : pi = 4 * atn(1)									'DECLARATION OF PI
	
	redim segments(diam)									'ALPHA LINES
	dim segmentsMirror										'TEMP EXTENSION OF ALPHA LINES
	redim ExtrusionTangent(diam)							'LINE CONNECTING EACH SEQUENTIAL NODE ON THE GIVEN CURVE
	redim segmentLengths(diam)								'DYNAMIC LENGTH OF LINE MEMBERS
	redim midpts(diam)										'MIDPOINTS OF EXTRUSIONTANGENT (BETWEEN EACH NODE)
	
	redim alpha(diam)										'ALPHA LINES (RENAMED)
	
	dim BetaCurveGNome										'BETA CURVE WITH ARBITRARY ANGLE (FIRST ONE)
	dim BetaCurveGnomeMirror								'TEMP EXTENSION OF betaGNomeMirror
	redim betaG(10)											'betaCurveGNome PROXY
	Redim beta(diam)										'betaCurve PROXY
	
	
	centerCrv = Rhino.getObject("Pick curve",4)				'USER SELECTS THE CURVE ABOUT WHICH TO BUILD THE TRELLIS 
	diam = Rhino.getInteger("Select number of division")	'USER INPUTS NUMBER OF TRELLIS CELLS 
	h1 = Rhino.getReal("Select Height 1 on Diamond.")		'USER INPUTS HEIGHT ABOVE CURVE OF TRELLIS CELLS
	h2 = Rhino.getReal("Select Height 2 on Diamond.")		'USER INPUTS HEIGHT BELOW CURVE OF TRELLIS CELLS
	
dim END_DECLARATION_OF_VARIABLES


'=====DRAWNODES=================================================================================================================

	Function DrawNodes(crv,div)							'PLACES POINTS ALONG THE USER SELECTED CURVE AT EQUAL INTERVALS
				nodes = Rhino.divideCurve(crv,div)				'DIVIDES THE INPUT CURVE "crv" INTO "div" EQUAL INTERVALS
				nodes = Rhino.AddPoints(nodes)					'CREATES THE GEOMETRY OF THE CURVES ALONG THE INTERVALS
				'Call Rhino.HideObjects(nodes)					'HIDES THE POINTS
			dim i												'THE COUNTER	
			For i=0 to div										
					nodes(i) = Rhino.pointCoordinates(nodes(i))	'CONVERTS THE POINTS INTO A SEQUENTIAL ARRAY OF 3D PT COORDINATES
				next
		End Function								
	
	Call DrawNodes(centerCrv,diam)


'=====PYTHAG=================================================================================================================

	function Pythag(b,h)									'FINDS LENGTHS AND ANGLES OF TRELLIS CELLS BASED ON THE BASE AND HEIGHT OF A GIVEN REGULAR BUT NON-RIGHT TRIANGLE
			
			dim height
			dim base
			dim L
			dim theta
			
			height = h										
			height = height^2
			rhino.print "height = " & height
			'rhino.sleep 500
			
			base = b
			base = base/2									'BASE DIVIDED BY TWO TO SPLIT THE TRIANGLE INTO A RIGHT TRIANGLE FOR ANALYSIS
			base = base^2
			rhino.print "base = " & base
			'rhino.sleep 500
			
			
			L = sqr(height + base)
			rhino.print "L = " & L
			'rhino.sleep 500
			
			Rhino.Print atn(h/(b/2))
			'Rhino.Sleep 1000
			
			theta = ((atn(h/(b/2))) * (180/pi))
			
		Pythag = Array(L,theta)								'MAKES pythag FUNCTION RETURN THE LENGTH OF THE HYPOTENUSE AND THE ANGLE ADJACENT TO THE ORIGINAL BASE
	
			
		End Function
	dim FUNCTION_PYTHAG_CALLED_WITHIN_OTHER_FUNCTIONS

'=====DIVIDECURVE=================================================================================================================

	function divideCurve(crv,div,r)						'PLACES INDEPENDANT ALPHA LINES ALONG CURVE
			dim i 
			dim x
				For i=0 to div-1								'
					Rhino.Print "Index is " & i									'BLAH BLAH BLAH
					'Rhino.Sleep 1000
					'Rhino.ClearCommandHistory
					
					Rhino.Print "Drawing Segment..."							'BLAH BLAH BLAH
					'Rhino.Sleep 1000
					Rhino.ClearCommandHistory
					
					segments(i) = Rhino.AddLine(nodes(i),nodes(i+1))			'DRAWS ALPHA LINES BETWEEN PTS ALONG INPUT CURVE
					segmentsMirror = Rhino.AddLine(nodes(i),nodes(i+1))			'CREATES THE (FUTURE) MIRRORED EXTENSION OF THE ALPHA LINE
					ExtrusionTangent(i) = Rhino.AddLine(nodes(i),nodes(i+1))	'CREATES THE LINE THAT WILL REMAIN CONNECTING THE NODES
					
					Rhino.Print "Placing MidPoint..."							'BLAH BLAH BLAH
					'Rhino.Sleep 1000
					Rhino.ClearCommandHistory
					
					midpts(i) = Rhino.CurveMidPoint(segments(i))				'PLACES PTS MIDWAY BTWN NODES ON INPUT CURVE
					call Rhino.AddPoint(midpts(i))								'ADDS THE ACTUAL PT GEOMETRIES ON THE CURVE
					Rhino.HideObject(Rhino.FirstObject)							'HIDES THE MIDPTS
					
					segmentLengths(i) = Rhino.CurveLength(segments(i))			'MEASURES THE LENGTH BTWN THE PTS
					
					Rhino.Print "By the way... The Segment Length was " & Segmentlengths(i)	'BLAH BLAH BLAH
					'Rhino.Sleep 2000
					Rhino.ClearCommandHistory
					
					Rhino.Print "Now sending to Pythag... Prepare for SQRT error!!!"		'BLAH BLAH BLAH
					'Rhino.Sleep 1000
					Rhino.ClearCommandHistory
					
					x = Pythag(segmentLengths(i),h1)																			'SENDS HYPOTENEUSE AND HEIGHT OF DIAMOND TRIANGLE TO 
					'x = array(6,30)																
					segments(i) = Rhino.ExtendCurveLength(segments(i),0,1,(1.5 * (Rhino.CurveLength(segments(i)))))				'EXTENDS THE LENGTH OF THE ALPHA
					segmentsMirror = Rhino.ExtendCurveLength(segmentsMirror,0,1,(1 * (Rhino.CurveLength(segments(i)))))			'EXTENDS THE ALPHA'S MIRRORED EXTENSION
					segments(i) = Rhino.RotateObject(segments(i),Rhino.CurveStartPoint(segments(i)),x(1))						'ROTATES THE ALPHA
					segmentsMirror = Rhino.RotateObject(segmentsMirror,Rhino.CurveStartPoint(segmentsMirror),180 + x(1))		'ROTATES THE ALPHA'S MIRRORED EXTENSION
					segments(i) = Rhino.JoinCurves(Array(segments(i),segmentsMirror),true)										'JOINS THE ALPHA & ITS MIRRORED EXTENSION
																																'...Rhino.Join RETURNS AN ARRAY CONTAINING ALL POSSIBLE JOINED SEGMENTS
					alpha(i) = segments(i)(0)																					'PUTS THE RIGHT JOIN INTO A SINGLE VARIABLE																			
				next
			End Function	
	
	call divideCurve(centerCrv,diam,memberLength)						
	

'=====DRAWBETACURVEGNOME=================================================================================================================
	
	Function DrawBetaCurveGNome() 							'CREATES FIRST BETA CURVE, WHICH IS THE ONLY ONE WHERE THE ANGLE IS ARBITRARY
		dim x
			x = Pythag((rhino.distance(nodes(0),nodes(1))),h2)						'PASSES BASE AND HYPOTENEUSE TO Pythag 
			
				'Rhino.ClearCommandHistory											'BLAH BLAH BLAH
				Rhino.Print "Base Distance: " &  rhino.distance(nodes(0),nodes(1))
				'Rhino.Sleep 1000
				'Rhino.ClearCommandHistory
			
				'Rhino.ClearCommandHistory											'BLAH BLAH BLAH
				Rhino.Print "Angle coming out of F_Pythag: " & x(1) 
				'Rhino.Sleep 1000
				'Rhino.ClearCommandHistory
			
				BetaCurveGnome = Rhino.AddLine(nodes(0),nodes(1))																				'DRAWS LINE FROM FIRST TO SECOND NODE
				BetaCurveGnomeMirror = Rhino.AddLine(nodes(0),nodes(1))																			'DRAWS THE SAME LINE AGAIN
				BetaCurveGnome = Rhino.ExtendCurveLength(BetaCurveGnome,0,1,(1.5 * (Rhino.CurveLength(BetaCurveGnome)))) 						'EXTENDS THE LENGTH OF THE FIRST LINE
				BetaCurveGnomeMirror = Rhino.ExtendCurveLength(BetaCurveGnomeMirror,0,1,(1.5 * (Rhino.CurveLength(BetaCurveGnomeMirror)))) 		'EXTENDS THE LENGTH OF THE SECOND LINE
				BetaCurveGnome = Rhino.RotateObject(BetaCurveGnome,Rhino.CurveStartPoint(BetaCurveGnome),(-1 * x(1))) 							'ROTATES THE FIRST LINE INTO POSITION
				BetaCurveGnomeMirror = Rhino.RotateObject(BetaCurveGnomeMirror,Rhino.CurveStartPoint(BetaCurveGnomeMirror),(-1 * x(1) + 180 ) ) 'ROTATES THE SECOND 180DEG MORE THAN THE FIRST, SO THAT IT EXTENDS THE FIRST
				BetaCurveGnome = Rhino.JoinCurves(Array(BetaCurveGnome,BetaCurveGnomeMirror),true) 												'JOINS THE TWO INTO ONE LARGE LINE 
				
				BetaG(0) = BetaCurveGNome(0)										'PLACES THE CURVE INTO A NEW ARRAY (SEE COMMENT OF RHINO.JOIN COMMAND ABOVE)									
				
		end function
	
	DrawBetaCurveGNome


'=====DRAWBETACURVES=================================================================================================================

	Function DrawBetaCurves(div)							'CREATES THE BETA (SECOND SET) CURVES WHERE THE ANGLE OF EACH DEPENDS ON THAT OF ITS SURROUNDING ANGLES
		'declare global variables here:
			dim servantAngle								'ANGLE RELATIVE TO THE INPUT CURVE OF EACH betaCuRVE
			redim betaCurve(div-1)							'THE betaCurve
			redim betaCurveMirror(div-1)					'THE betaCurve's EXTENSION
			dim otherAngles									'ARRAY CONTAINING THE ANGLES OF THE OTHER LINES AROUND THE SOON-TO-BE-CREATED betaCurve
			dim i											'LOOP COUNTER
				For i = 0 to div-2
					'define the angle:
						otherAngles = findAngles(i)						'GETS THE SURROUNDING ANGLES FROM THE otherAngles FUNCTION
						servantAngle = giveangle(otherAngles)			'SENDS THOSE ANGLES TO giveAngle FUNCTION TO GET THE BETA CURVES'S ANGLE
						Rhino.Print "Servant Angle = " & ServantAngle	'BLAH BLAH BLAH
					'create the line and its mirror:
						betaCurve(i) = Rhino.AddLine(nodes(i+1),nodes(i))			'ADDS A LINE FROM RIGHT TO LEFT FROM CURVE NODE TO PREVIOUS
						betaCurveMirror(i) = Rhino.AddLine(nodes(i+1),nodes(i))		'CREATES IT A NEW ONE OF THE SAME
						'Rhino.Sleep 500
					'extend the line and its mirror:
						betaCurve(i) = Rhino.ExtendCurveLength(BetaCurve(i),0,1,(1.5 * (Rhino.CurveLength(BetaCurve(i)))))						'EXTENDS THE FIRST CURVE		
						betaCurveMirror(i) = Rhino.ExtendCurveLength(BetaCurveMirror(i),0,1,(1.5 * (Rhino.CurveLength(BetaCurveMirror(i)))))	'EXTENDS THE SECOND
						'Rhino.Sleep 500
					'rotate the line and its mirror:
						betaCurveMirror(i) = Rhino.RotateObject(betaCurveMirror(i),Rhino.CurveStartPoint(betaCurveMirror(i)),servantangle)		'ROTATES THE FIRST BY THE ANGLE RETURNED FROM THE getAngle FUNCTION
						betaCurve(i) = Rhino.RotateObject(betaCurve(i),Rhino.CurveStartPoint(betaCurve(i)), servantAngle - 180)					'ROTATES THE SECOND BY 180DEG LESS THANTHE ANGLE RETURNED FROM THE getAngle FUNCTION
						'Rhino.Sleep 500
					'join the line and its mirror
						betaCurve(i) = Rhino.JoinCurves(Array(betaCurve(i),betaCurveMirror(i)),true)		'JOINS THE TWO CURVES
						beta(i) = betaCurve(i)(0)															'PLACES THE JOINED ANGLE INTO A NEW ARRAY (SEE EXPLANATION OF rhino.jOin FUNCTION ABOVE)
					Next
		end function
	
	DrawBetaCurves(diam)


'=====FINDANGLES=================================================================================================================

	function findangles(i)									'FINDS THE ALREADY GIVEN (ENVIRONMENT) ANGLES OF THE GIVEN DIAMOND CELL ALONG THE CURVE
		
		Dim Line1Pt1
		Dim Line1Pt2
		Dim Line2Pt1
		Dim Line2Pt2
		
		Dim AngleA, AngleB, AngleC, AngleD, AngleE				'THE SURROUNDING ANGLES
		
		'FIND ANGLE "c":
			Line1Pt1 = Rhino.CurveStartPoint(ExtrusionTangent(i))	'
			Line1Pt2 = Rhino.CurveEndPoint(ExtrusionTangent(i))
			Line2Pt1 = Rhino.CurveStartPoint(alpha(i))
			Line2Pt2 = Rhino.CurveEndPoint(alpha(i))
		
			AngleC = Rhino.Angle2(Array(Line1Pt1,Line1Pt2),Array(Line2Pt1,Line2Pt2))
				
		'FIND ANGLE "d": 
		If i = 0 Then														'FOR THE BETA CURVE FOLLOWING THE ALREADY DRAWN "BETA GNOME"
				Line1Pt1 = Rhino.CurveStartPoint(ExtrusionTangent(i))		'
				Line1Pt2 = Rhino.CurveEndPoint(ExtrusionTangent(i))
				Line2Pt1 = Rhino.CurveStartPoint(alpha(i))
				Line2Pt2 = Rhino.CurveStartPoint(alpha(i))
				
				AngleD = Rhino.Angle2((Array(Rhino.CurveStartPoint(ExtrusionTangent(i)),Rhino.CurveEndPoint(ExtrusionTangent(i)))),(Array(Rhino.CurveStartPoint(BetaG(0)),Rhino.CurveEndPoint(BetaG(0)))))
				
			Else																'FOR ALL OTHER SUBSEQUENT BETA CURVES
				Line1Pt1 = Rhino.CurveStartPoint(ExtrusionTangent(i))
				Line1Pt2 = Rhino.CurveEndPoint(ExtrusionTangent(i))
				Line2Pt1 = Rhino.CurveStartPoint(alpha(i))
				Line2Pt2 = Rhino.CurveStartPoint(alpha(i))
				
				AngleD = Rhino.Angle2((Array(Rhino.CurveStartPoint(ExtrusionTangent(i)),Rhino.CurveEndPoint(ExtrusionTangent(i)))),(Array(Rhino.CurveStartPoint(beta(i-1)),Rhino.CurveEndPoint(beta(i-1)))))
				
			End if
		
		'FIND ANGLE "a":
			Line1Pt1 = Rhino.CurveStartPoint(ExtrusionTangent(i))
			Line1Pt2 = Rhino.CurveEndPoint(ExtrusionTangent(i))
			Line2Pt1 = Rhino.CurveStartPoint(alpha(i+1))
			Line2Pt2 = Rhino.CurveEndPoint(alpha(i+1))
			
			AngleA = Rhino.Angle2(Array(Line1Pt1,Line1Pt2),Array(Line2Pt1,Line2Pt2))
		
		'FIND ANGLE "e":
			AngleE = 180 - (angleA(0) + angleD(0))
			
		
		'And the Results of the Function are.... 
		findangles = Array(AngleC(0),AngleD(0),AngleE,AngleA(0))
			
		'Let's see those angles!
		Rhino.Print "These are the measured angles: "
		Rhino.Print "AngleA = " & AngleA(0) 
		Rhino.Print "AngleD = " & AngleD(0) 
		Rhino.Print "AngleE = " & AngleE 
		Rhino.Print "AngleC = " & AngleC(0) 
		
		
	End Function


'=====GIVEANGLE=================================================================================================================

	function giveAngle(Array)								'RETURNS THE DEPENDANT ANGLE FOR ALL BUT THE FIRST BETA CURVE 
	
		dim bee,cee,dee,ee,aa
		dim A,B,C,D,E,F
		dim g, h
		
		cee = Array(0)
			Rhino.Print "Angle C Coming Out of Function = " & cee
		dee = Array(1)
			Rhino.Print "Angle D Coming Out of Function = " & dee
		ee = Array(2)
			Rhino.Print "Angle E Coming Out of Function = " & ee
		aa = Array(3)
			Rhino.Print "Angle A Coming Out of Function = " & aa
		
		A = cos(cee)
		B = sin(cee)
		C = (sin(ee)*sin(cee))/(sin(aa)-sin(dee))
		D = ((-1)*sin(ee))/(sin(aa)-sin(dee))
		E = A - D
		F = sqr((E^2)+(B^2))
		
		'bee = arcsin(C/F) - arcsin(B/F) - THE ACTUAL EQUATION... BUT IT NEEDS TO BE IN TERMS OF ARCTAN FOR VISUAL BASIC
			g = c/f																			
			h = b/f
			
			bee = ((atn(g/(sqr(1-(g^2)))))*(180/pi)) - ((atn(h/(sqr(1-(h^2)))))*(180/pi))
			bee = 180 - bee
			
			giveAngle = bee
			
			Rhino.Print "The mystery angle is.... " & giveAngle
		
	end function	



'=====FIN=====FIN=====FIN=====FIN=====FIN=====FIN=====FIN=====FIN=====FIN=====FIN=====FIN=====FIN=====FIN=====FIN=====FIN=====FIN