def offset_face(mesh, fkey, t): cent = mesh.face_centroid(fkey) vcords = mesh.face_coordinates(fkey, ordered=True) vkeys = mesh.face_vertices(fkey, ordered=True) pts = [] vecs = [] keys = [None] * len(vcords) for i, vcor in enumerate(vcords): vec1 = rs.VectorUnitize(rs.VectorCreate(vcords[i - 2], vcords[i - 1])) vec2 = rs.VectorUnitize(rs.VectorCreate(vcords[i], vcords[i - 1])) vec = rs.VectorAdd(vec1, vec2) vec = rs.VectorUnitize(vec) ang = rs.VectorAngle(vec, vec1) ang = math.radians(ang) l = t / math.sin(ang) vec = rs.VectorScale(vec, l) pt = rs.PointAdd(vcords[i - 1], vec) keys[i - 1] = mesh.add_vertex(x=pt[0], y=pt[1], z=pt[2]) for i, vkey in enumerate(vkeys): mesh.add_face([vkeys[i], keys[i], keys[i - 1], vkeys[i - 1]]) mesh.add_face(keys) del mesh.face[fkey]
def Moveobj(self, y_c_i): m_p = rs.CircleCenterPoint(self.circle_obj) y_p = rs.CircleCenterPoint(y_c_i.circle_obj) vector_m_y = rs.VectorCreate(y_p, m_p) vector_y_m = rs.VectorCreate(m_p, y_p) unit_vec_m_y = rs.VectorUnitize(vector_m_y) unit_vec_y_m = rs.VectorUnitize(vector_y_m) radius_1 = rs.CircleRadius(self.circle_obj) radius_2 = rs.CircleRadius(y_c_i.circle_obj) dis_1_2 = rs.Distance(m_p, y_p) dis = dis_1_2 - (radius_1 + radius_2) move_dis = (dis / 2) / 10 move_vec_m_y = rs.VectorScale(unit_vec_m_y, move_dis) move_vec_y_m = rs.VectorScale(unit_vec_y_m, move_dis) # status = self.getStatus(y_c_i) # # if(status == 1): # rs.MoveObject(self.circle_obj,move_vec_m_y) # rs.MoveObject(y_c_i.circle_obj,move_vec_y_m) # # if(status == 2): # rs.MoveObject(self.circle_obj,move_vec_y_m) # rs.MoveObject(y_c_i.circle_obj,move_vec_m_y) rs.MoveObject(self.circle_obj, move_vec_m_y) rs.MoveObject(y_c_i.circle_obj, move_vec_y_m)
def create_jig(self, list): jigs = [] for i in range(0, len(list), 2): domain = rs.CurveDomain(list[i]) start_point = rs.EvaluateCurve(list[i], domain[0]) end_point = rs.EvaluateCurve(list[i], domain[1]) start_plane = rs.PlaneFromNormal( start_point, rs.VectorUnitize(end_point - start_point)) end_plane = rs.PlaneFromNormal( end_point, rs.VectorUnitize(start_point - end_point)) start_curve_point = self.closest_intersection( rs.PlaneCurveIntersection(start_plane, self.curve_object), start_point) end_curve_point = self.closest_intersection( rs.PlaneCurveIntersection(end_plane, self.curve_object), end_point) start_vector = rs.VectorUnitize( rs.VectorCreate(start_point, start_curve_point)) end_vector = rs.VectorUnitize( rs.VectorCreate(end_point, end_curve_point)) start_vector_scale = rs.VectorScale(start_vector, -5) end_vector_scale = rs.VectorScale(end_vector, -5) start_square = self.create_square( rs.PointAdd(start_point, start_vector_scale), rs.PointAdd(end_point, end_vector_scale), start_vector) end_square = self.create_square( rs.PointAdd(end_point, end_vector_scale), rs.PointAdd(start_point, start_vector_scale), end_vector) jigs.append(self.create_jig_section(start_square, end_square)) return jigs
def mergeCoincidentLines(segments): """ removes coincident, consecutive segments input: List of GUIDs returns: List of GUIDs """ newSegments = [] i = 0 while i < len(segments): if (i < len(segments) - 1): #if coincident, delete both, add new. a = rs.VectorCreate(rs.CurveStartPoint(segments[i]), rs.CurveEndPoint(segments[i])) b = rs.VectorCreate(rs.CurveStartPoint(segments[i + 1]), rs.CurveEndPoint(segments[i + 1])) a = rs.VectorUnitize(a) b = rs.VectorUnitize(b) aAng = rs.VectorAngle(a, b) if (aAng < .00001): newLine = rs.AddLine(rs.CurveStartPoint(segments[i]), rs.CurveEndPoint(segments[i + 1])) rs.DeleteObject(segments[i]) rs.DeleteObject(segments[i + 1]) newSegments.append(newLine) i = i + 2 else: newSegments.append( segments[i]) #if not coincident, add to array i = i + 1 else: newSegments.append(segments[i]) #add last seg to array i = i + 1 return newSegments
def depressCrvs(crvs, paths, startPt, radius, sd): newCrvs = [] for i in range(len(crvs)): divPts = rs.DivideCurve(crvs[i], 100) if i < len(crvs) - 1: cntPt01 = centerCrv(crvs[i]) cntPt02 = centerCrv(crvs[i + 1]) horVec = rs.VectorCreate(cntPt01, cntPt02) for j in range(len(divPts)): path = rs.PointClosestObject(divPts[j], paths)[0] param = rs.CurveClosestPoint(path, divPts[j]) close = rs.EvaluateCurve(path, param) dist = rs.Distance(close, divPts[j]) tan = rs.CurveTangent(crvs[i], param) vec = [0, 0, -1] #rs.VectorCrossProduct(horVec,tan) testVec = rs.VectorCreate(cntPt01, divPts[j]) if rs.VectorDotProduct(vec, testVec) < 0: rs.VectorReverse(vec) vec = rs.VectorUnitize(vec) border = 1 entry = 1 if j > len(divPts) / 2: border = rs.Distance(rs.CurveEndPoint(crvs[i]), divPts[j]) else: border = rs.Distance(rs.CurveStartPoint(crvs[i]), divPts[j]) if border < sd * 3: border = border / (sd * 3) entryDist = rs.Distance(startPt, divPts[j]) if entryDist < sd * 10: entry = entryDist / (sd * 10) if dist < sd * 2: val = radius * (bellCrv(dist, sd)) divPts[j] = rs.PointAdd(divPts[j], vec * val * border * entry) newCrvs.append(rs.AddCurve(divPts)) return divPts
def ellipse(self, xheight, yheight, direction): centerPoint = rs.AddPoint(self.point) if direction == 'right': centerPoint = rs.MoveObject( centerPoint, rs.VectorScale(rs.VectorCreate([1, 0, 0], [0, 0, 0]), xheight / 2)) if direction == 'left': centerPoint = rs.MoveObject( centerPoint, rs.VectorScale(rs.VectorCreate([-1, 0, 0], [0, 0, 0]), xheight / 2)) if direction == 'top': centerPoint = rs.MoveObject( centerPoint, rs.VectorScale(rs.VectorCreate([0, 1, 0], [0, 0, 0]), xheight / 2)) if direction == 'bottom': centerPoint = rs.MoveObject( centerPoint, rs.VectorScale(rs.VectorCreate([0, -1, 0], [0, 0, 0]), xheight / 2)) newEllipse = rs.AddCircle(centerPoint, xheight / 2) yScaleFactor = yheight / xheight rs.ScaleObject(newEllipse, self.point, [1, yScaleFactor, 0]) rs.DeleteObject(centerPoint) return (newEllipse)
def transformMatrix(): obj_ids = rs.GetObjects("Select object(s) from which to create matrix", 0, True, True) if obj_ids is None: return box = rs.BoundingBox(obj_ids) if not isinstance(box, list): return origin = rs.PointDivide(rs.PointAdd(box[0], box[6]), 2) endpt = rs.GetPoint("To point") newpt = [1, 1, 1] translation1 = rs.VectorCreate(endpt, newpt) translation2 = rs.VectorCreate(translation1, origin) copied_obj_ids = rs.CopyObjects(obj_ids, translation2) for obj in copied_obj_ids: matrix = [] degrees = 90.0 # Some angle radians = math.radians(degrees) c = math.cos(radians) s = math.sin(radians) matrix.append([c, -s, 0, 0]) matrix.append([s, c, 0, 0]) matrix.append([0, 0, 1, 0]) matrix.append([0, 0, 0, 1]) pprint.pprint(matrix) rs.ScaleObject(obj, newpt, [3, 1, -9]) plane = rs.ViewCPlane() pprint.pprint(plane) rs.RotateObject(obj, newpt, uniform(0, 360), plane.XAxis) rs.RotateObject(obj, newpt, uniform(0, 360), plane.YAxis) rs.RotateObject(obj, newpt, uniform(0, 360), plane.ZAxis)
def duplicateAndRotate(): obj_ids = rs.GetObjects("Select object(s) to duplicate and rotate", 0, True, True) if obj_ids is None: return box = rs.BoundingBox(obj_ids) if not isinstance(box, list): return origin = rs.PointDivide(rs.PointAdd(box[0], box[6]), 2) endpt = rs.GetPoint("To point") ndups = rs.GetInteger("Number of duplications") maxd = rs.GetReal("Max Distance") translation = rs.VectorCreate(endpt, origin) for i in range(0, ndups, 1): xr = random() if random() < 0.5 else -1 * random() yr = random() if random() < 0.5 else -1 * random() zr = random() if random() < 0.5 else -1 * random() newpt = [xr * maxd, yr * maxd, zr * maxd] translation1 = rs.VectorCreate(endpt, newpt) translation2 = rs.VectorCreate(translation1, origin) copied_obj_ids = rs.CopyObjects(obj_ids, translation2) xyp = rs.WorldXYPlane() rs.RotateObjects(copied_obj_ids, newpt, random() * 360, xyp[0]) rs.RotateObjects(copied_obj_ids, newpt, random() * 360, xyp[1]) rs.RotateObjects(copied_obj_ids, newpt, random() * 360, xyp[2])
def move2PtInside(self, p0, p1, scale0=0.2, scale1=None): if scale1 is None: scale1 = scale0 mp = [ (p0[0] + p1[0]) / 2, (p0[1] + p1[1]) / 2, (p0[2] + p1[2]) / 2, ] v0 = rs.VectorCreate(mp, p0) v1 = rs.VectorCreate(mp, p1) v0 = rs.VectorScale(rs.VectorUnitize(v0), scale0) v1 = rs.VectorScale(rs.VectorUnitize(v1), scale1) v0 = rs.PointAdd(p0, v0) v1 = rs.PointAdd(p1, v1) return v0, v1 #eof #eoc
def __init__(self, _startPoint): self.location = _startPoint self.x = random.uniform(-2,2) self.y = random.uniform(-2,2) self.z = random.uniform(10,20) self.velocity = rs.VectorCreate([self.x,self.y,self.z],[0,0,0]) self.acceleration = rs.VectorCreate([0,0,0],[0,0,0])
def DropBlockToSurface(): try: obj = rs.GetObjects('Select Objects', rs.filter.curve | rs.filter.instance | rs.filter.mesh | rs.filter.surface | rs.filter.subd | rs.filter.light | rs.filter.polysurface, preselect=True) srf = rs.GetObject('Select Surface') if obj: if srf: rs.EnableRedraw(False) # Check if srf is a mesh, if so convert to Nurb isMesh = rs.IsMesh(srf) if isMesh == True: srf = rs.MeshToNurb(srf) # For each object send test rays up and down in Z coord # Move each object to the ray test that hits a srf for i in obj: bndBox = rs.BoundingBox(i) pt1 = bndBox[0] pt2 = bndBox[2] crv = rs.AddLine(pt1, pt2) if crv: midcrv = rs.CurveMidPoint(crv) rs.DeleteObject(crv) ray_pt_up = rs.ShootRay(srf, midcrv, (0, 0, 1), reflections=1) ray_pt_down = rs.ShootRay(srf, midcrv, (0, 0, -1), reflections=1) if ray_pt_up: vector = rs.VectorCreate(ray_pt_up[1], midcrv) rs.MoveObject(i, vector) if ray_pt_down: vector = rs.VectorCreate(ray_pt_down[1], midcrv) rs.MoveObject(i, vector) # deleate any created srf if isMesh == True: rs.DeleteObject(srf) rs.EnableRedraw(True) except: print("Failed to execute") rs.EnableRedraw(True) return
def tol(self): # tolerance angle check function vect1 = rs.VectorCreate(self.points[-2], self.points[-3]) vect2 = rs.VectorCreate(self.points[-1], self.points[-2]) norm = self.mesh.NormalAt(self.mpos) alpha = g.Vector3d.VectorAngle(vect1, vect2) if alpha > self.antol and rs.VectorDotProduct( norm, g.Vector3d(0., 0., 1.) ) < 0: # if the angle between 2 moves larger than tolerance self.state = 'off' # the waterflow is off the facade
def __init__(self): self.location = [0, 0, 0] self.velocity = [0, .1, .1] self.acceleration = [0, 0, 0] self.basePoint = [0, 0, 0] self.vecAcceleration = rs.VectorCreate(self.acceleration, self.basePoint) self.vecVelocity = rs.VectorCreate(self.velocity, self.basePoint) self.mass = 2000 self.g = 0.4
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 attractor(self, mag): attrPt = rs.VectorCreate((-800,-700,0) , (0,0,0)) steer = rs.VectorCreate( (0,0,0) , (0,0,0) ) diff = rs.VectorSubtract( attrPt, self.p ) diff = rs.VectorUnitize(diff) steer = rs.VectorAdd(steer , diff) steer = rs.VectorScale(steer, mag) self.a = rs.VectorAdd(self.a, steer)
def setup(): global pts pts = [] global lns lns = [] numAG = 36 for i in range(numAG): p = rs.VectorCreate( rs.AddPoint( 100*math.cos(i*2*math.pi/numAG), 100*math.sin(i*2*math.pi/numAG),0) , rs.AddPoint(0,0,0) ) v = rs.VectorCreate( rs.AddPoint( -randint(2,18),-randint(18,36),randint(-2,26) ) , rs.AddPoint(0,0,0 ) ) run1 = Runner(p, v) pts.append(run1)
def toldrop(self): vect1 = rs.VectorCreate(self.points[-2], self.points[-3]) vect2 = rs.VectorCreate(self.points[-1], self.points[-2]) norm = self.mpos.Mesh.NormalAt(self.mpos) alpha = g.Vector3d.VectorAngle(vect1, vect2) if alpha > self.antol and rs.VectorDotProduct( norm, g.Vector3d(0., 0., 1.) ) < 0: # if the angle between 2 moves larger than tolerance self.state = 'off' # the waterflow is off the facade alpha = g.Vector3d.VectorAngle(vect2, g.Vector3d(0., 0., -1.)) if alpha > (math.pi / 2 - self.androp) and rs.VectorDotProduct( norm, g.Vector3d(0., 0., 1.)) < 0: # if the geometry is too steep self.state = 'off' # the waterflow is off the facade
def Cremona1(no, nomes, Linhas, countPF, dicPF): ptos1 = [] dicUp = {} for i in range(countPF): if i == 0: Spt = dicPF[nomes[i]].PointAt(0) Ept = dicPF[nomes[i]].PointAt(1) else: if i == 1: cond1 = rs.PointCompare(dicPF[nomes[i - 1]].PointAt(0), dicPF[nomes[i]].PointAt(1), Tol) cond2 = rs.PointCompare(dicPF[nomes[i - 1]].PointAt(0), dicPF[nomes[i]].PointAt(0), Tol) if cond1 or cond2: pAux3 = Spt Spt = Ept Ept = pAux3 if rs.PointCompare(Ept, dicPF[nomes[i]].PointAt(1), Tol): ptAux1 = dicPF[nomes[i]].PointAt(1) ptAux2 = dicPF[nomes[i]].PointAt(0) else: ptAux1 = dicPF[nomes[i]].PointAt(0) ptAux2 = dicPF[nomes[i]].PointAt(1) Ept += (ptAux2 - ptAux1) F1 = rs.AddLine(Ept, Spt) #verificar o paralelismo entre F1 no PF e FG vec1 = rs.VectorCreate(rs.CurveEndPoint(Linhas[-1]), rs.CurveStartPoint(Linhas[-1])) vec2 = rs.VectorCreate(Spt, Ept) if rs.IsVectorParallelTo(vec2, vec1): print '______Paralelismo______' #colovcando F1 no dicionario do PF dicUp[nomes[-1]] = rs.coerceline(F1) #-cargas e nomenclatura #teste de tração e compressão sin1 = TraComp(no, F1, rs.coerceline(Linhas[-1]), nomes[-1]) #valores das cargas carga1 = rs.CurveLength(F1) * sin1 / Escala #teste de tensão admissivel cor1 = teste_elemento(nomes[-1], carga1, Linhas[-1]) #nomenclatura do FG txt1 = nomes[-1] + ' = ' + str('%.2f' % carga1) pt1 = rs.coerceline(Linhas[-1]).PointAt(.5) ptos1 += [pt1, txt1, cor1] #nomenclatura do PF pt1 = rs.coerceline(F1).PointAt(.5) txt1 = nomes[-1] ptos1 += [pt1, txt1, cor1] return dicUp, ptos1
def addExtlHandrail(self): hdrlPtList = [] hdrlEndPt = rs.AddPoint(rs.CurveEndPoint(self.guideCrv)) hdrlStPt = rs.AddPoint(rs.CurveStartPoint(self.guideCrv)) hdrlVec = rs.VectorCreate(hdrlStPt, hdrlEndPt) projHdrlVec = rs.VectorUnitize([hdrlVec.X, hdrlVec.Y, 0]) #Top Extension topExtEndPt = rs.CopyObject(hdrlEndPt) rs.MoveObject(topExtEndPt, rs.VectorScale(projHdrlVec, -.305)) hdrlPtList.append(topExtEndPt) #Btm Extension (tread length method) btmExtEndPt = rs.CopyObject(hdrlStPt) btmPtExtTemp = rs.CopyObject(hdrlStPt) btmVertPtExtTemp = rs.CopyObject(hdrlStPt) rs.MoveObject(btmPtExtTemp, hdrlVec) angledLineTemp = rs.AddLine(hdrlStPt, btmPtExtTemp) rs.MoveObject(btmVertPtExtTemp, [0, 0, -1]) vertLineTemp = rs.AddLine(btmVertPtExtTemp, hdrlStPt) rs.MoveObject(vertLineTemp, rs.VectorScale(projHdrlVec, self.treadLength)) btmExtPt = rs.LineLineIntersection(angledLineTemp, vertLineTemp)[0] hdrlPtList.append(hdrlEndPt) hdrlPtList.append(btmExtPt) #Make and move hdrlCrv = rs.AddPolyline(hdrlPtList) rs.MoveObject(hdrlCrv, [0, 0, self.hdrlHeight]) #move away from wall widthVec = rs.VectorUnitize( rs.VectorCreate(rs.CurveEndPoint(self.stairWidthEdge), rs.CurveStartPoint(self.stairWidthEdge))) rs.MoveObject(hdrlCrv, rs.VectorScale(widthVec, self.hdrlDistFromWall)) #cleanup rs.DeleteObject(topExtEndPt) rs.DeleteObject(hdrlEndPt) rs.DeleteObject(hdrlStPt) rs.DeleteObject(btmPtExtTemp) rs.DeleteObject(btmVertPtExtTemp) rs.DeleteObject(angledLineTemp) rs.DeleteObject(vertLineTemp) rs.DeleteObject(btmExtEndPt) return hdrlCrv
def genIntPoly(self, poly): cen=rs.CurveAreaCentroid(poly)[0] pts=rs.CurvePoints(poly) a=[(pts[0][0]+pts[1][0])/2,(pts[0][1]+pts[1][1])/2,0] b=[(pts[0][0]+pts[3][0])/2,(pts[0][1]+pts[3][1])/2,0] vec1=rs.VectorScale(rs.VectorUnitize(rs.VectorCreate(cen,a)),self.d0/2) vec2=rs.VectorScale(rs.VectorUnitize(rs.VectorCreate(cen,b)),self.d1/2) p=rs.PointAdd(cen,vec1) q=rs.PointAdd(cen,-vec1) r=rs.PointAdd(p,vec2) u=rs.PointAdd(p,-vec2) t=rs.PointAdd(q,vec2) s=rs.PointAdd(q,-vec2) poly=rs.AddPolyline([r,u,s,t,r]) self.req_poly.append(poly)
def AngleABC(a, b, c): """AngleABC(a, b, c). As if A-B-C made a polyline, measures the clockwise angle parameters: a (pt): first pt b (pt): elbow between A and C. c (pt): last point returns: clockwise angle in degrees """ vec1 = rs.VectorCreate(a, b) vec2 = rs.VectorCreate(c, b) inner = rs.VectorAngle(vec1, vec2) det = vec1[0]*vec2[1]-vec1[1]*vec2[0] if det<0: return inner else: return 360-inner
def angAttractor(attPt,testPt,baseVec,baseAng,thres,max): compare=rs.VectorCreate(attPt,testPt) editAng=rs.VectorAngle(baseVec,compare) ang=baseAng+(1-setAttractor(attPt,testPt,thres,0))*(editAng-baseAng) if ang>max: ang=max return ang
def goto(self, x, y, z=0): prevPos = rs.PointCoordinates(self.point) movement = rs.VectorCreate([x, y, z], prevPos) rs.MoveObject(self.point, movement) currentPos = rs.PointCoordinates(self.point) line = self.drawLine(prevPos, currentPos) return line
def deflect(self, deflectPoint): """ Takes a Point as an input. Point creates a force field. The turtle deflects around the point """ defPtPos = rs.PointCoordinates(deflectPoint) prevPos = rs.PointCoordinates(self.point) deflectVector1 = rs.VectorScale(rs.VectorCreate(prevPos, defPtPos), 0.33) deflectVector2 = -deflectVector1 deflectVector90_1 = rs.VectorScale( rs.VectorRotate(deflectVector1, 90, [0, 0, 1]), 0.33) deflectVector90_2 = -deflectVector90_1 deflectVectorList = [ deflectVector1, deflectVector2, deflectVector90_1, deflectVector90_2 ] forcePts = [] for i in deflectVectorList: newPt = rs.CopyObject(deflectPoint) rs.MoveObject(newPt, i) forcePts.append(newPt) gotoPt = rs.PointCoordinates(forcePts[0]) self.goto(gotoPt[0], gotoPt[1]) rs.AddArc3Pt(forcePts[0], forcePts[1], forcePts[2]) rs.AddArc3Pt(forcePts[1], forcePts[0], forcePts[3]) rs.DeleteObjects(forcePts)
def squareSect(crv,width,height): sections=[] divPts=rs.DivideCurve(crv,10) keep=True for i in range(len(divPts)): param=rs.CurveClosestPoint(crv,divPts[i]) tan=rs.CurveTangent(crv,param) plane=rs.PlaneFromNormal(divPts[i],tan) sect=rs.AddRectangle(plane,width,height) cpt=rs.CurveAreaCentroid(sect)[0] vec=rs.VectorCreate(divPts[i],cpt) sect=rs.MoveObject(sect,vec) if i>0: if testAlign(sect,oldSect)==False: sect=align(sect,oldSect,divPts[i],tan) oldSect=sect sections.append(sect) branch=rs.AddLoftSrf(sections,None,None,2,0,0,False) edges=rs.DuplicateEdgeCurves(branch) if width>height: testVal=height else: testVal=width for i in range(len(edges)): testPt=rs.CurveMidPoint(edges[i]) for j in range(len(edges)): param=rs.CurveClosestPoint(edges[j],testPt) pt=rs.EvaluateCurve(edges[j],param) if rs.Distance(pt,testPt)<testVal/6: keep=False rs.DeleteObjects(sections) rs.DeleteObjects(edges) return branch
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 update(self): self.vecAcceleration = rs.VectorCreate(self.acceleration, self.basePoint) self.vecVelocity = rs.VectorAdd(self.vecVelocity, self.vecAcceleration) self.location = rs.PointAdd(self.location, self.vecVelocity) self.acceleration = rs.VectorScale(self.acceleration, 0)
def ChangeLineLength(obj, fixedLengths): rhobj = rs.coerceline(obj) stPt = rhobj.PointAt(0) vec = rs.VectorCreate(rhobj.PointAt(1), stPt) vec.Unitize() newEndPt = stPt.Add(stPt, vec*fixedLengths[0]) return rc.Geometry.Line(stPt, newEndPt)
def getExtendedCrv(self, crvList, dist=50, layer_height=2.5, vecMul=.66): segmentCount = int(math.floor(dist / layer_height)) - 1 tmpList = [] fullHeight = [] for i in range(len(crvList)): extendedCrv = rs.ExtendCurveLength(crvList[i], 2, 0, dist) fullHeight.append(extendedCrv) domStart, domEnd = rs.CurveDomain(extendedCrv) trimmedCrv = rs.TrimCurve(extendedCrv, (domStart, 0)) tmpList.append(trimmedCrv) tmp = [] ###Smooth Curves### for i in range(len(tmpList)): bottomPt = rs.CurveEndPoint(tmpList[i]) zVec = rs.VectorAdd((0, 0, 0), (0, 0, dist)) topPt = rs.CopyObject(bottomPt, zVec) line = rs.AddLine(bottomPt, topPt) crvPts = rs.DivideCurve(tmpList[i], segmentCount) LinePts = rs.DivideCurve(line, segmentCount) for i in range(segmentCount): tmpVec = rs.VectorCreate(LinePts[segmentCount - i - 1], crvPts[i]) tmpVec = rs.VectorScale(tmpVec, vecMul) rs.MoveObject(crvPts[i], tmpVec) tmp.append(rs.AddInterpCurve(crvPts)) result = [] for crv in tmp: crvLen = rs.CurveLength(crv) if crvLen < dist: tmpExt = dist - crvLen result.append(rs.ExtendCurveLength(crv, 2, 0, tmpExt)) else: result.append(rs.CopyObject(crv)) return result
def __init__(self, pos=[0, 0, 0], heading=[1, 0, 0]): self.heading = heading self.point = rs.AddPoint(pos) self.draw = True pointPos = rs.PointCoordinates(self.point) self.direction = rs.VectorCreate(heading, pointPos) self.lines = []