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__()