def orientObjAlongPolyPts(obj, pts, basePoint=(0, 0, 0), baseVect=(0, 1, 0)): print('orient obj along poly points') up = (0, 0, 1) generatedObjects = [] for i in range(0, len(pts) - 1): if i < (len(pts) - 2): p0 = pts[i] p1 = pts[i + 1] p2 = pts[i + 2] v1 = rs.VectorUnitize(p1 - p0) v2 = rs.VectorUnitize(p2 - p1) n1 = rs.VectorCrossProduct(v1, up) n2 = rs.VectorCrossProduct(v2, up) mid = rs.VectorAdd(n1, n2) n = rs.VectorUnitize(mid) else: p0 = pts[i] p1 = pts[i + 1] v1 = rs.VectorUnitize(p1 - p0) n = rs.VectorCrossProduct(v1, up) rs.AddLine(p1, p1 + n) a = rs.VectorAngle((0, 1, 0), n) gen = rs.OrientObject(obj, [basePoint, basePoint + baseVect], [p1, p1 + n], 1) generatedObjects.append(gen) #g=rs.AddGroup() #groupObjects=rs.AddObjectsToGroup(generatedObjects,g) return generatedObjects
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 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 meshSwipPolyAlongPoly(profile, rail): profile = rs.CopyObject(profile) pts = rs.CurveEditPoints(rail) baseVect = Rhino.Geometry.Point3d(0, 1, 0) meshes = [] for i in range(0, len(pts) - 2): p0 = pts[i] p1 = pts[i + 1] p2 = pts[i + 2] v1 = rs.VectorUnitize(p1 - p0) v2 = rs.VectorUnitize(p2 - p1) rv1 = rs.VectorUnitize(p0 - p1) vect = p1 - p0 mid = rs.VectorUnitize((rv1 + v2) / 2) np = p1 + mid up = p1 + Rhino.Geometry.Point3d(0, 0, 1) pln = rs.PlaneFromPoints(p1, np, up) mesh, pjpts = meshExtrudePolyToByVectPlane(profile, vect, pln) meshes.append(mesh) rs.DeleteObject(profile) profile = rs.AddPolyline(pjpts) mesh = rs.JoinMeshes(meshes, True) rs.DeleteObject(profile) return mesh
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 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 LinearDimJoin(object_id0, object_id1): annotation_object0 = sc.doc.Objects.Find( object_id0 ) dim0 = annotation_object0.Geometry annotation_object1 = sc.doc.Objects.Find( object_id1 ) dim1 = annotation_object1.Geometry if isinstance(dim0, Rhino.Geometry.LinearDimension) and isinstance(dim1, Rhino.Geometry.LinearDimension): _, extensionLine01End, extensionLine02End, arrowhead01End, arrowhead02End, dimlinepoint0, _ = dim0.Get3dPoints() _, extensionLine11End, extensionLine12End, arrowhead11End, arrowhead12End, dimlinepoint1, _ = dim1.Get3dPoints() line0 = geo.Line(arrowhead01End, arrowhead02End) direct0=rs.VectorUnitize(line0.Direction) line1 = geo.Line(arrowhead11End, arrowhead12End) direct1=rs.VectorUnitize(line1.Direction) if rs.IsVectorParallelTo(direct0, direct1 ) != 0 : param0 = line0.ClosestParameter(line1.From) param1 = line0.ClosestParameter(line1.To) paramDictionary = { 0.0 : extensionLine01End, 1.0 : extensionLine02End, param0 : extensionLine11End, param1 : extensionLine12End } extensionLineList = [] for key in sorted(paramDictionary.keys()): extensionLineList.append(paramDictionary[key]) distance0 = line0.DistanceTo(extensionLineList[0],False) distance1 = line1.DistanceTo(extensionLineList[0],False) if distance0 > distance1: rs.AddLinearDimension(dim0.Plane, extensionLineList[0], extensionLineList[len(extensionLineList)-1], dimlinepoint0 ) else: rs.AddLinearDimension(dim1.Plane, extensionLineList[0], extensionLineList[len(extensionLineList)-1], dimlinepoint1 ) rs.DeleteObject(object_id0) rs.DeleteObject(object_id1)
def accumulationCheck(self): d12 = self.points[-1].DistanceTo(self.points[-2]) norm0 = rs.VectorUnitize(self.mesh.NormalAt(self.mpos)) # special check when the water drop stops if d12 == 0.: self.pop() self.edgeCheck(norm0) norm1 = rs.VectorUnitize( self.mesh.NormalAt(self.mesh.ClosestMeshPoint(self.points[-2], 0.))) # check accumulation conditions (distance, height and stepsize (in order)) if self.points[-1].Z > self.points[-2].Z or d12 < self.stepsize / 20.: # verify which case : stuck on an edge or in a basin if norm0.Z > 0.99 or (norm1 != norm0 and norm1.Z >= 0 and norm0.Z >= 0): # the water drop is in a basin self.pop() self.state = 'finished' criticalPoints.append(self.pos) else: # the water drop is on an edge self.pop() self.state = 'off' edgePoints.append(self.pos)
def randomDir(self, point, plane): # check if the drop has hit a flat srf and return a random direction if so if point == self.pos and self.count < 3: random = r.uniform(0., 2* math.pi) vect = g.Vector3d(1., 0., 0.) * self.stepsize vect.Rotate(random, plane.ZAxis) point = self.mesh.ClosestPoint(self.pos + vect) return point # check if the drop is riding verticaly if rs.VectorUnitize(plane.XAxis).Z > -.5: return point random = r.randint(0, 9) # 3 choices : downward, or two side shifting if random < 8: return point else: YAxis = rs.VectorUnitize(rs.VectorUnitize(plane.YAxis)) ratio = 0.18 if random == 8: # first direction is chosen point = point + YAxis * self.stepsize/5. return self.mesh.ClosestPoint(point) if random == 9: # first direction is chosen point = point - YAxis * self.stepsize/5. return self.mesh.ClosestPoint(point)
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 GetSensorPosAndNormal(centerPoint, lineVerts): assert (len(lineVerts) == 2) if equalWithAbsErrorVec(centerPoint, lineVerts[0]): return centerPoint, rs.VectorUnitize(lineVerts[1] - lineVerts[0]) elif equalWithAbsErrorVec(centerPoint, lineVerts[1]): return centerPoint, rs.VectorUnitize(lineVerts[0] - lineVerts[1]) else: return None, None
def GetSolidAngle(a,b,c): a = rs.VectorUnitize(a) b = rs.VectorUnitize(b) c = rs.VectorUnitize(c) numer = rs.VectorDotProduct(rs.VectorCrossProduct(a,b),c) denom = 1 + rs.VectorDotProduct(a,b) + rs.VectorDotProduct(b,c) + rs.VectorDotProduct(c,a) angle = 2*math.atan2(numer, denom) return abs(angle)
def divEQCrvToPolyAD(crv,w=900,adjacentCrvs=None): outpoly=PolyAD() crvLen=rs.CurveLength(crv) numDiv=crvLen/w width=crvLen/round(numDiv) pts=rs.DivideCurve(crv,numDiv,False,True) #add to output outpoly.points=pts sharedNormals=[None,None] if adjacentCrvs is not None: sharedNormals=findSharedbisecNormals(crv,adjacentCrvs) for i in range(0,len(pts)-2): up=(0,0,1) # direct direct_end # (p0)-v1->(p1)-v2->(p2) # |n_start |n |n_end # V V V p0=pts[i] p1=pts[i+1] p2=pts[i+2] v1=rs.VectorUnitize(p1-p0) v2=rs.VectorUnitize(p2-p1) n1=rs.VectorCrossProduct(v1,up) n2=rs.VectorCrossProduct(v2,up) mid=rs.VectorAdd(n1,n2) n=rs.VectorUnitize(mid) direct=p1-p0 #add to output outpoly.directions.append(direct) if i==0: if sharedNormals[0] is not None: n_start=sharedNormals[0] else: n_start=rs.VectorCrossProduct(v1,up) outpoly.normals.append(n_start) #add to output outpoly.normals.append(n) if i==len(pts)-3: if sharedNormals[1] is not None: n_end=sharedNormals[1] else: n_end=rs.VectorCrossProduct(v2,up) outpoly.normals.append(n_end) direct_end=p2-p1 outpoly.directions.append(direct_end) return outpoly
def Orthogonal(vecIn): vecIn = rs.VectorUnitize(vecIn) # Pick any vector which isn't aligned to the input otherVec = rs.coerce3dvector((1.0, 0.0, 0.0)) if abs(rs.VectorDotProduct(vecIn, otherVec)) > 0.99: otherVec = rs.coerce3dvector((0.0, 1.0, 0.0)) # Create a unit length orthogonal to both the other one, and the original one return rs.VectorUnitize(rs.VectorCrossProduct(vecIn, otherVec))
def BasisFromDirection(direction): b2 = rs.VectorUnitize(direction) for b in range(3): b0 = UnitVector(b) # At least one unit vector must meet this condition inner = rs.VectorDotProduct(b0, b2) if -0.5 < inner <= 0.5: b0 = rs.VectorUnitize(b0 - b2 * inner) b1 = rs.VectorCrossProduct(b2, b0) return [b0, b1, b2] return UnitBasis()
def getDirtCoef(self): vectDown = rs.VectorCreate(self.points[-1], self.points[-2]) if vectDown.Length == 0.: print self.count alpha = math.acos(-rs.VectorUnitize(vectDown).Z) * 180/math.pi norm = rs.VectorUnitize(self.mesh.NormalAt(self.mpos)) if alpha <= 90 and norm.Z > 0: coef = 1-(1-(alpha/90)**2)**.5 return coef if alpha <= 90 and norm.Z <= 0.: return 0 if alpha > 90: return 1
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 offset_vector(self, point, cross_section_index, point_index): modulo = len(self.point_lists[cross_section_index]) closest_point = rs.CurveClosestPoint( self.cross_sections[cross_section_index], point) crv = rs.CurveCurvature(self.cross_sections[cross_section_index], closest_point) crvTangent = crv[1] crvPerp = rs.VectorUnitize(crv[4]) unit_vector = rs.VectorUnitize(crvTangent) return [ rs.VectorScale(unit_vector, 0.205), rs.VectorReverse(rs.VectorCrossProduct(crvTangent, crvPerp)) ]
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 blendcorners(polyline_id, radius): # Fillets the corners of a polyline (from the McNeel website) if not polyline_id: return vertices = rs.PolylineVertices(polyline_id) if not vertices: return if radius is None: return between = lambda a, b: (a + b) / 2.0 newverts = [] for i in range(len(vertices) - 1): a = vertices[i] b = vertices[i + 1] segmentlength = rs.Distance(a, b) vec_segment = rs.PointSubtract(b, a) vec_segment = rs.VectorUnitize(vec_segment) if radius < (0.5 * segmentlength): vec_segment = rs.VectorScale(vec_segment, radius) else: vec_segment = rs.VectorScale(vec_segment, 0.5 * segmentlength) w1 = rs.PointAdd(a, vec_segment) w2 = rs.PointSubtract(b, vec_segment) newverts.append(a) newverts.append(between(a, w1)) newverts.append(w1) newverts.append(between(w1, w2)) newverts.append(w2) newverts.append(between(w2, b)) newverts.append(vertices[len(vertices) - 1]) CrvId = rs.AddCurve(newverts, 5) rs.DeleteObject(polyline_id) return CrvId
def CheckRunLengths(runs): lengthComment = '' for i, run in enumerate(runs): dist = rs.Distance(rs.CurveStartPoint(run[0]), rs.CurveStartPoint(run[1])) if dist > 360: lengthComment += 'Run {} requires a landing\n'.format(i + 1) templine = rs.AddLine(rs.CurveStartPoint(run[0]), rs.CurveStartPoint(run[1])) mdPt = rs.CurveMidPoint(templine) vec = rs.VectorCreate(mdPt, rs.CurveStartPoint(run[0])) landingCenter = rs.CopyObject(run[0], vec) vec = rs.VectorScale(rs.VectorUnitize(vec), 30) upperLine = rs.CopyObject(landingCenter, vec) vec = rs.VectorReverse(vec) lowerLine = rs.MoveObject(landingCenter, vec) rs.DeleteObject(templine) run.insert(1, lowerLine) run.insert(2, upperLine) flatList = [] for item in runs: for each in item: flatList.append(each) pairs = [] for i in range(0, len(flatList), 2): pairs.append([flatList[i], flatList[i + 1]]) return pairs, lengthComment
def RandomPointInCone(origin, direction, minDistance, maxDistance, maxAngle): vecTwig = rs.VectorUnitize(direction) vecTwig = rs.VectorScale(vecTwig, minDistance + random.random()*(maxDistance-minDistance)) MutationPlane = rs.PlaneFromNormal((0,0,0), vecTwig) vecTwig = rs.VectorRotate(vecTwig, random.random()*maxAngle, MutationPlane[1]) vecTwig = rs.VectorRotate(vecTwig, random.random()*360, direction) return rs.PointAdd(origin, vecTwig)
def drawQuadTab(self, island): pntA, pntD = self.get_coordinates(island) vecA = geom.Vector3d(pntA) vecD = geom.Vector3d(pntD) alpha = self.tabAngles[0] beta = self.tabAngles[1] lenI = self.tabWidth / math.sin(alpha * math.pi / 180.0) lenJ = self.tabWidth / math.sin(beta * math.pi / 180.0) if not self.tabOnLeft: alpha = -1 * alpha beta = -1 * beta vec = vecD.Subtract(vecD, vecA) vecUnit = rs.VectorUnitize(vec) vecI = rs.VectorScale(vecUnit, lenI) vecJ = rs.VectorScale(vecUnit, -lenJ) vecI = rs.VectorRotate(vecI, alpha, [0, 0, 1]) vecJ = rs.VectorRotate(vecJ, -beta, [0, 0, 1]) vecB = vecA + vecI vecC = vecD + vecJ pntB = geom.Point3d(vecB) pntC = geom.Point3d(vecC) points = [pntA, pntB, pntC, pntD] polyGuid = rs.AddPolyline(points) self.geom.append(polyGuid) return polyGuid
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 update(self): print('update') #delete last generated objects try: rs.DeleteObjects(self.generatedObjs) self.generatedObjs = [] except: print('exception in delete generated object') divWidth = 600 crv = self.baseCrv if not rs.IsObject(crv): print('crv is not an object') return if not rs.IsPolyline(crv): pts = rs.DivideCurveEquidistant(crv, divWidth) rail = rs.AddPolyline(pts) else: rail = rs.CopyObject(crv) pts = rs.CurveEditPoints(rail) if len(pts) < 3: print('too little points') return #find vectors to move and orient the profile vect = pts[1] - pts[0] vect = rs.VectorUnitize(vect) a = rs.VectorAngle(vect, (0, 1, 0)) - 90 #load the component path = self.loadPath component = None try: component = importComponent(path) except: print('exception on importing module') if component is None: print('component is None') return None #rs.MoveObjects(component.breps,pts[0]) #rs.RotateObjects(component.breps,pts[0],a) for b in component.breps: self.generatedObjs.append(b) oriented = orientObjAlongPolyPts(b, pts) print('pts count:', len(pts), ' num gen:', len(oriented)) rs.MoveObjects(component.polys, pts[0]) rs.RotateObjects(component.polys, pts[0], a) for c in component.polys: self.generatedObjs.append(c) mesh = meshSwipPolyAlongPoly(c, rail) self.generatedObjs.append(mesh) rs.DeleteObject(rail) print('generated obj count:', len(self.generatedObjs)) rs.AddGroup('gen') rs.AddObjectsToGroup(self.generatedObjs, 'gen')
def get_edge_vectors(s_brep,length): """gets the direction vectors for extending the edges of the one-surface brep""" edges = s_brep.Edges normal = s_brep.Faces[0].NormalAt(0.5,0.5) midpoints = [] for edge in edges: mp = edge.Domain.Mid midpoints.append(edge.PointAt(mp)) edge_vectors = [] for i, edge in enumerate(edges): #get directions to test moving midpoint start = edge.StartVertex.Location end = edge.EndVertex.Location v = rs.VectorCreate(end,start) xprod1 = Rhino.Geometry.Vector3d.CrossProduct(normal,v) xprod1 = rs.VectorUnitize(xprod1) xprod2 = rs.VectorReverse(xprod1) p1 = edge.PointAt(edge.Domain.Mid) + xprod1 p2 = edge.PointAt(edge.Domain.Mid) + xprod2 print "p1", p1 print "p2", p2 dist1 = distance_to_brep(s_brep,p1) dist2 = distance_to_brep(s_brep,p2) print "dist1", dist1 print "dist2", dist2 if dist1 > dist2: edge_vectors.append(rs.VectorScale(xprod1,length)) else: edge_vectors.append(rs.VectorScale(xprod2,length)) return edge_vectors
def blendcorners(): polyline_id = rs.GetObject("Polyline to blend", 4, True, True) if not polyline_id: return vertices = rs.PolylineVertices(polyline_id) if not vertices: return radius = rs.GetReal("Blend radius", 1.0, 0.0) if radius is None: return between = lambda a, b: (a + b) / 2.0 newverts = [] for i in range(len(vertices) - 1): a = vertices[i] b = vertices[i + 1] segmentlength = rs.Distance(a, b) vec_segment = rs.PointSubtract(b, a) vec_segment = rs.VectorUnitize(vec_segment) if radius < (0.5 * segmentlength): vec_segment = rs.VectorScale(vec_segment, radius) else: vec_segment = rs.VectorScale(vec_segment, 0.5 * segmentlength) w1 = rs.PointAdd(a, vec_segment) w2 = rs.PointSubtract(b, vec_segment) newverts.append(a) newverts.append(between(a, w1)) newverts.append(w1) newverts.append(between(w1, w2)) newverts.append(w2) newverts.append(between(w2, b)) newverts.append(vertices[len(vertices) - 1]) rs.AddCurve(newverts, 5) rs.DeleteObject(polyline_id)
def MirrorX(lineIn, pIn): pLine0 = lineIn[0] pLine1 = lineIn[1] normal = rs.VectorUnitize( rs.VectorCrossProduct([0, 0, 1], rs.VectorSubtract(pLine1, pLine0))) matrix = rs.XformMirror(pLine1, normal) return rs.PointTransform(pIn, matrix)
def vecRotate(vec, ang, axis): cos = m.cos(m.pi / 180 * ang) sin = m.sin(m.pi / 180 * ang) v = vec u = rs.VectorUnitize(axis) #u = [axis[0]/np.linalg.norm(axis),axis[1]/np.linalg.norm(axis),axis[2]/np.linalg.norm(axis)] R1, R2, R3 = [], [], [] c = 1 - cos R1.append(cos + m.pow(u[0], 2) * c) R1.append(u[0] * u[1] * c - u[2] * sin) R1.append(u[0] * u[2] * c + u[1] * sin) R2.append(u[1] * u[0] * c + u[2] * sin) R2.append(cos + m.pow(u[1], 2) * c) R2.append(u[1] * u[2] * c - u[0] * sin) R3.append(u[2] * u[0] * c - u[1] * sin) R3.append(u[2] * u[1] * c + u[0] * sin) R3.append(cos + m.pow(u[2], 2) * c) x = v[0] * R1[0] + v[1] * R1[1] + v[2] * R1[2] y = v[0] * R2[0] + v[1] * R2[1] + v[2] * R2[2] z = v[0] * R3[0] + v[1] * R3[1] + v[2] * R3[2] return [x, y, z]