def closest_intersection(self, intersections, point):
closest_intersection = intersections[0][1]
length = rs.VectorLength(rs.VectorCreate(point, closest_intersection))
for i in range(0, len(intersections), 1):
new_length = rs.VectorLength(
rs.VectorCreate(point, intersections[i][1]))
if length > new_length:
length = new_length
closest_intersection = intersections[i][1]
return closest_intersection
def innerangle(a, b, radians=False):
dp = dotprod(a, b)
len_1 = rs.VectorLength(a)
len_2 = rs.VectorLength(b)
#print len_1
#print len_2
innerangle = math.acos(dp / (len_1 * len_2))
if radians == False:
innerangle = math.degrees(innerangle)
return innerangle
def offsetPoints(pList, startPt, endPt):
pointList = []
sideVector = rs.VectorCreate(endPt, startPt)
pointSpacing = (rs.VectorLength(sideVector) / len(pList))
gapVector = rs.VectorUnitize(sideVector)
gapVector = rs.VectorScale(gapVector, pointSpacing)
for i in range(0, len(pList)):
scaledVector = rs.VectorScale(gapVector, i)
pointMove = rs.VectorAdd(startPt, scaledVector)
offsetPoint = rs.VectorAdd(pointMove,
pList[i] * rs.VectorLength(sideVector))
point = (0, 0, 0)
movedPoint = rs.PointAdd(point, offsetPoint)
pointList.append(movedPoint)
return pointList
def vector_sum(lines, preview=False):
vector_list = []
total_time = 0
total_length = 0
last_feed = 0
for i in range(len(lines)):
point_a = lines[i][:3]
if i == len(lines) - 1: break
point_b = lines[i + 1][:3]
vector = rs.AddLine(point_a, point_b) if preview else rs.VectorCreate(
point_a, point_b)
if preview:
rs.ObjectLayer(vector, LAYER_NAME)
rs.ObjectColor(vector, color_palette["cut"])
vector_list.append(vector)
if len(lines[i]) == 4:
feed = lines[i][-1]
last_feed = feed
vector_length = rs.CurveLength(vector) if preview else rs.VectorLength(
vector)
total_length += vector_length
total_time += (vector_length) / last_feed
return vector_list, round(total_time, 2), round(total_length, 2)
def FitSurface(srf_id, samples):
surf_points = rs.SurfacePoints(srf_id)
G = rs.SurfaceEditPoints(srf_id, True, True)
N = GrevilleNormals(srf_id)
S = ConvertToUVW(srf_id, samples)
Forces = [(0, 0, 0) for pt in surf_points]
Factors = [0.0 for pt in surf_points]
proximity = 0.0
translation = 0.0
for i in range(len(S)):
proximity += abs(S[i][2])
for j in range(len(surf_points)):
local_dist = (S[i][0] - G[j][0])**2 + (S[i][1] - G[j][1])**2
if local_dist < 0.01: local_dist = 0.01
local_factor = 1 / local_dist
local_force = rs.VectorScale(N[j], local_factor * S[i][2])
Forces[j] = rs.VectorAdd(Forces(j), local_force)
Factors[j] += local_factor
Forces = DivideVectorArray(Forces, Factors)
for i in range(len(surf_points)):
surf_points[i] = rs.PointAdd(surf_points[i], Forces[i])
translation += rs.VectorLength(Forces[i])
srf_N = rs.SurfacePointCount(srf_id)
srf_K = rs.SurfaceKnots(srf_id)
srf_W = rs.SurfaceWeights(srf_id)
srf_D = (rs.SurfaceDegree(srf_id, 0), rs.SurfaceDegree(srf_id, 1))
return rs.AddNurbsSurface(srf_N, P, srf_K[0], srf_K[1], srf_D, srf_W)
def FromEdgetoPlane():
PointPlane = []
CurveIdList = []
Brep = []
edges = rs.GetEdgeCurves()
if edges:
for edgeinfo in edges:
Brep.append(edgeinfo[1])
CurveIdList.append(edgeinfo[0])
for CurveId in CurveIdList:
if rs.IsCircle(CurveId):
Pt = rs.CircleCenterPoint(CurveId)
Normal = rs.CurveNormal(CurveId)
LenghtNormal = rs.VectorLength(Normal)
LenghNormal = self.m_foronumero.Text
LenghNormal = int(LenghNormal)
Normal = (LenghNormal * Normal[0], LenghNormal * Normal[1],
LenghNormal * Normal[2])
PtStill = rs.AddPoint(Pt)
Ptmoved = rs.MoveObject(Pt, Normal)
Ptmoved = rs.coerce3dpoint(Ptmoved)
PtStill = rs.coerce3dpoint(PtStill)
PointPlane.append([
PtStill[0], PtStill[1], PtStill[2], Normal[0],
Normal[1], Normal[2]
])
#PointPlane.append([Ptmoved[0],Ptmoved[1],Ptmoved[2],Normal[0],Normal[1],Normal[2]])
return (PointPlane, Brep)
def __init__(self, MESH, PT, VEC, ANG):
self.mesh = MESH
self.start = PT
self.vec = VEC
self.len = rs.VectorLength(self.vec)
self.drawn = []
self.ang = ANG
self.branches = []
def ptRun(self):
self.v = rs.VectorAdd(self.v, self.a)
v = rs.VectorLength(self.v)
if v > 15:
self.v = rs.VectorScale(rs.VectorUnitize(self.v), 15)
self.p = rs.VectorAdd(self.p, self.v)
self.a = rs.VectorCreate( (0,0,0),(0,0,0) )
self.ptList.append(self.p)
def assignBlockToPanel(obj):
"""
Assigns block containing a base surface to a surface with the matching name.
Block, base surface, and target surface must all have the same name.
input: target surface (with name)
returns: None
"""
allBlockNames = rs.BlockNames()
for eachBlockName in allBlockNames:
if rs.ObjectName(obj) == eachBlockName:
blockName = eachBlockName
print "Matching Block Found"
objBasePt = rs.SurfaceEditPoints(obj)[0]
objYPt = rs.SurfaceEditPoints(obj)[1]
objXPt = rs.SurfaceEditPoints(obj)[2]
objXVec = rs.VectorCreate(objXPt, objBasePt)
objXLength = rs.VectorLength(objXVec)
objYLength = rs.Distance(objBasePt, objYPt)
blockObjs = rs.BlockObjects(blockName)
for blockObj in blockObjs:
if rs.ObjectName(blockObj) == blockName:
print "Contains base plane"
if rs.IsSurface(blockObj):
blockBasePt = rs.SurfaceEditPoints(blockObj)[0]
blockYPt = rs.SurfaceEditPoints(blockObj)[1]
blockXPt = rs.SurfaceEditPoints(blockObj)[2]
blockXVec = rs.VectorCreate(blockXPt, blockBasePt)
rotAngle = rs.VectorAngle(objXVec, blockXVec)
blockXLength = rs.VectorLength(blockXVec)
blockYLength = rs.VectorLength(
rs.VectorCreate(blockYPt, blockBasePt))
xScale = objXLength / blockXLength
yScale = objYLength / blockYLength
newScale = [yScale, xScale, 1]
rs.InsertBlock(blockName,
objBasePt,
scale=newScale,
angle_degrees=rotAngle)
break
else:
print "Error: Base plane was not a surface"
def drawEdge(self,nodes):
p1 = self.posVec
p2 = nodes[self.parentID].posVec
self.geom.append(rs.AddLine(p1,p2))
pNormal = rs.VectorSubtract(p2,p1)
height = rs.VectorLength(pNormal)
plane = rs.PlaneFromNormal(p1,pNormal)
radius = self.radius
self.geom.append(rs.AddCylinder(plane,height,radius))
def cul_move_vector(self, other_sphere_list):
"""
引力と斥力の設計が謎。
:return vector, Boolean(動かすかそうでないか？)
"""
# fixed_flagがTrueの場合は動かさない。 --> 着目している球体である場合
if self.fixed_flag is True:
composited_vector = None
return composited_vector, False
vectors = []
for other_sphere in other_sphere_list:
if self == other_sphere:
continue
# 両者の半径を比較し、ベクトルの方向を決定する。引力か斥力か。
if (other_sphere.radius + self.radius) >= distance(
self.center_coordinate, other_sphere.center_coordinate):
# 斥力
vector = [(self.center_coordinate[0] -
other_sphere.center_coordinate[0]),
(self.center_coordinate[1] -
other_sphere.center_coordinate[1]),
(self.center_coordinate[2] -
other_sphere.center_coordinate[2])]
vector = vector_scale(vector, 2)
vectors.append(vector)
else:
# 隣接関係をもつ個体の間のみ引力を働かさせる。
if other_sphere.id is None:
pass
else:
if other_sphere.id in self.neighbor_id:
# 引力
vector = [(other_sphere.center_coordinate[0] -
self.center_coordinate[0]),
(other_sphere.center_coordinate[1] -
self.center_coordinate[1]),
(other_sphere.center_coordinate[2] -
self.center_coordinate[2])]
vectors.append(vector)
# self.sphereとother_sphereとの相対ベクトルをすべて合成する。
composited_vector = vector_composite(vectors)
# 合成ベクトルが0ならば、自身は動かさない。
# if vector_composite[0] == 0 and vector_composite[1] == 0 and vector_composite[2] == 0:
if rs.VectorLength(composited_vector) == 0:
return composited_vector, False
else:
return vector_unit(composited_vector), True
def throwNode(nodes,speed,stickRange,passParams,resizeThreshold):
boundRadius = passParams[0]
bGeom = passParams[1]
#sFactor = passParams[2]
#print passParams[2]
#assumes time steps of 1
startPos = getBoundaryPos(boundRadius);
endPos = getBoundaryPos(boundRadius);
direction = rs.VectorSubtract(endPos,startPos)
direction = rs.VectorUnitize(direction)
vel = rs.VectorScale(direction,speed);
currentPos = rs.VectorAdd(startPos,vel)
previewGeom = []
isTravelling = True
while(isTravelling):
scriptcontext.escape_test() #hit escape to quit NOT WORKING
time.sleep(0.01*10**-7)
for o in previewGeom: rs.DeleteObjects(o)
dist = rs.VectorLength(currentPos) #distance to origin
#check if particle went out of bounds
if(dist>boundRadius):
isTravelling = False
else:
previewGeom.append(drawPos(currentPos,stickRange))
for i in range(len(nodes)):
n = nodes[i]
if(inStickRange(currentPos,n,stickRange)):
#GOT STUCK! add a new node at that position
newNode = node(currentPos,i,.08) #parent is idx of node stuck too
newNode.increaseRadius(.01, nodes)
nodes.append(newNode)
#rNodes.append(rs.AddPoint(currentPos))
if(math.fabs(boundRadius-dist) <= resizeThreshold):
#print "boundRadius should resize"
rs.DeleteObjects(bGeom)
boundRadius += resizeThreshold/2 #arbitrary
bGeom = rs.AddCircle([0,0,0],boundRadius)
passParams[0] = boundRadius
passParams[1] = bGeom
isTravelling = False
for o in previewGeom: rs.DeleteObjects(o)
break
currentPos = rs.VectorAdd(currentPos,vel)
Rhino.RhinoApp.Wait()
return passParams
def AddArcDir(ptStart, ptEnd, vecDir):
vecBase = rs.PointSubtract(ptEnd, ptStart)
if rs.VectorLength(vecBase)==0.0: return
if rs.IsVectorParallelTo(vecBase, vecDir): return
vecBase = rs.VectorUnitize(vecBase)
vecDir = rs.VectorUnitize(vecDir)
vecBisector = rs.VectorAdd(vecDir, vecBase)
vecBisector = rs.VectorUnitize(vecBisector)
dotProd = rs.VectorDotProduct(vecBisector, vecDir)
midLength = (0.5*rs.Distance(ptStart, ptEnd))/dotProd
vecBisector = rs.VectorScale(vecBisector, midLength)
return rs.AddArc3Pt(ptStart, rs.PointAdd(ptStart, vecBisector), ptEnd)
def DrawArcSED():
ptA = rs.GetPoint("Start of arc")
if not ptA: return
ptB = rs.GetPoint("End of arc")
if not ptB: return
ptD = rs.GetPoint("Direction of arc at start", ptA)
if not ptD: return
vecD = rs.PointSubtract(ptD, ptA)
if rs.VectorLength(vecD) == 0.0: return
AddArcDir(ptA, ptB, vecD)
def grow(self):
newBranches = []
if len(self.branches) == 0:
self.startBranch()
for i in range(len(self.branches)):
self.pullBranch(self.branches[i])
axis01 = self.findAxis(self.branches[i].end01)
axis02 = self.findAxis(self.branches[i].end02)
if rs.VectorAngle(self.branches[i].axis, axis01) < 60:
v = rs.VectorCreate(self.branches[i].end01,
self.branches[i].start)
v = rs.VectorScale(v, self.length / rs.VectorLength(v))
newBranches.append(
branch(self.branches[i].end01, v, self.ang, axis01))
if rs.VectorAngle(self.branches[i].axis, axis02) < 60:
v = rs.VectorCreate(self.branches[i].end02,
self.branches[i].start)
v = rs.VectorScale(v, self.length / rs.VectorLength(v))
newBranches.append(
branch(self.branches[i].end02, v, self.ang, axis02))
self.branches = []
self.branches.extend(newBranches)
return self.branches
def __update__(self, other, b1, b2):
self.counted = True
other.counted = True
self.vector = rs.VectorCreate(BUILDINGS[b2].coordinates,
BUILDINGS[b1].coordinates)
other.vector = -self.vector
self.distance = rs.VectorLength(self.vector)
other.distance = self.distance
self.unit = self.vector / self.distance
other.unit = -self.unit
def surfaceIrradiance_fixed(towerIn, sunIn, intensityIn):
sunUnit = rs.VectorUnitize(sunIn)
for floor in range(len(towerIn)):
numPoints = len(towerIn[floor])
for i in range(numPoints):
p1 = towerIn[floor][i]
p2 = towerIn[floor][(i + 1) % numPoints]
v1 = rs.VectorSubtract(p2, p1)
v2 = [0, 0, 1]
n = rs.VectorCrossProduct(v1, v2)
if rs.VectorLength(n) > rs.UnitAbsoluteTolerance(10**(-3), True):
cosTheta = rs.VectorDotProduct(rs.VectorUnitize(n), sunUnit)
if cosTheta > 0:
factor = intensityIn * cosTheta / 200 #200 is just to shorten the vector to something manageable
v = rs.VectorScale(n, factor)
AddVector(v, p1)
def addArc(startPt, endPt, vecDir):
vecBase = rs.PointSubtract(endPt, startPt)
if rs.VectorLength(vecBase) == 0.0:
return
if rs.IsVectorParallelTo(vecBase, vecDir):
return
vecBase = rs.VectorUnitize(vecBase)
vecDir = rs.VectorUnitize(vecDir)
vecBisector = rs.VectorAdd(vecDir, vecBase)
vecBisector = rs.VectorUnitize(vecBisector)
midlength = (0.5*rs.Distance(startPt, endPt)) / (rs.VectorDotProduct(vecBisector, vecDir))
vecBisector = rs.VectorScale(vecBisector, midlength)
return rs.AddArc3Pt(startPt, endPt, rs.PointAdd(startPt, vecBisector))
def addArcDiv(ptStart, ptEnd, vecDir):
vecBase = rs.PointSubtract(ptEnd, ptStart)
# error handling
if rs.VectorLength(vecBase) == 0.0: return
if rs.IsVectorParallelTo(vecBase, vecDir): return
vecBase = rs.VectorUnitize(
vecBase
) # normalize vector == force magnitude to 1 to just compare direction
vecDir = rs.VectorUnitize(vecDir)
vecBisector = rs.VectorAdd(vecDir, vecBase)
vecBisector = rs.VectorUnitize(vecBisector)
dotProd = rs.VectorDotProduct(vecBisector, vecDir)
midLength = (0.5 * rs.Distance(ptStart, ptEnd)) / dotProd
vecBisector = rs.VectorScale(vecBisector, midLength)
return rs.AddArc3Pt(ptStart, rs.PointAdd(pt.Start, vecBisector), ptEnd)
def Rugosity_horizontal_v1(crv_id):
pts = rs.DivideCurveEquidistant(crv_id, link_length,
create_points=False,
return_points=True)
# find the rugosity length (horizontal/vertical dependent)
rugosity_start = pts[0]
rugosity_end = pts[len(pts)-1]
rugosity_numerator = abs(rugosity_end.X - rugosity_start.X)
# find the chain length (not horizontal/vertical dependent)
rugosity_denominator = 0
for i in range(1, len(pts)):
extra = rs.VectorLength(rs.VectorCreate(pts[i], pts[i-1]))
rugosity_denominator = rugosity_denominator + extra
rugosity = rugosity_numerator / rugosity_denominator
return rugosity
def GetUphillVectorFromPlane(obj, u = 0, v = 0):
"""Gets the uphill vector from a surface, with optional u, v
Parameters:
surface (surface): surface to test
u (float)[optional]: u parameter
v (float)[optional]: v parameter
Returns:
vector(guid, ...): identifiers of surfaces created on success
"""
rhobj = rs.coercesurface(obj)
frame = rhobj.FrameAt(u,v)[1]
pt0 = rhobj.PointAt(u,v)
pt1 = rc.Geometry.Point3d.Add(pt0, rc.Geometry.Vector3d(0,0,10))
projPoint = frame.ClosestPoint(pt1)
vec = rs.VectorCreate(projPoint, pt0)
if rs.VectorLength(vec) < rs.UnitAbsoluteTolerance():
uphillVec = rc.Geometry.Vector3d(0,0,1)
else:
uphillVec = rs.VectorUnitize(vec)
return uphillVec
def uniform_centers_normals(radii, edge_length, midpt, perim_dist_min):
"""Generates centers and normals such that no two perimeter curves are closer than perim_dist_min."""
origin, hel = rh.Geometry.Point3d(0, 0, 0), edge_length / 2.
perim_ids, centers, unorms, tries = [], [], [], 0
for r in radii:
iterations = 0
while 1:
if iterations > len(radii) * 300:
raise RuntimeError(
'exceeded max iterations to find permissible center-normal combination'
)
theta, phi = 2.0 * math.pi * random.random(), (
math.acos(2.0 * random.random() - 1.0) + math.pi) / 2.
pt_unit_sphere = rh.Geometry.Point3d(
math.cos(theta) * math.sin(phi),
math.sin(theta) * math.sin(phi), math.cos(phi))
unorm = rs.VectorCreate(pt_unit_sphere, origin)
cxyz = [
midpt[xyz] + (random.random() - 0.5) * 2. * hel
for xyz in range(3)
]
center = rh.Geometry.Point3d(cxyz[0], cxyz[1], cxyz[2])
plane = rs.PlaneFromNormal(center, unorm)
perim, perim_id = fracture_perimeter(plane, r)
if perim_ids:
res = rs.CurveClosestObject(perim_id, perim_ids)
if res:
mindistv = rs.VectorCreate(res[1], res[2])
if rs.VectorLength(mindistv) > perim_dist_min:
break
else:
break
rs.DeleteObject(perim_id)
iterations += 1
perim_ids.append(perim_id)
centers.append(center)
unorms.append(unorm)
rs.DeleteObjects(perim_ids)
return centers, unorms
def avoid(self):
if obstacle:
avoid = [0, 0, 0]
count = 0
sumradar = 0
averadar = 0
for i in range(len(obstacle)):
judge = rs.MeshClosestPoint(obstacle[i], self.pos)
radar = rs.Distance(self.pos, judge[0])
vecradar = rs.VectorCreate(self.pos, judge[0])
# print radar
if radar < 0.5:
self.pos = rs.VectorSubtract(self.posP, self.pos)
vecradar = rs.VectorScale(vecradar, 2)
if radar < 3 and radar > 0.5:
avoid = rs.VectorAdd(avoid, judge[0])
sumradar += radar
count += 1
vecradar = rs.VectorScale(vecradar, 0.5)
obstacle[i] = rs.MoveObject(obstacle[i], vecradar)
if count != 0:
aveavoid = rs.VectorScale(avoid, 1 / count)
averadar = sumradar / count
else:
aveavoid = self.pos
averadar = averadar + 24
vec1 = rs.VectorCreate(self.pos, aveavoid)
vec1 = rs.VectorScale(vec1, ((averadar + 24) / averadar)**2)
if rs.VectorLength(vec1) > 1:
vec1 = vectorlimit(vec1, 1)
# n = rnd.randint(0,10)
# vec1 = rs.VectorRotate (vec1,-60,[0,0,1])
else:
vec1 = [0, 0, 0]
return vec1
def meshExtrudeCrvToPattern(crv, facadeType, totalHeightVect):
crv = rs.CopyObject(crv)
global TYPECOLORS
totalLength = rs.VectorLength(totalHeightVect)
restLength = totalLength
length = facadeType.heights[0]
counter = 0
meshes = []
def genRow(crv, length, facadeType, counter):
patterIndex = counter % len(facadeType.pattern)
extrudeVect = Rhino.Geometry.Vector3d(0, 0, length)
pts = divCrvByLengths(crv, facadeType.widths)
colorRow = genMeshColorRow(pts, facadeType.pattern[patterIndex],
TYPECOLORS)
m = meshExtrudePtsByVect(pts, extrudeVect, colorRow)
return m
if length > 0:
while restLength - length > 0:
m = genRow(crv, length, facadeType, counter)
meshes.append(m)
#prepare for next round
counter += 1
restLength -= length
if counter > 20: break
crv = rs.MoveObject(crv, Rhino.Geometry.Vector3d(0, 0, length))
length = facadeType.heights[counter % len(facadeType.heights)]
#print('length:',length)
#print('rest length:',restLength)
if length == -1: break
if restLength > 0:
finalLength = restLength
#print('final length:',finalLength)
m = genRow(crv, finalLength, facadeType, counter)
meshes.append(m)
rs.DeleteObject(crv)
return rs.JoinMeshes(meshes, True)
def FromEdgetoPlane():
PointPlane = []
CurveIdList = []
Brep = []
edges = rs.GetEdgeCurves()
if edges:
for edgeinfo in edges:
Brep.append(edgeinfo[1])
CurveIdList.append(edgeinfo[0])
# print CurveIdList
for CurveId in CurveIdList:
if rs.IsCircle(CurveId):
# print "Sono un cerchio"
Pt = rs.CircleCenterPoint(CurveId)
Normal = rs.CurveNormal(CurveId)
LenghtNormal = rs.VectorLength(Normal)
LenghNormal = rs.GetString("give me the lengh of the hole", "100")
LenghNormal = int(LenghNormal)
Normal = (LenghNormal * Normal[0], LenghNormal * Normal[1],
LenghNormal * Normal[2])
print Normal
PtStill = rs.AddPoint(Pt)
Ptmoved = rs.MoveObject(Pt, Normal)
Ptmoved = rs.coerce3dpoint(Ptmoved)
PtStill = rs.coerce3dpoint(PtStill)
# print Ptmoved
# print PtStill
PointPlane.append([
PtStill[0], PtStill[1], PtStill[2], Normal[0], Normal[1],
Normal[2]
])
#PointPlane.append([Ptmoved[0],Ptmoved[1],Ptmoved[2],Normal[0],Normal[1],Normal[2]])
return (PointPlane, Brep)
def throwNode(nodes,speed,stickRange,rNodes,boundRadius):
#assumes time steps of 1
startPos = getBoundaryPos(boundRadius);
endPos = getBoundaryPos(boundRadius);
direction = rs.VectorSubtract(endPos,startPos)
direction = rs.VectorUnitize(direction)
vel = rs.VectorScale(direction,speed);
currentPos = rs.VectorAdd(startPos,vel)
previewGeom = []
isTravelling = True
while(isTravelling):
time.sleep(0.0001)
for o in previewGeom: rs.DeleteObjects(o)
dist = rs.VectorLength(currentPos) #distance to origin
#check if particle went out of bounds
if(dist>boundRadius):
isTravelling = False
else:
previewGeom.append(drawPos(currentPos,stickRange))
for i in range(len(nodes)):
n = nodes[i]
if(inStickRange(currentPos,n,stickRange)):
#GOT STUCK! add a new node at that position
newNode = node(currentPos,i,1) #parent is idx of node stuck to, r = 1
rs.AddLine(n.posVec,currentPos)
nodes.append(newNode)
#rNodes.append(rs.AddPoint(currentPos))
isTravelling = False
for o in previewGeom: rs.DeleteObjects(o)
break
currentPos = rs.VectorAdd(currentPos,vel)
Rhino.RhinoApp.Wait()
sub_vect = (vect) / 3
#draw line between origin (og_) pts and cloud of random pts
init_dst = rs.AddLine(pt, clos_pt)
line_set1.append(init_dst)
#move cloud of random pts according to outcome of sub_vect
new_pt = rs.MoveObject(pt, sub_vect)
new_pt_coord = rs.PointCoordinates(new_pt)
cloud_pts.append(new_pt)
#set parameter for spheres and boxes
#run through clos_pt, if it's x
string_l = rs.ObjectLayer(index)
print string_l
div_num = 3
vector_length = rs.VectorLength(sub_vect) / div_num
#adding spheres to the new lines
#rs.AddSphere(new_pt,vector_length)
#adding boxes to the new lines
rs.AddBox(\
[(new_pt_coord),\
(new_pt_coord[0]+vector_length,new_pt_coord[1],new_pt_coord[2]),\
(new_pt_coord[0]+vector_length,new_pt_coord[1]+vector_length,new_pt_coord[2]),\
(new_pt_coord[0],new_pt_coord[1]+vector_length,new_pt_coord[2]),\
(new_pt_coord[0],new_pt_coord[1],new_pt_coord[2]+vector_length),\
(new_pt_coord[0]+vector_length,new_pt_coord[1],new_pt_coord[2]+vector_length),\
(new_pt_coord[0]+vector_length,new_pt_coord[1]+vector_length,new_pt_coord[2]+vector_length),\
(new_pt_coord[0],new_pt_coord[1]+vector_length,new_pt_coord[2]+vector_length)])
#Function to draw a vector_A
def AddVector(base, vec):
rs.AddPoint(base)
tip = rs.PointAdd(base, vec)
line = rs.AddLine(base, tip)
rs.CurveArrows(line, 2)
#Base_point and direction of an original vector
base_point = (20, 10, 5)
vector_A = (10, 10, 10)
AddVector(base_point, vector_A)
#Create vector
vector_B = rs.VectorCreate((25, 16, -2), base_point)
AddVector(base_point, vector_B)
#Vector add
vector_C = rs.VectorAdd(vector_A, vector_B)
AddVector(base_point, vector_C)
#vector dot product
s = rs.VectorDotProduct(vector_A, vector_B)
print s
#Vector cross product
vector_D = rs.VectorCrossProduct(vector_A, vector_B)
AddVector(base_point, vector_D)
length_D = rs.VectorLength(vector_D)
print length_D
results.append(extrusion)
if buildScaffolding:
scaffoldBase = rs.AddRectangle(
(-scaffoldSide / 2, -scaffoldSide / 2, 0), scaffoldSide,
scaffoldSide)
scaffold = rs.ExtrudeCurveStraight(scaffoldBase, (0, 0, 0),
(0, 0, (layers - 1) * layerHeight))
rs.CapPlanarHoles(scaffold)
rs.DeleteObject(scaffoldBase)
results.append(scaffold)
if complete:
rs.DeleteObjects(curves)
rs.AddObjectsToGroup(results, rs.AddGroup())
return results
else:
rs.AddObjectsToGroup(curves, rs.AddGroup())
return curves
for i in range(icicleCount):
translation = (random.gauss(0,
placement[0]), random.gauss(0,
placement[1]), 0)
distance = rs.VectorLength(translation)
layers = int(map(distance, 0, placement[0], layerRange[0], layerRange[1]))
maxScale = map(i, 0, placement[0], maxScaleRange[0], maxScaleRange[1])
objects = piece(layers, maxScale)
rs.MoveObject(objects, translation)
# rs.RotateObject(objects, (0, 0, 0), 60 * i)
migrationprogress = round(
3.0 * float(iteration) / float(iterations_per_SCHEDUAL_Slot) -
2, 2)
print 'iNR:', iNR, 'slot simulation progress:', migrationprogress, '%'
for user in USERS:
departurelocation = BUILDINGS[user.location]
oldpod = user.pod
newpod = user.nextpod
if user.relocating:
if oldpod.departed == False:
vector = rs.VectorCreate(
BUILDINGS[user.nextlocation].coordinates,
user.coordinates)
if migrationprogress > 2.0 / 3.0 * (
1.0 - rs.VectorLength(vector) / dis):
newpod.__fly__(leftiterations)
oldpod.departed = True
departurelocation.__release_from__(oldpod)
if user.podtravel == True:
oldpod.__fly__(leftiterations)
user.__follow__(oldpod, leftiterations)
print 'user', user.first_name, user.last_name, 'left his object'
else:
oldpod.__stay__()
avaliblePODS[oldpod.activity].append(oldpod)
user.__go_to__(newpod.destination,
leftiterations)
else:
newpod.__fly__(leftiterations)
oldpod.__stay__()
