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): fillets.append( rs.AddFilletCurve(self.line_lists[i][j], self.line_lists[i][j + 1], 1)) for k in range(0, len(self.line_lists[i])): line = self.line_lists[i][k] if (k < len(self.line_lists[i]) - 1): line_domain = rs.CurveDomain(line) line_intersect = rs.CurveCurveIntersection( line, fillets[k])[0][5] line = rs.TrimCurve(self.line_lists[i][k], (line_domain[0], line_intersect), True) if (k > 0): line_domain = rs.CurveDomain(line) line_intersect = rs.CurveCurveIntersection( line, fillets[k - 1]) line = rs.TrimCurve(line, (line_intersect[0][5], line_domain[1]), True) new_line.append(line) if (k < len(self.line_lists[i]) - 1): new_line.append(fillets[k]) self.lines.append(rs.JoinCurves(new_line))
def double_pitch(m, n, o, p, diffY, diffZ): """generates a double pitch roof""" # cullis cullisN = rs.AddLine(m, n) cullisP = rs.AddLine(p, o) # ridge cullisO = rs.AddLine(n, o) domainO = rs.CurveDomain(cullisO) cullisM = rs.AddLine(p, m) domainM = rs.CurveDomain(cullisM) midCullisO = rs.EvaluateCurve(cullisO, (domainO[1] / 2.0)) midCullisM = rs.EvaluateCurve(cullisM, (domainM[1] / 2.0)) ridgeM = rs.PointAdd(rs.PointAdd(midCullisM, [0, 0, diffZ]), [0, diffY, 0]) ridgeO = rs.PointAdd(rs.PointAdd(midCullisO, [0, 0, diffZ]), [0, -diffY, 0]) ridge = rs.AddLine(ridgeM, ridgeO) allGeometry.append(rs.AddLoftSrf([cullisN, ridge])) allGeometry.append(rs.AddLoftSrf([cullisP, ridge])) # gable ridgeOPt = ridgeO ridgeMPt = ridgeM # print(m) # print(ridgeMPt) # print(p) allGeometry.append(rs.AddSrfPt([m, ridgeMPt, p])) allGeometry.append(rs.AddSrfPt([n, ridgeOPt, o]))
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 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 BSearchCurve(idCrv, Length, Tolerance): Lcrv = rs.CurveLength(idCrv) if Lcrv < Length: return tmin = rs.CurveDomain(idCrv)[0] tmax = rs.CurveDomain(idCrv)[1] t0 = tmin t1 = tmax while True: t = 0.5 * (t1 + t0) Ltmp = rs.CurveLength(idCrv, 0, [tmin, t]) if abs(Ltmp - Length) < Tolerance: return t if Ltmp < Length: t0 = t else: t1 = t
def RecursiveGrowth(ptStart, vecDir, props, gen): minTwigCount, maxTwigCount, maxGen, maxTwigLength, lengthMutation,maxTwigAngle, angleMutation = props if gen > maxGen : return newProps = props maxTwigLength *= lengthMutation maxTwigAngle *= angleMutation if maxTwigAngle>90:maxTwigAngle=90 newProps = minTwigCount, maxTwigCount, maxGen, maxTwigLength, lengthMutation, maxTwigAngle, angleMutation maxN=int(minTwigCount+random.random()* (maxTwigCount-minTwigCount)) for n in range (0,maxN): newPoint = RandomPointInCone (ptStart, vecDir, .25*maxTwigLength, maxTwigLength, maxTwigAngle) newProps = minTwigCount, maxTwigCount, maxGen, maxTwigLength, lengthMutation,maxTwigAngle, angleMutation maxN=int(minTwigCount+random.random()* (maxTwigCount-minTwigCount) ) for n in range(0,maxN): newPoint = RandomPointInCone(ptStart, vecDir, .25*maxTwigLength, maxTwigLength, maxTwigAngle) newTwig = AddArcDir(ptStart, newPoint, vecDir) if newTwig: vecGrow = rs.CurveTangent(newTwig, rs.CurveDomain(newTwig)[1]) RecursiveGrowth(newPoint, vecGrow, newProps, gen+1)
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 slice_sequence(crvs, seq_count): pt_slice = [] frame = 1 / seq_count # print frame for i in xrange(len(crvs)): crv = crvs[i] crv = rs.coercecurve(crv) start_pt, end_pt = rs.CurveDomain(crv) # print start_pt, "to", end_pt ### [0 to len(Curves)] param_slice = [] for j in xrange(int(end_pt)): for k in xrange(seq_count): value = j + k * frame param_slice.append(value) param_slice.append(end_pt) # print param_slice # print len(param_slice) sub_list = [] for l in xrange(len(param_slice)): pt = rg.Curve.PointAt(crv, param_slice[l]) sub_list.append(pt) pt_slice.append(sub_list) return pt_slice
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 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 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 create_cross_sections(self): crvdomain = rs.CurveDomain(self.curve_object) self.cross_sections = [] self.cross_section_planes = [] t_step = (crvdomain[1] - crvdomain[0]) / self.SAMPLES pi_step_size = math.pi / self.SAMPLES pi_step = 0 prev_normal = None prev_perp = None for t in rs.frange(crvdomain[0], crvdomain[1], t_step): crvcurvature = rs.CurveCurvature(self.curve_object, t) crosssectionplane = None if not crvcurvature: crosssectionplane = self.cross_section_plane_no_curvature( t, prev_normal, prev_perp) else: crosssectionplane = self.cross_section_plane_curvature( crvcurvature, prev_normal, prev_perp) if crosssectionplane: prev_perp = crosssectionplane.XAxis prev_normal = crosssectionplane.YAxis pi_scalar = self.create_scalar(pi_step) radii = self.ellipse_radii(pi_scalar) csec = rs.AddEllipse(crosssectionplane, radii[0], radii[1]) self.cross_sections.append(csec) self.cross_section_planes.append(crosssectionplane) pi_step += pi_step_size
def addpointat_r1_parameter(curve_id, parameter): domain = rs.CurveDomain(curve_id) if not domain: return r1_param = domain[0] + parameter * (domain[1] - domain[0]) r3point = rs.EvaluateCurve(curve_id, r1_param) if r3point: point_id = rs.AddPoint(r3point) rs.ObjectColor(point_id, parametercolor(parameter))
def renderSubTree(self, startRadius, growthFactor, curveDegree): #start radius is the radius at the tip of the smallest branches #growth Factor is the factor by which the start radius grows #as it moves towards the root, node by node #curveDegree is the degree of the curves of the tree treeID = rs.AddGroup() while True: deepCh = self.deepestChild() startNode = deepCh[0] if startNode == None: #this is the case where the whole tree is rendered #later return the group id of the group #that contains the whole tree from here return treeID curNode = startNode nodeList = [startNode] while (not curNode.parent is None) and (not curNode.isDone): nodeList.append(curNode.parent) curNode = curNode.parent posList = [] i = 0 while i < len(nodeList): posList.append(nodeList[i].pos) i += 1 curveID = rs.AddCurve(posList,curveDegree) curDom = rs.CurveDomain(curveID) node1 = rs.EvaluateCurve(curveID, curDom[0]) node2 = rs.EvaluateCurve(curveID, curDom[1]) tan1 = rs.CurveTangent(curveID, curDom[0]) tan2 = rs.CurveTangent(curveID, curDom[1]) plane1 = rs.PlaneFromNormal(node1, tan1) plane2 = rs.PlaneFromNormal(node2, tan2) radius1 = startRadius radius2 = (growthFactor**len(nodeList))*startRadius circles = [] circles.append(rs.AddCircle(plane1, radius1)) circles.append(rs.AddCircle(plane2, radius2)) branch = rs.AddSweep1(curveID, circles, True) rs.AddObjectToGroup(branch, treeID) rs.DeleteObjects(circles) rs.DeleteObject(curveID) for nd in nodeList: nd.isDone = True
def draw_hole(grid00, grid01): grids = [grid00, grid01] points = [] lists = [] for i in grids: domain = rs.CurveDomain(i) domains = [domain[0] + b, domain[1] - b0 * b, domain[1] - b] lists.append(domains) for ii in domains: point = rs.EvaluateCurve(i, ii) points.append(point) for i in range(2): grid = rs.AddCurve([points[i * 3], points[5 - i * 3]]) domain0 = rs.CurveDomain(grid) domain1 = domain0[1] - c point = rs.EvaluateCurve(grid, domain1) #rs.AddPoint(point) rs.AddCurve([point, points[i * 3 + 1]]) rs.TrimCurve(grids[i], (lists[i][0], lists[i][1])) rs.TrimCurve(grid, (domain0[0], domain1))
def addPoint(curve_id, parameter): domain = rs.CurveDomain(curve_id) r1_param = domain[0] + (parameter * (domain[1] - domain[0])) # slice curve domain r3point = rs.EvaluateCurve(curve_id, r1_param) # at each domain chunk, store a var if r3point: point_id = rs.AddPoint( r3point) # add new point object along each domain chunk rs.ObjectColor(point_id, paramColor( parameter)) # color each point with a incrementing param
def offsetBothCrvs(crvs, width): if rs.IsCurveClosed(crvs): domain = rs.CurveDomain(crvs) parameter = (domain[0] + domain[1]) / 2.0 rs.CurveSeam(crvs, parameter) offsets = [] offsets.append(rs.OffsetCurve(crvs, [0, 0, 0], width / 2)) offsets.append(rs.OffsetCurve(crvs, [0, 0, 0], -width / 2)) section = rs.AddLoftSrf(offsets, loft_type=2) if offsets: rs.DeleteObjects(offsets) return section
def __generate_form_levels(self, spine_curve): crvdomain = rs.CurveDomain(spine_curve) printedState = "" crosssection_planes = [] crosssection_plane_nums = [] crosssections = [] t_step = (crvdomain[1] - crvdomain[0]) / ( self.object_properties["number_of_lofts"] - 1) t = crvdomain[0] for t in rs.frange(crvdomain[0], crvdomain[1], t_step): if (self.emotion_properties["vertical_AR"][str(int(t + 1))] != None): crvcurvature = rs.CurveCurvature(spine_curve, t) crosssectionplane = None if not crvcurvature: crvPoint = rs.EvaluateCurve(spine_curve, t) crvTangent = rs.CurveTangent(spine_curve, t) crvPerp = (0, 0, 1) crvNormal = rs.VectorCrossProduct(crvTangent, crvPerp) printedState = printedState + str(crvNormal) crosssectionplane = rs.PlaneFromNormal( crvPoint, crvTangent) if (t == 0): crosssectionplane = rs.PlaneFromNormal([0, 0, 0], [0, 0, 1]) else: crvPoint = crvcurvature[0] crvTangent = crvcurvature[1] crvPerp = rs.VectorUnitize(crvcurvature[4]) crvNormal = rs.VectorCrossProduct(crvTangent, crvPerp) printedState = printedState + str(crvNormal) crosssectionplane = rs.PlaneFromNormal( crvPoint, crvTangent, crvNormal) if crosssectionplane: crosssection_planes.append(crosssectionplane) crosssection_plane_nums.append(str(int(t + 1))) if len(crosssection_plane_nums) > 0: last_element = crosssection_plane_nums.pop( len(crosssection_plane_nums) - 1) crosssection_plane_nums.insert(0, last_element) for index in xrange(len(crosssection_plane_nums)): crosssections.append( self.__generate_individual_levels( crosssection_planes[index], crosssection_plane_nums[index])) if not crosssections: return crosssections.append(crosssections.pop(0)) rs.AddLoftSrf(crosssections, closed=False, loft_type=int( round(self.emotion_properties["vertical_wrapping"]))) return crosssection_planes[0]
def GetHolepoint (): id = rs.GetObject("select hole curve",4,True,True) n = rs.GetInteger("How may hole point") if not id or n <=0: print "illegal selection or interger" return domain = rs.CurveDomain(id) t = 0 while t<=1.0: point = rs.EvaluateCurve(id,domain[0]+t*(domain[1]-domain[0])) print point[0],' ',point[1],' ',point[2] t+=1.0/n
def createMarkSphere(curve_list): curve = curve_list[0] domain = rs.CurveDomain(curve) t = domain[1] / 2.0 point = rs.EvaluateCurve(curve, t) mark_collision = rs.AddSphere(point, 40) rs.ObjectColor(mark_collision, [255, 0, 0]) return mark_collision
def space(self, density): space = [] density = int(density) if rs.IsCurve(self.guid): domain = rs.CurveDomain(self.guid) u = (domain[1] - domain[0]) / (density - 1) for i in range(density): space.append(domain[0] + u * i) elif rs.IsPolyCurve(self.guid): rs.EnableRedraw(False) segments = rs.ExplodeCurves(self.guid) for segment in segments: domain = rs.CurveDomain(segment) u = (domain[1] - domain[0]) / (density - 1) for i in range(density): space.append(domain[0] + u * i) rs.DeleteObjects(segments) rs.EnableRedraw(True) else: raise Exception('Object is not a curve.') return space
def periods_ofcurve(curve, n): domain = rs.CurveDomain(curve) cpoint_list = [] point0 = rs.EvaluateCurve(curve, domain[0]) point1 = rs.EvaluateCurve(curve, domain[1]) #rs.AddPoints( [ point0, point1 ] ) for i in range(n + 1): d = domain[1] * (i) / n point_lower = rs.EvaluateCurve(curve, d - a) point_upper = rs.EvaluateCurve(curve, d + a) cpoint_list.append(point_lower) cpoint_list.append(point_upper) return cpoint_list
def curvePlnrNormalAtEnds(crv): up = (0, 0, 1) dom = rs.CurveDomain(crv) t0 = dom[0] t1 = dom[1] pln0 = rs.CurvePerpFrame(crv, t0) pln1 = rs.CurvePerpFrame(crv, t1) n0 = rs.VectorCrossProduct(pln0.ZAxis, up) n1 = rs.VectorCrossProduct(pln1.ZAxis, up) return n0, n1
def wallBaseSrf(crv, width): rs.SimplifyCurve(crv) if rs.IsCurveClosed(crv): domain = rs.CurveDomain(crv) parameter = (domain[0] + domain[1]) / 2.0 rs.CurveSeam(crv, parameter) offsets = map(lambda x: rs.OffsetCurve(crv, [0, 0, 0], x), [width / 2, -width / 2]) section = rs.AddLoftSrf(offsets, loft_type=2) if offsets: rs.DeleteObjects(offsets) if rs.IsPolysurface(section): return rs.ExplodePolysurfaces(section, delete_input=True) return section
def splitLine(line): #obtain the curve (line) minimum and maximum (domain) lineDomain = rs.CurveDomain(line) min = lineDomain[0] max = lineDomain[1] OneThird = (max - min) / 3 TwoThird = (max - min) * 2 / 3 StartLine = rs.TrimCurve(line, (min, min + OneThird), False) EndLine = rs.TrimCurve(line, (min + TwoThird, max)) SplitLine = (StartLine, EndLine) #return the array of two lines return SplitLine
def iterativePanel(lengthPanel): #aux elements crvBase = rs.GetObject("Iterative mode, Select curve to be use as rail", rs.filter.curve) #domain for split the curve into equal parts domain = rs.CurveDomain(crvBase) t = domain[1]/2.0 crvSplit = rs.SplitCurve(crvBase, t) #building the core pEnd = rs.DivideCurveEquidistant(crvSplit[1], lengthPanel, True) for i in range (len(pEnd)-1): #rs.AddCircle(pEnd[i], 5) #Just fot testing panel = rs.AddLine(pEnd[i], pEnd[i+1])
def projectPtOnSrf(attractorPt, targetSrf, pt): r = rs.AddLine(attractorPt, pt) r = rs.ScaleObject(r, attractorPt, (10, 10, 10)) dom = rs.CurveDomain(r) crv = rs.coercecurve(r) srf = rs.coercesurface(targetSrf).ToNurbsSurface() inv = Interval(dom[0], dom[1]) rs.DeleteObject(r) xobj = Intersection.CurveSurface(crv, inv, srf, 0.1, 1) return xobj[0].PointB
def createMidPointFromCurve(curve): split_num = 2 point_list = [] domain = rs.CurveDomain(curve) t = (domain[1] - domain[0]) / split_num for int in range(split_num): dt = t * int point = rs.EvaluateCurve(curve, dt) point_list.append(point) # 直線の中心点を求める line = rs.AddLine(point_list[0], point_list[1]) mid_point = rs.CurveMidPoint(line) return mid_point
def splitlines(lines, count): #temp list and clear input list templines = lines lines = [] pts = [] #make sure we have a way to break the recursion if count == 0: return 1 else: for line in templines: #get properties of the line (endpts, length, direction, domain) stpt = rs.CurveStartPoint(line) endpt = rs.CurveEndPoint(line) length = rs.Distance(stpt, endpt) dir1 = rs.VectorCreate(endpt, stpt) crvdomain = rs.CurveDomain(line) #parameters for midpt and pts 1/3 and 2/3 along the line t0 = crvdomain[1] / 2.0 t1 = crvdomain[1] / 3.0 t2 = t1 * 2 midpt = rs.EvaluateCurve(line, t0) ptatonethird = rs.EvaluateCurve(line, t1) ptattwothird = rs.EvaluateCurve(line, t2) midpt = rs.AddPoint(midpt) #call get normal function normal = getnormal(stpt, endpt) #move midpt perpendicular to line at 1/3 the length of the line scaled = rs.VectorScale(normal, 0.3333) rs.MoveObject(midpt, scaled) #create the 4 newlines and add them to the list newline1 = rs.AddLine(stpt, ptatonethird) newline2 = rs.AddLine(ptatonethird, midpt) newline3 = rs.AddLine(midpt, ptattwothird) newline4 = rs.AddLine(ptattwothird, endpt) lines.append(newline1) lines.append(newline2) lines.append(newline3) lines.append(newline4) #create a list of objects to delete cleanup = [] cleanup.append(line) cleanup.append(midpt) rs.DeleteObjects(cleanup) #don't forget to decrement the count otherwise infinite loop count = count - 1 return splitlines(lines, count)