def get_dist(pt,poly): # find closest point on axis curve param = rs.CurveClosestPoint(axis, pt) # get plane perpendicular to curve ck,pl = axis.PerpendicularFrameAt(param) # part responsible for flat end caps # if distance from point to plane is bigger than 0, # return that distance pp = rs.PlaneClosestPoint(pl,pt) d2 = rs.Distance(pt,pp) if d2>0.01: return d2 # else change the basis of the polygon from world xy # to that plane to check for distance and inside/outside pm = (param-axis.Domain[0])/(axis.Domain[1]-axis.Domain[0]) wxy = rs.WorldXYPlane() tf = rg.Transform.PlaneToPlane(wxy,pl) ang = sa + pm*(ea-sa) tr = rg.Transform.Rotation(ang, pl.Normal, pl.Origin) tpts = rs.CurvePoints(poly) for p in tpts: p.Transform(tf) p.Transform(tr) ply = rs.AddPolyline(tpts) prm = rs.CurveClosestPoint(ply,pt) cp = rs.EvaluateCurve(ply,prm) d = rs.Distance(pt,cp) # if the point is inside the curve, reverse the distance bln = rs.PointInPlanarClosedCurve(pt,ply,pl) if bln: d *= -1 return d
def cxc(crv, pt, r, onlyNext=True): trash = [] xc = rs.AddCircle(pt, r) xx = rs.CurveCurveIntersection(crv, xc) xpts = [] if xx is None: return None #print('xx len:',len(xx)) for xxe in xx: if xxe[0] == 1: xpts.append(xxe[1]) rs.DeleteObject(xc) dom = rs.CurveDomain(crv) # endT=rs.CurveClosestPoint(crv,rs.CurveEndPoint(crv)) # print('endT :'endT) if onlyNext: centerT = rs.CurveClosestPoint(crv, pt) maxT = dom[0] maxI = 0 for i in range(0, len(xpts)): p = xpts[i] t = rs.CurveClosestPoint(crv, p) if t > maxT: maxT = t maxI = i # print(dom[1],centerT,t) if maxT > dom[1] or maxT < centerT: return None return xpts[maxI] return xpts
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 createPipe(self, first, mid, last, text): first_fillet = rs.AddFilletCurve(first, mid, 0.25) fillet_points = rs.CurveFilletPoints(first, mid, 0.25) first_circle = rs.AddCircle(fillet_points[2], 0.125) first_cp = rs.CurveClosestPoint(first, fillet_points[0]) first_domain = rs.CurveDomain(first) nfirst = rs.TrimCurve(first, (first_domain[0], first_cp), False) second_cp = rs.CurveClosestPoint(mid, fillet_points[1]) second_domain = rs.CurveDomain(mid) nmid = rs.TrimCurve(mid, (second_cp, second_domain[1]), False) second_fillet = rs.AddFilletCurve(mid, last, 0.25) fillet_points = rs.CurveFilletPoints(mid, last, 0.25) second_circle = rs.AddCircle(fillet_points[2], 0.125) first_cp = rs.CurveClosestPoint(mid, fillet_points[0]) first_domain = rs.CurveDomain(mid) nmid = rs.TrimCurve(nmid, (first_domain[0], first_cp), False) second_cp = rs.CurveClosestPoint(last, fillet_points[1]) second_domain = rs.CurveDomain(last) nlast = rs.TrimCurve(last, (second_cp, second_domain[1]), False) curve = rs.JoinCurves( [nfirst, first_fillet, nmid, second_fillet, nlast]) print curve pipe = rs.AddPipe(curve, 0, 0.09375, 0, 1) points = [ rs.CurveStartPoint(first), rs.CurveEndPoint(first), rs.CurveStartPoint(last), rs.CurveEndPoint(last) ] self.copyAndMover(first, mid, last, points, text)
def fillet_lines(self): self.lines = [] for i in range(0, len(self.line_lists)): fillets = [] new_line = [] for j in range(0, len(self.line_lists[i]) - 1): first_line = self.line_lists[i][j] second_line = self.line_lists[i][j + 1] fillet = rs.AddFilletCurve(first_line, second_line, 0.125) fillet_points = rs.CurveFilletPoints(first_line, second_line, 0.125) first_cp = rs.CurveClosestPoint(first_line, fillet_points[0]) first_domain = rs.CurveDomain(first_line) self.line_lists[i][j] = rs.TrimCurve( first_line, (first_domain[0], first_cp), True) second_cp = rs.CurveClosestPoint(second_line, fillet_points[1]) second_domain = rs.CurveDomain(second_line) self.line_lists[i][j + 1] = rs.TrimCurve( second_line, (second_cp, second_domain[1]), True) fillets.append(fillet) for k in range(0, len(self.line_lists[i])): new_line.append(self.line_lists[i][k]) if (k < len(self.line_lists[i]) - 1): new_line.append(fillets[k]) new_curve = self.get_curve_from_segments(new_line) self.lines.append(new_curve)
def grow(self, side): 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 and side == 1: param = rs.CurveClosestPoint(self.path, self.branches[i].end01) dist = rs.Distance(self.branches[i].end01, rs.EvaluateCurve(self.path, param)) tan = rs.CurveTangent(self.path, param) newBranches.append( branch(self.branches[i].end01, self.branches[i].vec01, self.ang, axis01)) if rs.VectorAngle(self.branches[i].axis, axis02) < 60 and side == 2: param = rs.CurveClosestPoint(self.path, self.branches[i].end02) dist = rs.Distance(self.branches[i].end02, rs.EvaluateCurve(self.path, param)) tan = rs.CurveTangent(self.path, param) vecAng = rs.VectorAngle(self.branches[i].vec02, tan) vec = rs.VectorRotate(self.branches[i].vec02, -vecAng / 5, axis02) newBranches.append( branch(self.branches[i].end02, self.branches[i].vec02, self.ang, axis02)) self.branches = [] self.branches.extend(newBranches) return self.branches
def curvy_stairs(curve, start_pt, end_pt, stair_width, steps, plinth_lst, bannister_lst): ref = rs.OffsetCurve( curve, [1, 0, 0], stair_width) # create the second curve to guide the stair ref_pts = [n * 1 / steps for n in range(steps + 1) ] # guide points to divide up the curve left_pts = [rs.EvaluateCurve(curve, t) for t in ref_pts] # guide points on input curve right_pts = [rs.EvaluateCurve(ref, t) for t in ref_pts] #guide points on the offset curve height = end_pt[2] - start_pt[2] #stair height rise = [0, 0, height / steps] # a vector for i in range(steps): #draw rise v_ver = [ left_pts[i], right_pts[i], rs.PointAdd(right_pts[i], rise), rs.PointAdd(left_pts[i], rise) ] rs.AddSrfPt(v_ver) #draw run v_hori = [v_ver[3], v_ver[2], right_pts[i + 1], left_pts[i + 1]] rs.AddSrfPt(v_hori) #draw sides s1 = rs.AddLine(left_pts[i], rs.PointAdd(left_pts[i], rise)) s2 = rs.AddLine(rs.PointAdd(left_pts[i], rise), left_pts[i + 1]) s3 = rs.AddSubCrv(curve, rs.CurveClosestPoint(curve, left_pts[i]), rs.CurveClosestPoint(curve, left_pts[i + 1])) rs.AddEdgeSrf([s1, s2, s3]) rs.DeleteObjects([s1, s2, s3]) s1 = rs.AddLine(right_pts[i], rs.PointAdd(right_pts[i], rise)) s2 = rs.AddLine(rs.PointAdd(right_pts[i], rise), right_pts[i + 1]) s3 = rs.AddSubCrv(ref, rs.CurveClosestPoint(ref, right_pts[i]), rs.CurveClosestPoint(ref, right_pts[i + 1])) rs.AddEdgeSrf([s1, s2, s3]) rs.DeleteObjects([s1, s2, s3]) s1 = rs.AddLine(left_pts[0], right_pts[0]) s2 = rs.AddLine(left_pts[-1], right_pts[-1]) rs.AddEdgeSrf([s1, curve, s2, ref]) rs.DeleteObjects([s1, s2]) if plinth_lst[0]: curvy_plinth(curve, ref, stair_width, plinth_lst) if bannister_lst[0]: curvy_bannister(curve, ref, stair_width, bannister_lst)
def copyAndMover(self, first, mid, last, points, text): plane = rs.PlaneFromPoints(points[0], points[1], points[2]) uv1 = rs.PlaneClosestPoint(plane, points[1], False) uv2 = rs.PlaneClosestPoint(plane, points[2], False) distHor = abs(uv1[0] - uv2[0]) distVert = abs(uv1[1] - uv2[1]) key = 'len{0}{1}'.format(distHor, distVert) key = re.sub(r'\.', '', key) if key in self.partsHash: self.partsHash[key].append(text) else: self.partsHash[key] = [] self.partsHash[key].append(text) ypos = len(self.partsHash.keys()) + len(self.partsHash.keys()) rs.AddText(key, [0, ypos, 0], 0.3) newPoints = [ rs.AddPoint(0, ypos, 0), rs.AddPoint(self.FLAT_LENGTH, ypos, 0), rs.AddPoint(self.FLAT_LENGTH + distHor, ypos + distVert, 0), rs.AddPoint((self.FLAT_LENGTH * 2) + distHor, ypos + distVert, 0) ] first = rs.OrientObject(first, points, newPoints, 1) mid = rs.OrientObject(mid, points, newPoints, 1) last = rs.OrientObject(last, points, newPoints, 1) first_fillet = rs.AddFilletCurve(first, mid, 0.09375) fillet_points = rs.CurveFilletPoints(first, mid, 0.09375) first_circle = rs.AddCircle(fillet_points[2], 0.09375) first_cp = rs.CurveClosestPoint(first, fillet_points[0]) first_domain = rs.CurveDomain(first) first = rs.TrimCurve(first, (first_domain[0], first_cp), True) second_cp = rs.CurveClosestPoint(mid, fillet_points[1]) second_domain = rs.CurveDomain(mid) mid = rs.TrimCurve(mid, (second_cp, second_domain[1]), True) second_fillet = rs.AddFilletCurve(mid, last, 0.09375) fillet_points = rs.CurveFilletPoints(mid, last, 0.09375) second_circle = rs.AddCircle(fillet_points[2], 0.09375) first_cp = rs.CurveClosestPoint(mid, fillet_points[0]) first_domain = rs.CurveDomain(mid) mid = rs.TrimCurve(mid, (first_domain[0], first_cp), True) second_cp = rs.CurveClosestPoint(last, fillet_points[1]) second_domain = rs.CurveDomain(last) last = rs.TrimCurve(last, (second_cp, second_domain[1]), True) curve = rs.JoinCurves( [first, first_fillet, mid, second_fillet, last]) rs.AddCircle([0, ypos - 0.125 - 0.09375, 0], 0.09375) rs.AddCircle([(self.FLAT_LENGTH * 2) + distHor, ypos + distVert + 0.125 + 0.09375, 0], 0.09375)
def get_inscribed_radius(curve, origin=(0,0,0)): # find out how many segments in this curve nsegs = rs.PolyCurveCount(curve) # record closest distance & point best_r = None best_point = None # for each curve segment for seg in range(nsegs): # get the curve parameter (i.e. input to spline function) that # approaches the origin most closely for this segment. param = rs.CurveClosestPoint(curve, origin, seg) # evaluate the curve at that parameter to get 3D point location point = rs.EvaluateCurve(curve, param) # get the displacement from the origin point = mz.vec_sub(list(point), origin) # get length r = mz.vec_length(point) # update best if best_r is None or r < best_r: best_r = r best_point = point # return distance & point return best_r, best_point
def get_dist(p, j): param = rs.CurveClosestPoint(axis[j], p) cp = rs.EvaluateCurve(axis[j], param) dv = map_values(param, axis[j].Domain[0], axis[j].Domain[1], 0, 1) r = (1 - dv) * start_radius[j] + dv * end_radius[j] d = rs.Distance(p, cp) - r return d
def WindowLeftDistance(): # Find midpoint of window left line midpoint_windowLeft = rs.CurveMidPoint(window_leftLine[1]) # Find closest point in curve window left parameterLeftLine = rs.CurveClosestPoint(window_leftLine[1], midpoint_windowLeft) # Find curve window left Tangent windowLeft_Tangent = rs.CurveTangent(window_leftLine[1], parameterLeftLine) # find window left normal plane windowLeft_plane = rs.PlaneFromNormal(midpoint_windowLeft, windowLeft_Tangent) # find start and end points of ground line points_ll = [] start_ll = bbox[0] end_ll = bbox[3] points_ll.append(start_ll) points_ll.append(end_ll) #find point on Surface Left line point_SurfLeftLine = rs.LinePlaneIntersection(points_ll, windowLeft_plane) #point_SurfLeftLine = rs.AddPoint(point_SurfLeftLine) Window_leftDistance = rs.Distance(midpoint_windowLeft, point_SurfLeftLine) return Window_leftDistance
def depressCrvs(srf, crvs, paths, startPt, radius, sd): newCrvs = [] for i in range(len(crvs)): divPts = rs.DivideCurve(crvs[i], 400) for j in range(len(divPts)): path = rs.PointClosestObject(divPts[j], paths)[0] param = rs.CurveClosestPoint(path, divPts[j]) close = rs.EvaluateCurve(path, param) srfParam = rs.SurfaceClosestPoint(srf, close) vec = rs.SurfaceNormal(srf, srfParam) dist = rs.Distance(close, divPts[j]) 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) else: border = 1 entryDist = rs.Distance(startPt, divPts[j]) if entryDist < sd * 10: entry = entryDist / (sd * 10) else: entry = 1 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 SillHeight(): # Find mid point of sill line midpointSill = rs.CurveMidPoint(window_sillLine[1]) #midpointSill = rs.AddPoint(midpointSill) # Find closest point in curve parameterSill = rs.CurveClosestPoint(window_sillLine[1], midpointSill) # Find curve Tangent sill_Tangent = rs.CurveTangent(window_sillLine[1], parameterSill) # find normal plane sill_plane = rs.PlaneFromNormal(midpointSill, sill_Tangent) # find start and end points of ground line points_gl = [] start_gl = rs.CurveStartPoint(groundLine[1]) end_gl = rs.CurveEndPoint(groundLine[1]) points_gl.append(start_gl) points_gl.append(end_gl) #find point on ground line pointGroundLine = rs.LinePlaneIntersection(points_gl, sill_plane) #pointGroundLine = rs.AddPoint(pointGroundLine) sill_Height = rs.Distance(midpointSill, pointGroundLine) return sill_Height
def __init__(self, point, rotation, Course): #self.brickWidth = brickWidth self.brickCenter = point self.brickRotation = rotation self.Course = Course # self.courseCurve = curve self.curveParameter = rs.CurveClosestPoint(Course.getCurve(), point)
def distance(self): Udomain = rs.SurfaceDomain(self.strsrf, 0) Vdomain = rs.SurfaceDomain(self.strsrf, 1) stepU = (Udomain[1] - Udomain[0]) / self.intu stepV = (Vdomain[1] - Vdomain[0]) / self.intv #PLOT POINTS ON SURFACE) for i in range(self.intu + 1): for j in range(self.intv + 1): #define u and v in terms of step values and i and j u = Udomain[0] + stepU * i v = Vdomain[0] + stepV * j point = rs.EvaluateSurface(self.strsrf, u, v) crvParam = rs.CurveClosestPoint(self.Crv, point) crvPoints = rs.EvaluateCurve(self.Crv, crvParam) if rs.Distance(point, crvPoints) < 400: self.dis[(i, j)] = rs.Distance(point, crvPoints) else: self.dis[(i, j)] = 1300 return self.dis
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 get_edge_keys_and_param(message='Select edge.', layer=None): if layer: objs = rs.ObjectsByLayer(layer) selectable = [] for obj in objs: if "edge" in rs.ObjectName(obj): selectable.append(obj) else: selectable = None guid = rs.GetObjectEx(message, 4, False, False, selectable) uv = None t = None if guid: guid = guid[0] name = rs.ObjectName(guid).split('.') if 'edge' in name: pt = rs.GetPointOnCurve(guid, "Select point on edge") if not pt: return None, None param = rs.CurveClosestPoint(guid, pt) lb, ub = rs.CurveDomain(guid) t = (param - lb) / (ub - lb) print(lb, ub) key = name[-1] uv = tuple(key.split('-')) return uv, t
def get_distance(self,x,y,z): p = rs.CreatePoint(x,y,z) param=rs.CurveClosestPoint(self.c, p) cp=rs.EvaluateCurve(self.c,param) dv = map_values(param,self.c.Domain[0],self.c.Domain[1],0,1) r = (1-dv)*self.r1 + dv*self.r2 d = rs.Distance(p,cp) - r return d
def EdgeVectors(srf, pts): crvs = rs.DuplicateEdgeCurves(srf) edgeVectors = [] for pt in pts: closestIndex = 0 closestDist = 99999 for i, crv in enumerate(crvs): tempPt = rs.EvaluateCurve(crv, rs.CurveClosestPoint(crv, pt)) dist = rs.Distance(pt, tempPt) if dist < closestDist: closestDist = dist closestIndex = i tempPt = rs.EvaluateCurve(crvs[closestIndex], rs.CurveClosestPoint(crvs[closestIndex], pt)) rs.AddLine(tempPt, pt) edgeVectors.append(rs.VectorCreate(tempPt, pt)) return edgeVectors
def is_point_on_curve(curve_guid, point_xyz): geom_key = geometric_key(point_xyz) t = rs.CurveClosestPoint(curve_guid, point_xyz) pt_on_crv = rs.EvaluateCurve(curve_guid, t) geom_key_pt_on_crv = geometric_key(pt_on_crv) if geom_key == geom_key_pt_on_crv: return True else: return False
def rampIntersection(route1, route2, width): edges = [] offSeg1 = offsetLine(route1, width / 2) offSeg2 = offsetLine(route2, width / 2) test1 = rs.CurveCurveIntersection(offSeg1, offSeg2) if (test1 == None): side1 = False else: side1 = True offSeg3 = offsetLine(route1, -width / 2) offSeg4 = offsetLine(route2, -width / 2) rs.ObjectColor(offSeg3, [255, 0, 0]) rs.ObjectColor(offSeg4, [255, 0, 0]) test2 = rs.CurveCurveIntersection(offSeg3, offSeg4) if (test2 == None): side2 = False else: side2 = True if (side1): pivotPt = rs.LineLineIntersection(offSeg1, offSeg2)[0] perpPt1 = rs.EvaluateCurve(offSeg3, rs.CurveClosestPoint(offSeg3, pivotPt)) perpPt2 = rs.EvaluateCurve(offSeg4, rs.CurveClosestPoint(offSeg4, pivotPt)) edges.append(rs.AddLine(pivotPt, perpPt1)) edges.append(rs.AddLine(pivotPt, perpPt2)) elbowPt = rs.LineLineIntersection(offSeg3, offSeg4)[0] else: pivotPt = rs.LineLineIntersection(offSeg3, offSeg4)[0] perpPt1 = rs.EvaluateCurve(offSeg1, rs.CurveClosestPoint(offSeg1, pivotPt)) perpPt2 = rs.EvaluateCurve(offSeg2, rs.CurveClosestPoint(offSeg2, pivotPt)) edges.append(rs.AddLine(pivotPt, perpPt1)) edges.append(rs.AddLine(pivotPt, perpPt2)) elbowPt = rs.LineLineIntersection(offSeg1, offSeg2)[0] rs.DeleteObject(offSeg1) rs.DeleteObject(offSeg2) rs.DeleteObject(offSeg3) rs.DeleteObject(offSeg4) landing = rs.AddPolyline([pivotPt, perpPt1, elbowPt, perpPt2, pivotPt]) return edges, landing
def tangents(self, points): tangents = [] if rs.IsPolyCurve(self.guid): pass elif rs.IsCurve(self.guid): for point in points: param = rs.CurveClosestPoint(self.guid, point) vector = list(rs.CurveTangent(self.guid, param)) tangents.append((point, vector)) else: raise RhinoCurveError('object is not a curve') return tangents
def tangents(self, points): tangents = [] if rs.IsPolyCurve(self.guid): pass elif rs.IsCurve(self.guid): for point in points: param = rs.CurveClosestPoint(self.guid, point) vector = list(rs.CurveTangent(self.guid, param)) tangents.append(vector) else: raise Exception('Object is not a curve.') return tangents
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 spiral_stairs(curve, center, start_pt, end_pt, stair_width, steps, plinth_lst, bannister_lst): height = end_pt[2] - start_pt[2] cen = rs.AddLine(center, rs.PointAdd(center, [0, 0, height])) cen_e = rs.CurveEndPoint(cen) ref_pts = [n * 1 / steps for n in range(steps + 1)] outer_pts = [rs.EvaluateCurve(curve, t) for t in ref_pts] inner_pts = [[cen_e[0], cen_e[1], cen_e[2] * t] for t in ref_pts] print(inner_pts) rise = [0, 0, height / steps] for i in range(steps): #draw rise v_ver = [ outer_pts[i], inner_pts[i], rs.PointAdd(inner_pts[i], rise), rs.PointAdd(outer_pts[i], rise) ] rs.AddSrfPt(v_ver) #draw run v_hori = [v_ver[3], v_ver[2], outer_pts[i + 1]] rs.AddSrfPt(v_hori) #draw sides s1 = rs.AddLine(outer_pts[i], rs.PointAdd(outer_pts[i], rise)) s2 = rs.AddLine(rs.PointAdd(outer_pts[i], rise), outer_pts[i + 1]) s3 = rs.AddSubCrv(curve, rs.CurveClosestPoint(curve, outer_pts[i]), rs.CurveClosestPoint(curve, outer_pts[i + 1])) rs.AddEdgeSrf([s1, s2, s3]) rs.DeleteObjects([s1, s2, s3]) if plinth_lst[0]: curvy_plinth(curve, None, stair_width, plinth_lst) if bannister_lst[0]: curvy_bannister(curve, None, stair_width, bannister_lst)
def findBrickPlacements(closestBricks, index): global BrickList #get midpoint of bricks midPoint = closestBricks[0].getMidpoint3D(closestBricks[1]) print closestBricks[0].getTributaryMidpoint3D(closestBricks[1]) #get closest point on line to this midpoint closestParam = rs.CurveClosestPoint(ContourCurves[index], midPoint) closestMidPoint = rs.EvaluateCurve(ContourCurves[index], closestParam) #rotate brick rotation = 0 newBrick = Brick3D(closestMidPoint, rotation, CourseList[index]) return newBrick
def multiLineCurve(): """ --- --- --- --- --- --- --- --- --- --- --- ------------------------------------------- --- --- --- --- --- --- --- --- --- --- --- this script divides a curve by length and adds dashes to either side of the curve, grouped per curve / polyline limitation: does not accomodate at corners (to avoid ccx issues) www.studiogijs.nl """ curves = rs.GetObjects("select curves to change into multiline-style",4, preselect=True) if not curves: return s=sc.sticky['scale'] if sc.sticky.has_key('scale') else 20 scale = rs.GetReal("scale of the multiline curve", s, 5, 100) if not scale: return sc.sticky['scale']=scale rs.EnableRedraw(False) for curve in curves: lines=[] if rs.CurveLength(curve)>scale: pts = rs.DivideCurveLength(curve, scale) for pt in pts: t=rs.CurveClosestPoint(curve, pt) vec = rs.CurveTangent(curve, t)*scale/5 line = rs.AddLine(pt-vec, pt+vec) trans = rs.VectorRotate(vec, 90, [0,0,1]) trans/=2 line_copy = rs.CopyObject(line, trans) trans = -trans lines.append(line_copy) rs.MoveObject(line, trans) lines.append(line) group = rs.AddGroup() rs.AddObjectsToGroup(lines, group) rs.AddObjectsToGroup(curve, group) rs.SelectObjects(lines) rs.SelectObjects(curves) rs.EnableRedraw(True)
def move_point_down(self, point, cross_section_index, point_index): if (cross_section_index > 0): offset_vectors = self.offset_vector(point, cross_section_index, point_index) normal = rs.VectorReverse(offset_vectors[0]) scaled_offset = rs.VectorScale(rs.VectorUnitize(offset_vectors[1]), 3) new_point = rs.PointAdd(point, normal) return [ rs.PointAdd(new_point, scaled_offset), rs.PointAdd(new_point, rs.VectorReverse(scaled_offset)) ] else: curve = self.cross_sections[cross_section_index] parameter = rs.CurveClosestPoint(curve, point) tangent = rs.CurveTangent(curve, parameter) unit_vector = rs.VectorUnitize(tangent) scale_vector = rs.VectorReverse(rs.VectorScale(unit_vector, 2)) return [rs.PointAdd(point, scale_vector)]
def findBrickPlacement(closestBricks, index): global BrickList #get midpoint of bricks midPoint = closestBricks[0].getMidpoint3D(closestBricks[1]) #get closest point on line to this midpoint closestParam = rs.CurveClosestPoint(ContourCurves[index], midPoint) closestPoint = rs.EvaluateCurve(ContourCurves[index], closestParam) closestBrickDistCurve = closestBricks[0].getDistanceOnCurve( closestBricks[1]) #rotate brick none, for now rotation = 0 newBrick = Brick3D(closestPoint, rotation, CourseList[index]) return newBrick
def baseBranch(mesh,start,vec,ang,length,gen): end=rs.PointAdd(start,vec*length) end=rs.MeshClosestPoint(mesh,end)[0] branch1=rs.AddLine(start,end) projBranch1=rs.PullCurveToMesh(mesh,branch1) branches=[projBranch1] stored=branches newBranches=[] i=0 count=0 while i < gen: i=i+1 for branch in branches: end=rs.CurveEndPoint(branch) param=rs.CurveClosestPoint(branch,end) vec=rs.CurveTangent(branch,param) vec=rs.VectorUnitize(vec) index=rs.MeshClosestPoint(mesh,end)[1] norm=rs.MeshFaceNormals(mesh)[index] vec=rs.VectorRotate(vec,ang,norm) start=rs.PointAdd(end,vec*length) start=rs.MeshClosestPoint(mesh,start)[0] newBranch=rs.AddLine(end,start) pulledBranch=rs.PullCurveToMesh(mesh,newBranch) rs.DeleteObject(newBranch) newBranches.append(pulledBranch) vec=rs.VectorRotate(vec,-2*ang,norm) start=rs.PointAdd(end,vec*length) start=rs.MeshClosestPoint(mesh,start)[0] newBranch=rs.AddLine(end,start) pulledBranch=rs.PullCurveToMesh(mesh,newBranch) rs.DeleteObject(newBranch) if rs.Distance(start,rs.CurveEndPoint(pulledBranch))<length/2: newBranches.append(pulledBranch) branches=newBranches stored.extend(branches) newBranches=[] count=count+1 #for i in range(len(stored)): # squareSect(stored[i],1,1) print count return stored