def create_pipe(self, point_n, point_p): outer_point_n = self.create_scaled_point(point_n, self.PIPE_SCALAR) outer_point_p = self.create_scaled_point(point_p, self.PIPE_SCALAR) inner_point_n = self.create_scaled_point(point_n, self.INNER_PIPE_SCALAR) inner_point_p = self.create_scaled_point(point_p, self.INNER_PIPE_SCALAR) opl = rs.AddPolyline([outer_point_p, self.middle_point, outer_point_n]) ipl = rs.AddPolyline([inner_point_p, self.middle_point, inner_point_n]) o_pipe = rs.AddPipe(opl, 0, self.CIRCLE_WIDTH, 1, 1) i_pipe = rs.AddPipe(ipl, 0, self.CIRCLE_INNER_WIDTH, 1, 1) return rs.BooleanUnion([o_pipe, i_pipe])
def modify_input(filename): # Import object from file join_string = str(input_directory + filename) combined_string = '!_Import ' + '"' + join_string + '"' rs.Command(combined_string) # Get all objects imported objs = rs.LastCreatedObjects(select=False)[0] # Close curve closed_curve = rs.CloseCurve(objs, 0.5) rs.DeleteObject(objs) # Rebuild curve to create smoother shape rs.RebuildCurve(closed_curve, 3, 100) # Pipe figure with radius of 0.25 piped = rs.AddPipe(closed_curve, 0, 0.4)[0] rs.MoveObject(piped, [0, 0, 0]) bounding_pts = rs.BoundingBox([piped], view_or_plane=rs.WorldXYPlane()) maxX = 0 minX = 0 minY = 0 minZ = 0 for pt in bounding_pts: if pt[0] < minX: minX = pt[0] if pt[0] > maxX: maxX = pt[0] if pt[1] < minY: minY = pt[1] if pt[2] < minZ: minZ = pt[2] rect = rs.AddRectangle(rs.WorldXYPlane(), abs(maxX - minX), 3.0) # Move rect up 1/2 of diameter of circle used to pipe # Potentially use solid but smaller in height rect # Select function in rhino module could allow us to select objects so that the export works. rs.MoveObject(rect, [minX, minY - 3.0, minZ + 0.4]) piped_rect = rs.AddPipe(rect, 0, 0.4) rs.DeleteObject(closed_curve) rs.DeleteObject(rect) rs.SelectObjects([piped, piped_rect]) rs.Command("_-Export " + output_directory + filename + '.stl' + " _Enter _Tolerance=.001 _Enter")
def renderhistory(self): """ draws a curve through all the positions in my history list """ proj_points_new = [] circle1 = [] #ADD CURVE for i in range(len(self.proj_points)): if i % 10 == 0: if self.proj_points[i] is not None: proj_points_new.append(self.proj_points[i]) try: self.crv1 = rs.AddCurve(proj_points_new, 3) except: pass #ADD SWEEP GEOMETRY #print (len(self.z_distances)) #self.crv1_start = rs.CurveStartPoint(self.crv1) #divide_crv = rs.DivideCurve(self.crv1, (len(self.z_distances)) #print divide_crv #proj_pipe = rs.AddPipe(self.crv1,(len(self.z_distances)),self.z_distances, cap=2) #crv1_lenght = rs.CurveLength(self.crv1) #print crv1_lenght try: proj_pipe = rs.AddPipe(self.crv1, 0, .25, cap=2) except: pass
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 right(): r_curve = rs.CopyObject(curve, [0, 0, b_lst[1]]) rs.AddPipe(r_curve, 0, b_lst[2], cap=1) rs.DeleteObjects(r_curve) pts = [rs.EvaluateCurve(curve, t) for t in ref_pts] for i in range(b_lst[3]): base = rs.PointAdd(pts[i], [0, 0, b_lst[1]]) rs.AddCylinder(pts[i], base, b_lst[4])
def modify_input(filename): # Import object from file join_string = str(input_directory + filename) combined_string = '!_Import ' + '"' + join_string + '"' rs.Command(combined_string) # Get all objects imported objs = rs.LastCreatedObjects(select=False)[0] # Close curve closed_curve = rs.CloseCurve(objs, 0.5) rs.DeleteObject(objs) # Rebuild curve to create smoother shape rs.RebuildCurve(closed_curve, 3, 100) # Pipe figure with radius of 0.25 piped = rs.AddPipe(closed_curve, 0, 0.4)[0] rs.MoveObject(piped, [0, 0, 0]) bounding_pts = rs.BoundingBox([piped], view_or_plane=rs.WorldXYPlane()) maxX = 0 minX = 0 minY = 0 minZ = 0 for pt in bounding_pts: if pt[0] < minX: minX = pt[0] if pt[0] > maxX: maxX = pt[0] if pt[1] < minY: minY = pt[1] if pt[2] < minZ: minZ = pt[2] rect = rs.AddRectangle(rs.WorldXYPlane(), abs(maxX - minX), 3.0) rs.MoveObject(rect, [minX, minY - 3.0, minZ]) rs.AddPipe(rect, 0, 0.4) rs.DeleteObject(closed_curve) rs.DeleteObject(rect) export_string = '!_Export ' + '"' + str(output_directory + filename) + '"' rs.Command(export_string)
def g(): """ receives: theta = degree of line ( 0 < theta < 45 ) num = number of pattern ( 0 < num < 15 ) works: draw wire returns: None """ r = 10 sp = rs.AddSphere((0, 0, 0), r) box = [] for x in rs.frange(-r, r, 0.1): for y in rs.frange(-r, r, 0.1): if r**2 > x**2 + y**2: z = ma.sqrt(abs(r**2 - x**2 - y**2)) box.append((x, y, z)) for y in rs.frange(-r, r, 0.1): if r**2 > x**2 + y**2: z = ma.sqrt(abs(r**2 - x**2 - y**2)) box.append((x, -y, -z)) ll = len(box) rbox = [] for i in range(0, ll): r = rd.random() if r < 0.01: rbox.append(box[i]) box2 = [] box2.append(rd.sample(box, 300)) box3 = [] """ for i in range(0,100): if i == 0: dis=[] dis2=[] for k in range(1,100): x = box2[0][0][0] y = box2[0][0][1] z = box2[0][0][2] xx = box2[0][k][0] yy = box2[0][k][1] zz = box2[0][k][2] d = (x-xx)**2 + (y-yy)*2 + (z-zz)**2 dis.append(d) dis2.append(d) box2.remove(box2[0][0]) dis.sort() n = dis2.index(dis[-1]) k = box2[n] box2.remove(k) """ curve = rs.AddCurve(rbox, 2) rs.AddPipe(curve, 0, 0.05, True)
def drawpipes(self): #do not try to make a curve if the list only contains one point if self.trailID != "imnotacurveyet!": #delete variable rs.DeleteObject(self.trailID) rs.DeleteObject(self.pipes) self.trailID = rs.AddCurve(self.trailEndPts, 3) #self.pipes = rs.AddPipe(self.trailID,0,(0.3+2*rnd.random())) #for pipe in self.trailID: r = 0.1 + 1 * rnd.random() # pipe radio R = r * 150 self.pipes = rs.AddPipe(self.trailID, 0, r) #rs.HideObjects(curves) rs.ObjectColor(self.pipes, (R % 255, (R + 150) % 255, (R + 75) % 255))
def drawTime(): FPS = 30 last_time = time.time() global t t = 0 curves = [] # whatever the loop is... while True: # draw animation t += 1 # pause so that the animation runs at 30 fps new_time = time.time() # see how many milliseconds we have to sleep for # then divide by 1000.0 since time.sleep() uses seconds sleep_time = ((1000.0 / FPS) - (new_time - last_time)) / 1000.0 if sleep_time > 0: time.sleep(sleep_time) last_time = new_time run() print t if t > 108: for k in pts: curves.append(rs.AddCurve(k.ptList)) rs.EnableRedraw(False) for crv in curves: rs.AddPipe(crv, [0,0.5,1], [4,1,4], cap=2) for ln in lns: rs.AddPipe(ln, 0, 1, cap=2) rs.EnableRedraw(True) break escape_test()
def output_frame (filename): join_string = str(input_directory + filename) combined_string = '!_Import ' + '"' + join_string + '"' rs.Command(combined_string) # Get all objects imported objs = rs.LastCreatedObjects(select=False)[0] # Close curve closed_curve = rs.CloseCurve(objs, 0.5) rs.DeleteObject(objs) # Rebuild curve to create smoother shape rs.RebuildCurve(closed_curve, 3, 100) # Pipe figure with radius of 0.25 piped = rs.AddPipe(closed_curve,0,pipe_diameter)[0] rs.MoveObject(piped, [0,0,0]) bounding_pts = rs.BoundingBox([piped], view_or_plane=rs.WorldXYPlane()) maxX = 0 minX = 0 minY = 0 minZ = 0 for pt in bounding_pts: if pt[0] < minX: minX = pt[0] if pt[0] > maxX: maxX = pt[0] if pt[1] < minY: minY = pt[1] if pt[2] < minZ: minZ = pt[2] epsilon = 0.5 center = 0 one = [center - (box_width / 2),minY-epsilon,-1 * pipe_diameter] two = [center - (box_width / 2),minY-epsilon,pipe_diameter] three = [center + (box_width / 2),minY-epsilon,pipe_diameter] four = [center + (box_width / 2),minY-epsilon,-1 * pipe_diameter] five = [center - (box_width / 2),minY+epsilon,-1 * pipe_diameter] six = [center - (box_width / 2),minY+epsilon,pipe_diameter] seven = [center + (box_width / 2),minY+epsilon,pipe_diameter] eight = [center + (box_width / 2),minY+epsilon,-1 * pipe_diameter] bowx = rs.AddBox([two, three, four, one, six, seven, eight, five])
def draw_graph(vertices, edges, loop_size=1.0, spindle_size=1.0, node_radius=0.0, line_radius=0.0, key_to_colour={}): """Draw a graph in Rhino as grouped points and lines with optional element size and node colouring. Loops for edges (u, u) and parallel edges for multiple edges (u, v) and/or (v, u) are allowed. Parameters ---------- vertices : dict A dictionary of vertex keys pointing to point coordinates. edges : list A list of tuples of pairs of vertex indices. loop_size : float, optional Rough size of the loops due to edges (u, u). Default value is 1.0. spindle_size : float, optional Rough size of the spindles due to mutiple edges (u, v) and/or (v, u). Default value is 1.0. node_radius : float, optional Node radius representing the vertices. If equal to 0.0, a point is added, else a sphere. Default value is 1.0. line_radius : float, optional Line radius representing the edges. If equal to 0.0, a line is added, else a pipe. Default value is 1.0. key_to_colour : dict, optional An optional dictonary with vertex keys pointing to RGB colours. Returns ------- group : Rhino group A Rhino group with the list of points or sphere surfaces of the vertices, and the list of the list of curves or pipe surfaces of the edges. """ # nodes as points or spheres with optional colours nodes = [] for key, xyz in vertices.items(): nodes.append(rs.AddPoint(xyz) if node_radius == 0.0 else rs.AddSphere(xyz, node_radius)) if key in key_to_colour: rs.ObjectColor(nodes[-1], key_to_colour[key]) # curves curves = [] while len(edges) > 0: crvs = [] u0, v0 = edges.pop() # count occurences in case of multiple parallel edges n = 1 for u, v in edges: if (u == u0 and v == v0) or (u == v0 and v == u0): edges.remove((u, v)) n += 1 # if not loop edge if u0 != v0: start = vertices[u0] end = vertices[v0] # rough spindle of parallel edges based on third offset point mid = midpoint_line([start, end]) direction = cross_vectors(normalize_vector(subtract_vectors(end, start)), [0.0, 0.0, 1.0]) for i in range(n): k = (float(i) / float(n) * spindle_size) - spindle_size / 2.0 * (float(n) - 1.0) / float(n) dir_mid = add_vectors(mid, scale_vector(direction, k)) crvs.append(rs.AddInterpCurve([start, dir_mid, end], degree=3)) # if loop edge else: xyz0 = vertices[u0] x0, y0, z0 = xyz0 # rough loop based on three additional points xyz1 = [x0 + loop_size / 2.0, y0 - loop_size / 2.0, z0] xyz2 = [x0 + loop_size, y0, z0] xyz3 = [x0 + loop_size / 2.0, y0 + loop_size / 2.0, z0] crvs += [rs.AddInterpCurve([xyz0, xyz1, xyz2, xyz3, xyz0], degree=3) for i in range(n)] # spread if multiple loops for i, crv in enumerate(crvs): rs.RotateObject(crv, [x0, y0, z0], 360 * float(i) / float(n)) # pipe if non-null radius is specified if line_radius != 0.0: pipes = [rs.AddPipe(crv, 0, line_radius) for crv in crvs] rs.DeleteObjects(crvs) crvs = pipes curves += crvs # output group group = rs.AddGroup() rs.AddObjectsToGroup(nodes + curves, group) return group
1] != 0.0 and final_arr[bone][frame][ 2] != 0.0: # do not consider values at origin if final_arr[bone][frame][ 2] != 0.0: # do not consider values with z = 0 if lastFrame == 0 or rs.Distance( final_arr[bone][frame], final_arr[bone][lastFrame]) > threshold: if pipe_bool == 'p': rs.AddPoint(final_arr[bone][frame]) else: linePoints.append(final_arr[bone][frame]) lastFrame = frame if pipe_bool != 'p': curveids[bone] = rs.AddCurve(linePoints) if pipe_bool == 's': rs.AddPipe(curveids[bone], 0, pipe_size) else: linePoints = [] lastFrame = 0 for frame in range(0, row_count): # for each frame of this bone if final_arr[b][frame][0] != 0.0 and final_arr[b][frame][ 1] != 0.0 and final_arr[b][frame][ 2] != 0.0: # do not consider values at origin if final_arr[b][frame][ 2] != 0.0: # do not consider values with z = 0 if lastFrame == 0 or rs.Distance( final_arr[b][frame], final_arr[b][lastFrame]) > threshold: if pipe_bool == 'p': rs.AddPoint(final_arr[b][frame])
def handrailGen(self, sender, e): flip = self.flipC.Checked hType = self.handrailTypeC.SelectedIndex handrailOffset = int(self.handrailOffsetC.Value) * scale tread = int(self.treadC.Value) * scale riser = int(self.riserC.Value) * scale numSteps = int(self.numStepsC.Value) hEndLength = int(self.handrailExtensionC.Value) * scale pipeDiameter = int(self.handrailDiameterC.Value) * scale hHeight = int(self.handrailHeightC.Value) * scale topLine = rs.AddLine(line[0], line[1]) rs.ObjectName(topLine, "BC6#DT5LCQX*#8r97Tquf5gNF") topPoint = line[0] genHandrail = self.genHandrailBool.Checked rs.EnableRedraw(False) if genHandrail == False: iteration = rs.ObjectsByName( "qe7g&G5LzXEvbudtPT8xCxQbisusFVqCPqMsiHK2jc") if iteration: rs.DeleteObjects(iteration) rs.EnableRedraw(True) if genHandrail == True: # Delete any existing iteration iteration = rs.ObjectsByName( "qe7g&G5LzXEvbudtPT8xCxQbisusFVqCPqMsiHK2jc") if iteration: rs.DeleteObjects(iteration) # get perp line - length of stair t = rs.CurveClosestPoint(topLine, topPoint) planeNormal = rs.CurveNormal(topLine) tangent = rs.CurveTangent(topLine, t) if flip == False: curveNormal = rs.VectorCrossProduct(planeNormal, tangent) else: curveNormal = rs.VectorReverse( rs.VectorCrossProduct(planeNormal, tangent)) # Get guide curve scaledV = rs.VectorReverse( rs.VectorScale(curveNormal, tread*numSteps)) ptGuide1 = rs.AddPoint(line[0]) ptGuide2 = rs.CopyObject(ptGuide1, scaledV) rs.MoveObjects([ptGuide1, ptGuide2], [ 0, 0, (riser*numSteps)*-1]) curve = rs.AddCurve([ptGuide1, ptGuide2]) # Get vector for step run vectorRun = rs.VectorCreate( topPoint, topPoint + curveNormal * tread) # Setup curves for handrail curve1 = curve curve2 = rs.MoveObject(rs.CopyObject(curve1, rs.VectorCreate(line[1], rs.CurveStartPoint(curve1))), [0, 0, (riser * numSteps)*-1]) midPoint = rs.CurveMidPoint(userCurve) # Main slanted handrail curve pt1 = rs.MoveObject(rs.MoveObject(rs.CurveStartPoint(curve1), vectorRun), [ 0, 0, hHeight + (riser*numSteps)]) pt2 = rs.MoveObject(rs.MoveObject( rs.CurveEndPoint(curve1), vectorRun), [0, 0, hHeight]) mainCurve = rs.AddCurve([pt1, pt2]) # Top leveled handrail curve at 300mm standard DDA pt3 = rs.CopyObject(pt1, rs.VectorReverse( rs.VectorScale(rs.VectorUnitize(vectorRun), hEndLength))) topCurve = rs.AddCurve([pt1, pt3]) # Bottom leveled handrail curve at 300mm standard DDA pt4 = rs.CopyObject(pt2, rs.VectorScale( rs.VectorUnitize(vectorRun), hEndLength)) bottomCurve = rs.AddCurve([pt2, pt4]) # Start list of construction geometry for later cleanup hGeoList = [curve1, curve2, pt1, pt2, mainCurve, pt3, topCurve, pt4, bottomCurve, ptGuide1, ptGuide2, curve, topLine] # IF STATEMENTS FOR HANDRAIL TYPE # 1 180 degree, no return if hType == 0: # Lower Handrail return hpt1 = rs.CopyObject(pt4, [0, 0, (pipeDiameter * 2) * -1]) hpt2 = rs.MoveObject(rs.CopyObject( pt4, [0, 0, pipeDiameter * -1]), rs.VectorScale(rs.VectorUnitize(vectorRun), pipeDiameter)) lowerH = rs.AddArc3Pt(pt4, hpt1, hpt2) # Upper Handrail return hpt3 = rs.CopyObject(pt3, [0, 0, (pipeDiameter * 2) * -1]) hpt4 = rs.MoveObject(rs.CopyObject(pt3, [0, 0, pipeDiameter * -1]), rs.VectorReverse( rs.VectorScale(rs.VectorUnitize(vectorRun), pipeDiameter))) upperH = rs.AddArc3Pt(pt3, hpt3, hpt4) # Draw leg upper lpt1 = rs.CurveMidPoint(topCurve) lpt2 = rs.CopyObject(lpt1, [0, 0, hHeight*-1]) lCurveUpper = rs.AddCurve([lpt1, lpt2]) # Draw leg lower lpt3 = rs.CopyObject(pt2, [0, 0, hHeight*-1]) lCurveLower = rs.AddCurve([pt2, lpt3]) # Make vectors to move handrails into place moveShort = rs.VectorScale(userVector, handrailOffset) moveLong = rs.VectorScale( userVector, rs.CurveLength(userCurve) - (handrailOffset*2)) # Join, offset skeleton hCurve = rs.JoinCurves( [mainCurve, topCurve, bottomCurve, lowerH, upperH]) hCurve1 = rs.CopyObject(hCurve, moveShort) lCurveUpper1 = rs.CopyObject(lCurveUpper, moveShort) lCurveLower1 = rs.CopyObject(lCurveLower, moveShort) # Pipe skeleton pipe1 = rs.AddPipe( hCurve1, 0, pipeDiameter/2, blend_type=0, cap=1) pipe2 = rs.AddPipe( lCurveUpper1, 0, pipeDiameter/2, blend_type=0, cap=1) pipe3 = rs.AddPipe( lCurveLower1, 0, pipeDiameter/2, blend_type=0, cap=1) # form list of generated geo handrailGeo1 = [pipe1, pipe2, pipe3] # Name geo for deletion for i in handrailGeo1: rs.ObjectName( i, "qe7g&G5LzXEvbudtPT8xCxQbisusFVqCPqMsiHK2jc") # copy handrailGeo2 = rs.CopyObjects(handrailGeo1, moveLong) # Cleanup construction linework hGeoList.extend([hpt1, hpt2, lowerH, hpt3, hpt4, upperH, lpt2, lpt3, lCurveLower, hCurve, hCurve1, lCurveUpper1, lCurveLower1, lCurveUpper]) rs.DeleteObjects(hGeoList) rs.EnableRedraw(True) # 2 180 degree, full return if hType == 1: rs.EnableRedraw(False) # Lower handrail return hpt1 = rs.CopyObject(pt4, [0, 0, (hEndLength/3)*-2]) hpt2 = rs.CopyObject(pt2, [0, 0, (hEndLength/3)*-2]) hCurve11 = rs.AddPolyline([pt4, hpt1, hpt2]) lowerH = rs.JoinCurves([bottomCurve, hCurve11]) # Upper handrail return hpt3 = rs.CopyObject(pt3, [0, 0, (hEndLength/3)*-2]) hpt4 = rs.CopyObject(rs.CurveMidPoint( topCurve), [0, 0, (hEndLength/3)*-2]) hCurve2 = rs.AddPolyline([pt3, hpt3, hpt4]) upperH = rs.JoinCurves([topCurve, hCurve2]) # Draw leg upper lpt1 = rs.CurveMidPoint(topCurve) lpt2 = rs.CopyObject(lpt1, [0, 0, hHeight*-1]) lCurveUpper = rs.AddCurve([lpt1, lpt2]) # Draw leg lower lpt3 = rs.CopyObject(pt2, [0, 0, hHeight*-1]) lCurveLower = rs.AddCurve([pt2, lpt3]) # Make vectors to move handrails into place moveShort = rs.VectorScale(userVector, handrailOffset) moveLong = rs.VectorScale( userVector, rs.CurveLength(userCurve) - (handrailOffset*2)) # Pipe skeleton move hCurve1 = rs.JoinCurves([lowerH, upperH, mainCurve]) rs.MoveObjects( [hCurve1, lCurveUpper, lCurveLower], moveShort) # Pipe pipe1 = rs.AddPipe( hCurve1, 0, pipeDiameter/2, blend_type=0, cap=1) pipe2 = rs.AddPipe( lCurveUpper, 0, pipeDiameter/2, blend_type=0, cap=1) pipe3 = rs.AddPipe( lCurveLower, 0, pipeDiameter/2, blend_type=0, cap=1) handrailGeo1 = [pipe1, pipe2, pipe3] # Name geo for deletion for i in handrailGeo1: rs.ObjectName( i, "qe7g&G5LzXEvbudtPT8xCxQbisusFVqCPqMsiHK2jc") # Move and copy into position handrailGeo2 = rs.CopyObjects(handrailGeo1, moveLong) # Cleanup hGeoList.extend([hpt1, hpt2, hCurve11, lowerH, hpt3, hpt4, hCurve2, upperH, lpt2, lCurveUpper, lpt3, lCurveLower, hCurve1]) rs.DeleteObjects(hGeoList) rs.EnableRedraw(True) # 3 Ground triangle return if hType == 2: rs.EnableRedraw(False) # Draw leg upper lpt1 = rs.CurveMidPoint(topCurve) lpt2 = rs.CopyObject(lpt1, [0, 0, hHeight*-1]) lCurveUpper = rs.AddCurve([lpt1, lpt2]) # Draw leg lower lpt3 = rs.CopyObject(pt2, [0, 0, hHeight*-1]) lCurveLower = rs.AddCurve([pt2, lpt3]) # Lower Return lowerH = rs.AddCurve([pt4, lpt3]) # Upper Return upperH = rs.AddCurve([pt3, lpt2]) # Make vectors to move handrails into place moveShort = rs.VectorScale(userVector, handrailOffset) moveLong = rs.VectorScale( userVector, rs.CurveLength(userCurve) - (handrailOffset*2)) # Join Curves and move hCurve = rs.JoinCurves( [mainCurve, topCurve, bottomCurve, lowerH, upperH]) rs.MoveObjects( [hCurve, lCurveUpper, lCurveLower], moveShort) # pipe pipe1 = rs.AddPipe(hCurve, 0, pipeDiameter / 2, blend_type=0, cap=1) pipe2 = rs.AddPipe( lCurveUpper, 0, pipeDiameter/2, blend_type=0, cap=1) pipe3 = rs.AddPipe( lCurveLower, 0, pipeDiameter/2, blend_type=0, cap=1) handrailGeo1 = [pipe1, pipe2, pipe3] # Name geo for deletion for i in handrailGeo1: rs.ObjectName( i, "qe7g&G5LzXEvbudtPT8xCxQbisusFVqCPqMsiHK2jc") # move and copy into place handrailGeo2 = rs.CopyObjects(handrailGeo1, moveLong) # Cleanup hGeoList.extend( [lpt2, lCurveUpper, lpt3, lCurveLower, lowerH, upperH, hCurve, topLine]) rs.DeleteObjects(hGeoList) rs.EnableRedraw(True) # 4 Ground return if hType == 3: rs.EnableRedraw(False) # Draw leg upper lpt1 = rs.CurveMidPoint(topCurve) lpt2 = rs.CopyObject(lpt1, [0, 0, hHeight*-1]) lCurveUpper = rs.AddCurve([lpt1, lpt2]) # Draw leg lower lpt3 = rs.CopyObject(pt2, [0, 0, hHeight*-1]) lCurveLower = rs.AddCurve([pt2, lpt3]) # Lower Return hpt1 = rs.CopyObject(pt4, [0, 0, hHeight*-1]) hCurve1 = rs.AddCurve([pt4, hpt1]) # Upper Return hpt2 = rs.CopyObject(pt3, [0, 0, hHeight*-1]) hCurve2 = rs.AddCurve([pt3, hpt2]) # Join curves hCurve = rs.JoinCurves( [mainCurve, topCurve, bottomCurve, hCurve1, hCurve2]) # Get Vectors moveShort = rs.VectorScale(userVector, handrailOffset) moveLong = rs.VectorScale( userVector, rs.CurveLength(userCurve) - (handrailOffset*2)) # move rs.MoveObjects( [hCurve, lCurveUpper, lCurveLower], moveShort) # Pipe pipe1 = rs.AddPipe(hCurve, 0, pipeDiameter / 2, blend_type=0, cap=1) pipe2 = rs.AddPipe( lCurveUpper, 0, pipeDiameter/2, blend_type=0, cap=1) pipe3 = rs.AddPipe( lCurveLower, 0, pipeDiameter/2, blend_type=0, cap=1) handrailGeo1 = [pipe1, pipe2, pipe3] # Name geo for deletion for i in handrailGeo1: rs.ObjectName( i, "qe7g&G5LzXEvbudtPT8xCxQbisusFVqCPqMsiHK2jc") # move and copy into place handrailGeo2 = rs.CopyObjects(handrailGeo1, moveLong) # Clean up hGeoList.extend([lpt2, lCurveUpper, lpt3, lCurveLower, hpt1, hCurve1, hpt2, hCurve2, hCurve, topLine]) rs.DeleteObjects(hGeoList) rs.EnableRedraw(True) # 5 Wall return if hType == 4: rs.EnableRedraw(False) # Draw leg upper lpt1 = rs.CurveMidPoint(topCurve) lpt2 = rs.CopyObject(lpt1, [0, 0, hHeight*-1]) lCurveUpper = rs.AddCurve([lpt1, lpt2]) # Draw leg lower lpt3 = rs.CopyObject(pt2, [0, 0, hHeight*-1]) lCurveLower = rs.AddCurve([pt2, lpt3]) # get vectors vector1 = rs.VectorScale(rs.VectorUnitize( rs.VectorReverse(userVector)), handrailOffset) vector2 = rs.VectorScale( userVector, rs.CurveLength(userCurve)) # Lower Return hpt1 = rs.CopyObject(pt4, vector1) hCurve1 = rs.AddCurve([pt4, hpt1]) # Upper Return hpt2 = rs.CopyObject(pt3, vector1) hCurve2 = rs.AddCurve([pt3, hpt2]) # Join main curves hCurveMain1 = rs.JoinCurves( [mainCurve, topCurve, bottomCurve]) # Get Vectors moveShort = rs.VectorScale(userVector, handrailOffset) moveLong = rs.VectorScale( userVector, rs.CurveLength(userCurve) - handrailOffset) # Copy hanrail 2 hCurveMain2 = rs.CopyObject(hCurveMain1, moveLong) hCurve3 = rs.CopyObject(hCurve1, vector2) hCurve4 = rs.CopyObject(hCurve2, vector2) lCurveUpper2 = rs.CopyObject(lCurveUpper, moveLong) lCurveLower2 = rs.CopyObject(lCurveLower, moveLong) # Join curves hCurveJoined1 = rs.JoinCurves( [hCurve1, hCurve2, hCurveMain1]) hCurveJoined2 = rs.JoinCurves( [hCurveMain2, hCurve3, hCurve4, ]) # Pipe pipe1 = rs.AddPipe( hCurveJoined1, 0, pipeDiameter/2, blend_type=0, cap=1) pipe2 = rs.AddPipe( lCurveLower, 0, pipeDiameter/2, blend_type=0, cap=1) pipe3 = rs.AddPipe( lCurveUpper, 0, pipeDiameter/2, blend_type=0, cap=1) pipe4 = rs.AddPipe( hCurveJoined2, 0, pipeDiameter/2, blend_type=0, cap=1) pipe5 = rs.AddPipe( lCurveUpper2, 0, pipeDiameter/2, blend_type=0, cap=1) pipe6 = rs.AddPipe( lCurveLower2, 0, pipeDiameter/2, blend_type=0, cap=1) handrailGeo1 = [pipe1, pipe2, pipe3, pipe3, pipe4, pipe5, pipe6] # Name geo for deletion for i in handrailGeo1: rs.ObjectName( i, "qe7g&G5LzXEvbudtPT8xCxQbisusFVqCPqMsiHK2jc") # Move handrail 1 into place rs.MoveObjects([pipe1, pipe2, pipe3], moveShort) # Cleanup hGeoList.extend([lpt2, lCurveUpper, lpt3, lCurveLower, hpt1, hCurve1, hpt2, hCurve2, hCurveMain1, hCurveMain2, hCurve3, hCurve4, lCurveUpper2, lCurveLower2, hCurveJoined1, hCurveJoined2]) rs.DeleteObjects(hGeoList) rs.EnableRedraw(True)
d = rs.Distance(pts_gcrv1[i], pts_gcrv2[i]) sf = -d * 0.3 # shear factor nz1 = pts_gcrv1[i][2] #n = new # z = coordinate nx1 = pts_gcrv1[i][0] + sf # x = coordinate ny1 = pts_gcrv1[i][1] # y = coordinate npts_gcrv1 = (nx1, ny1, nz1) spts_list1.append(npts_gcrv1) nz2 = pts_gcrv2[i][2] #n = new # z = coordinate nx2 = pts_gcrv2[i][0] - sf # x = coordinate ny2 = pts_gcrv2[i][1] # y = coordinate npts_gcrv2 = (nx2, ny2, nz2) spts_list2.append(npts_gcrv2) print("TEST", "Point added") scrv1 = rs.AddInterpCurve(spts_list1) scrv2 = rs.AddInterpCurve(spts_list2) pts_scrv1 = rs.DivideCurve(scrv1, div) pts_scrv2 = rs.DivideCurve(scrv2, div) rs.AddLoftSrf([gcrv1, scrv1]) rs.AddLoftSrf([gcrv2, scrv2]) #add the pipe for outer frame pipe_frame1 = rs.AddPipe(scrv1, 0, rad) pipe_frame2 = rs.AddPipe(scrv2, 0, rad)
import rhinoscriptsyntax as rs #get 2 curves & store them in list crvs = rs.GetObjects("select 2 curves") crv1 = crvs[0] crv2 = crvs[1] div = 25 #no of points the curve is divided rad1 = 0.25 #radius for the internal connections rad2 = rad1 * 2 #radius fore the frame #divide the curves and store the points in a list or 2 lists pts1 = rs.DivideCurve(crv1, div) pts2 = rs.DivideCurve(crv2, div) #makes the line between points and the internal pipe for i in range(len(pts1)): if rs.Distance(pts1[i], pts2[i]) > 0: lines = rs.AddLine(pts1[i], pts2[i]) pipe = rs.AddPipe(lines, 0, rad1) else: continue #add the pipe for outer frame pipe_frame1 = rs.AddPipe(crv1, 0, rad2) pipe_frame2 = rs.AddPipe(crv2, 0, rad2)
for nghd in data: # if nghd['name'] != 'Central Oakland': # continue # uncomment the above to try out one nghd border_points = nghd['border'] curve = rs.AddPolyline(border_points) surface = rs.AddPlanarSrf(curve) extrusion_line = rs.AddLine((0,0,0), (0,0,3)) solid = rs.ExtrudeSurface(surface, extrusion_line) rs.DeleteObjects([curve, surface, extrusion_line]) for pipe in nghd['pipes']: p0 = pipe[0] p1 = pipe[1] pipe_line = rs.AddLine((p0[0], p0[1], -.5), (p1[0], p1[1], 3.5)) pipe = rs.AddPipe(pipe_line, 0, 0.5, cap=2) rs.DeleteObject(pipe_line) new_solid = None try: new_solid = rs.BooleanDifference([solid], [pipe]) except: print "a boolean difference failed in " + nghd['name'] rs.DeleteObject(pipe) continue if new_solid == None: rs.DeleteObject(pipe) continue # boolean difference failed, just skip one pipe else: solid = new_solid
rad1 = 0.15 #radius for the downward structure rad2 = rad1 * 2 #radius fore the frame gpts_list1 = [] # list of new points for crv 1 gpts_list2 = [] # list of new points for crv 2 #makes the line between points for i in range(len(pts_crv1)): nz1 = pts_crv1[i][2] - gravity #n = new # z = coordinate nx1 = pts_crv1[i][0] # x = coordinate ny1 = pts_crv1[i][1] # y = coordinate npts_crv1 = (nx1, ny1, nz1) gpts_list1.append(npts_crv1) gline1 = rs.AddLine(pts_crv1[i], npts_crv1) #gravity line pipe_crv1 = rs.AddPipe(gline1, 0, rad1) nz2 = pts_crv2[i][2] - gravity #n = new # z = coordinate nx2 = pts_crv2[i][0] # x = coordinate ny2 = pts_crv2[i][1] # y = coordinate npts_crv2 = (nx2, ny2, nz2) gpts_list2.append(npts_crv2) gline2 = rs.AddLine(pts_crv2[i], npts_crv2) #gravity line pipe_crv2 = rs.AddPipe(gline2, 0, rad1) gcrv1 = rs.AddInterpCurve(gpts_list1) gcrv2 = rs.AddInterpCurve(gpts_list2) rs.AddPipe(gcrv1, 0, rad2) rs.AddPipe(gcrv2, 0, rad2)
#Platform of the base rs.CurrentLayer("Surface") rs.AddLoftSrf([L1, L2]) #Definition of parabola points rs.CurrentLayer("Points") for i in range(Ndiv + 1): x = Points1[i][0] P = [x, 0, Amp*(x-L)*(x + L)*(-1/10)] Points3.append(rs.AddPoint(P)) #Vertical lines btw Points1(base) and Points3 (Points form parabola) rs.CurrentLayer("Columns") for i in range(1, Ndiv): A_line = rs.AddLine(Points1[i], Points3[i]) pipe = rs.AddPipe(A_line, 0, r1,blend_type=0, cap=0, fit=False) rs.DeleteObject(A_line) rs.CopyObject(pipe, (0,W,0)) rs.DeleteObject(path) #Diagonal stiffeners btw Points1(base) and Points3(Parabola) rs.CurrentLayer("Diagonals") for i in range(Ndiv-1): A_line = rs.AddLine(Points1[i], Points3[i+1]) pipe = rs.AddPipe(A_line, 0, r1,blend_type=0, cap=0, fit=False) rs.DeleteObject(A_line) rs.CopyObject(pipe, (0,W,0)) #Top pipes of the bridge rs.CurrentLayer("Diagonals")
def pipe_lines(self): self.pipes = [] for i in range(0, len(self.lines)): self.pipes.append(rs.AddPipe(self.lines[i], 0, 0.25)) rs.DeleteObjects(self.lines)
def makePipe(lineID): pipe = rs.AddPipe(lineID, 0, 0.1, cap=1) return pipe
x = random.uniform(-100, x_range) y = random.uniform(-100, y_range) z = random.uniform(-100, z_range) pt = [x, y, z] return pt point1 = rs.AddPoint(-100, 0, 0) point2 = rs.AddPoint(100, 0, 0) #cloud = rs.PointAdd(point1, point2) #cloud = rs.AddPoints(point1) cloud = (point1, point2) line = rs.AddLine(point1, point2) pipe = rs.AddPipe(line, 0, 4) all_points = [] for i in range(0, 100): pt = rs.AddPoint(place_pts(100, 100, 100)) index = rs.PointArrayClosestPoint(cloud, pt) cp = cloud[index] vect = rs.VectorCreate(cp, pt) #move = rs.MoveObject(pt,vect) #vector = rs.VectorCreate(index, pt) #index_points = rs.PointArrayClosestPoint(pipe_points, pt) #vector = rs.VectorCreate(index_points, pt) #rs.VectorCreate() #unit_vector = rs.VectorUnitize(vector) #new_pt = rs.MoveObject(pt, unit_vector)
def main(): # get our curves profile, cross = get_two_curves() if profile is None or cross is None: return ################################################## # get bounding box for cross section cross_bbox = rs.BoundingBox([cross]) cmin, cmax = box_to_points(cross_bbox) cz_range = cmax[2] - cmin[2] cz = 0.5 * (cmax[2] + cmin[2]) c_ctr, _ = rs.CurveAreaCentroid(cross) # make sure it's planar in XY if cz_range > 1e-9: print 'cross section curve should be planar in XY plane' return ################################################## # get bounding box for profile profile_bbox = rs.BoundingBox([profile]) # make sure it's planar in in YZ pmin, pmax = box_to_points(profile_bbox) px_range = pmax[0] - pmin[0] if px_range > 1e-9: print 'profile curve should be planar in YZ plane' return ################################################## # get the point closest to the center for the # cross-section curve r, pc = get_inscribed_radius(cross, c_ctr) ################################################## # get the range of z-values for the profile curve _, _, z0 = pmin _, _, z1 = pmax ################################################## # build list of rings and list of points points = [] ring_pipes = [] # for each level for i in range(num_levels): # get the Z value of the ith plane u = float(i) / (num_levels-1) z = z0 + u*(z1 - z0) # build the i'th plane plane = rs.PlaneFromNormal([0, 0, z], [0, 0, 1], [1, 0, 0]) # find out where the plane intersects the profile curve intersect = rs.PlaneCurveIntersection(plane, profile) # there should be exactly one intersection of type 1 (point) if intersect is None or len(intersect) > 1 or intersect[0][0] != 1: print 'bad intersection' return # get the intersection point pi = intersect[0][1] # get the desired XY radius at this z value ri = abs(pi[1]) # we need to set up some transformations: # translate cross section curve down to z=0 T1 = rs.XformTranslation(mz.vec_mul(list(c_ctr), -1.0)) # scale it along XY by the ratio of radii S1 = rs.XformScale([ri/r, ri/r, 1.0]) # scale a piped cross section along Z by a vertical scale factor S2 = rs.XformScale([1.0, 1.0, ring_vscale]) # translate piped cross section up to our desired z value T2 = rs.XformTranslation([0, 0, z]) # scale and translate cross section curve ci = rs.TransformObject(cross, rs.XformMultiply(S1, T1), copy=True) # pipe it ring = rs.AddPipe(ci, [0, 1], [ring_rad, ring_rad]) # scale vertically and transform up ring = rs.TransformObject(ring, rs.XformMultiply(T2, S2)) # delete the copy of the cross section curve rs.DeleteObject(ci) # add to list of ring pipes ring_pipes.append(ring) # create a rotation by the i'th angle angle_i_deg = i*360.0/num_sides Ri = rs.XformRotation2(angle_i_deg, [0, 0, 1], [0, 0, 0]) # transform the closest point by rotation and scale pci = rs.PointTransform(pc, rs.XformMultiply(rs.XformMultiply(Ri, T2), S1)) # add to list of points points.append(pci) # we have built up a list of points for a single spiral of struts to connect, # now we need to pipe them all together and do the ArrayPolar thing around # the z axis # first build a single spiral of struts strut_pipes = [] for i0 in range(num_levels-1): i1 = i0+1 p0 = points[i0] p1 = points[i1] l01 = rs.AddLine(p0, p1) pipe = rs.AddPipe(l01, [0, 1], [strut_rad, strut_rad], cap=2) rs.DeleteObject(l01) strut_pipes.append(pipe) # then array polar around Z axis all_strut_pipes = [] all_strut_pipes += strut_pipes for j in range(1, num_sides): angle_j_deg = j*360.0/num_sides Rj = rs.XformRotation2(angle_j_deg, [0, 0, 1], [0, 0, 0]) all_strut_pipes += rs.TransformObjects(strut_pipes, Rj, copy=True) # now just select all the objects we created rs.SelectObjects(ring_pipes + all_strut_pipes) # done! print 'yay'
points1.append(w1.getLocation()) w2.step() points2.append(w2.getLocation()) parameterCounter = 0.0 parameterCounter1 = 0.0 parameterCounter2 = 0.0 for point in points: tempRadius = random.uniform(.05,.25) tempRadius1 = random.uniform(.05,.25) tempRadius2 = random.uniform(.05,.25) radii.append(tempRadius) radii1.append(tempRadius) radii2.append(tempRadius) parameters.append(parameterCounter) parameters1.append(parameterCounter) parameters2.append(parameterCounter) parameterCounter += 1/len(points) parameterCounter1 += 1/len(points) parameterCounter2 += 1/len(points) curve = rs.AddCurve(points) curve1 = rs.AddCurve(points1) curve2 = rs.AddCurve(points2) rs.AddPipe(curve, parameters, radii, 1, 2, False) rs.AddPipe(curve1, parameters1, radii1, 1, 2, False) rs.AddPipe(curve2, parameters2, radii2, 1, 2, False)
def AddLine(start, ends, radius, index): line = rs.AddLine(start, ends) pipe = rs.AddPipe(line, 0, radius) draw(pipe, index) return line
def output_frame(filename): global box_height global box_width global pipe_diameter # Import object from file join_string = str(input_directory + filename) combined_string = '!_Import ' + '"' + join_string + '"' rs.Command(combined_string) # Get all objects imported objs = rs.LastCreatedObjects(select=False)[0] # Close curve closed_curve = rs.CloseCurve(objs, 0.5) rs.DeleteObject(objs) # Rebuild curve to create smoother shape rs.RebuildCurve(closed_curve, 3, 100) # Pipe figure with radius of 0.25 piped = rs.AddPipe(closed_curve, 0, pipe_diameter)[0] rs.MoveObject(piped, [0, 0, 0]) bounding_pts = rs.BoundingBox([piped], view_or_plane=rs.WorldXYPlane()) maxX = 0 minX = 0 minY = 0 minZ = 0 for pt in bounding_pts: if pt[0] < minX: minX = pt[0] if pt[0] > maxX: maxX = pt[0] if pt[1] < minY: minY = pt[1] if pt[2] < minZ: minZ = pt[2] epsilon = 0.5 center = 0 one = [ center - (box_width / 2) - box_height, minY - epsilon, -1 * pipe_diameter ] two = [ center - (box_width / 2) - box_height, minY - epsilon, pipe_diameter ] three = [ center + (box_width / 2) + box_height, minY - epsilon, pipe_diameter ] four = [ center + (box_width / 2) + box_height, minY - epsilon, -1 * pipe_diameter ] five = [ center - (box_width / 2) - box_height, minY + epsilon, -1 * pipe_diameter ] six = [ center - (box_width / 2) - box_height, minY + epsilon, pipe_diameter ] seven = [ center + (box_width / 2) + box_height, minY + epsilon, pipe_diameter ] eight = [ center + (box_width / 2) + box_height, minY + epsilon, -1 * pipe_diameter ] bowx = rs.AddBox([two, three, four, one, six, seven, eight, five]) # rect = rs.AddRectangle(rs.WorldXYPlane(), box_width, box_height) #rect = rs.AddRectangle(rs.WorldXYPlane(), box_width, box_height) # Potentially use solid but smaller in height rect # rs.MoveObject(rect, [minX, minY - 3.0, minZ + pipe_diameter]) # piped_rect = rs.AddPipe(rect,0,pipe_diameter) rs.DeleteObject(closed_curve) # rs.DeleteObject(rect) rs.SelectObjects([piped, bowx]) rs.Command("_-Export " + output_directory + filename + '.stl' + " _Enter _Tolerance=.001 _Enter")
Poly_top = rs.CopyObject(Poly_base, (0, 0, H)) #Returns Curve Control Points Points1 = rs.CurvePoints(Poly_base) Points2 = rs.CurvePoints(Poly_top) #Construct the legs rs.CurrentLayer("Legs") #loop for lines which will be legs for i in range(N): A_lines = rs.AddLine(Points1[i], Points2[i]) #lines for the pipes #Add pipes pipe = rs.AddPipe(A_lines, 0, radius_pipes, blend_type=0, cap=1, fit=False) #Append each pipe to Legs Legs.append(pipe) #rs.DeleteObjects([A_lines, Poly_base, Poly_top]) #Create group rs.AddGroup("Legs") rs.AddObjectsToGroup(Legs, "Legs") #Construct the table top, draw offset curve offset_crv = rs.OffsetCurve(Poly_top, Cen_top, -(offset_dist), normal=None,
name_dot = rs.AddTextDot(value, point_list[i][j]) rs.ObjectLayer(name_dot, new_layer) else: # convert to string to float value = float(value) if(value > 0): value = value * factor # select vector vec_coord = norm_list[i][j] print(vec_coord) # scale vector with data from team vec = rs.VectorScale(vec_coord, value + 0.1 ) if(rs.VectorLength(vec) < 0.1): # unitize vector vec_unit = rs.VectorUnitize(vec) vec = rs.VectorScale(vec_unit, 0.2) print(point_list[i][j]) # copy point start_point = rs.AddPoint(point_list[i][j]) end_point = rs.CopyObject(start_point, vec) # create a line line = rs.AddLine(point_list[i][j], end_point) pipe = rs.AddPipe(line, [0.0, 1.0], [4, 4], cap = 1) rs.DeleteObjects([start_point, end_point, line]) rs.ObjectLayer(pipe, new_layer) rs.EnableRedraw = True