def create_board(self, size=CELL_SIZE): """Drawing a game board""" board_location_point = rs.GetPoint("Set board starter point") if board_location_point: self.board_location_point = board_location_point point = self.board_location_point self.grid = [] for i in range(3): row = [] for j in range(3): x1 = point[0] + i * size y1 = point[1] + j * size x2 = point[0] + (i + 1) * size y2 = point[1] + (j + 1) * size row.append([(x1, y1), (x2, y2)]) self.grid.append(row) rectangles = [ rs.AddRectangle((point[0], point[1] + size - size * .025, 0), size * 3, size * .05), rs.AddRectangle((point[0], point[1] + 2 * size - size * .025, 0), size * 3, size * .05), rs.AddRectangle((point[0] + size - size * .025, point[1], 0), size * .05, size * 3), rs.AddRectangle((point[0] + 2 * size - size * .025, point[1], 0), size * .05, size * 3) ] rs.CurveBooleanUnion(rectangles) rs.DeleteObjects(rectangles)
def make_slots(W, L): g_W = 6 #20/L or 14/L g_L = min(W / 3, 35) #3dis grip = rs.AddRectangle([0, 0, 0], g_W, g_L) c, _ = rs.CurveAreaCentroid(grip) return [grip, c, g_W, g_L]
def drawEvaluateValue(list_evaluate): frame = 5000 original_point = 5000 step_x_axis = 100 plane = rs.WorldXYPlane() xform = rs.XformTranslation([0, 5000, 0]) plane1 = rs.PlaneTransform(plane, xform) rs.AddRectangle(plane1, frame, frame) evaluate_sum = [] for i in range(len(list_evaluate)): evaluate_sum.append(sum(list_evaluate[i])) max_value = max(evaluate_sum) min_value = min(evaluate_sum) # if 1000 > max_value > 100: # # if 10000 > max_value >= 1000: point_list = [] for i in range(len(evaluate_sum)): value = evaluate_sum[i] # print("evaluate_sum", evaluate_sum[i]) new_value = remap(value, max_value, 0, 5000, 0) # print("new_value", new_value) pt = rs.AddPoint(i * step_x_axis, original_point + new_value, 0) point_list.append(pt) rs.AddPolyline(point_list)
def draw(pts): rs.EnableRedraw(0) sleep(0.05) RhinoApp.Wait() for i in range(4): for j in range(4): if recs[i][j]: rs.DeleteObject(recs[i][j]) if tags[i][j]: rs.DeleteObject(tags[i][j]) if pts[i][j]: recs[i][j] = rs.AddRectangle( rs.PlaneFromNormal((i + 0.1, j + 0.1, 0), (0, 0, 1)), 0.8, 0.8) tags[i][j] = rs.AddText(pts[i][j], (i + 0.5, j + 0.5, 0), 0.2 + (0.1 / len(str(pts[i][j]))), 'Arial', 0, 131074) if pts[i][j] <= 4: rs.ObjectColor(tags[i][j], (245, 245, 220)) rs.ObjectColor(recs[i][j], (245, 245, 220)) if 8 <= pts[i][j] <= 16: rs.ObjectColor(tags[i][j], (245, 97, 0)) rs.ObjectColor(recs[i][j], (245, 97, 0)) if 32 <= pts[i][j] <= 64: rs.ObjectColor(tags[i][j], (245, 7, 0)) rs.ObjectColor(recs[i][j], (245, 9, 0)) if pts[i][j] > 64: rs.ObjectColor(tags[i][j], (245, 197, 44)) rs.ObjectColor(recs[i][j], (245, 197, 44)) rs.EnableRedraw(1)
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 createAirplane(): #CREATE FUSELAGE rectangleFuselage = rs.AddRectangle(rs.WorldXYPlane(), Fw, Fh) endPointsF = rs.PolylineVertices(rectangleFuselage) fPtsB = offsetPoints(Fpb, endPointsF[0], endPointsF[1]) fPtsR = offsetPoints(Fpr, endPointsF[1], endPointsF[2]) fPtsT = offsetPoints(Fpt, endPointsF[2], endPointsF[3]) fPtsL = offsetPoints(Fpl, endPointsF[3], endPointsF[0]) fPtsL.append(fPtsB[0]) fCurveOpen = rs.AddCurve(fPtsB + fPtsR + fPtsT + fPtsL, 2) #CREATE WING SLOT wingSlotStart = rs.VectorAdd(endPointsF[0], (Fwx, Fwy, 0)) wingSlotEnd = rs.VectorAdd(wingSlotStart, (Fw - Fwx + maxPointOffset * 2, 0, 0)) wingSlot = rs.AddLine(wingSlotStart, wingSlotEnd) wingSlotOffset = rs.OffsetCurve(wingSlot, (0, 1, 0), 1 / 32) rs.AddLine(rs.CurveStartPoint(wingSlot), rs.CurveStartPoint(wingSlotOffset)) #CREATE WING wPlaneOffY = Wh + 1 wPlaneOffX = Fw / 2 wingPlane = rs.MovePlane(rs.WorldXYPlane(), (wPlaneOffX, -wPlaneOffY, 0)) rectangleWing = rs.AddRectangle(wingPlane, Ww, Wh) endPointsW = rs.PolylineVertices(rectangleWing) wPtsB = offsetPoints(Wpb, endPointsW[0], endPointsW[1]) wPtsR = offsetPoints(Wps, endPointsW[1], endPointsW[2]) wPtsT = offsetPoints(Wpt, endPointsW[2], endPointsW[3]) wPtsT.append(endPointsW[3]) wPtsB.insert(0, endPointsW[0]) wingCurve = rs.AddCurve(wPtsB + wPtsR + wPtsT) #wingLine = rs.AddLine(endPointsW[3],endPointsW[0]) rs.MirrorObject(wingCurve, endPointsW[3], endPointsW[0], True) #CREATE WING GROOVE wingGrooveStart = rs.VectorAdd(endPointsW[3], (-1 / 64, maxPointOffset, 0)) wingGrooveEnd = rs.VectorAdd(wingGrooveStart, (0, -(maxPointOffset + Wh * Wsd), 0)) wingGroove = rs.AddLine(wingGrooveStart, wingGrooveEnd) wingGrooveOffset = rs.OffsetCurve(wingGroove, (1, 0, 0), -1 / 32) rs.AddLine(rs.CurveEndPoint(wingGroove), rs.CurveEndPoint(wingGrooveOffset)) #DELETE RECTANGLES rs.DeleteObject(rectangleFuselage) rs.DeleteObject(rectangleWing)
def createSlits(data, width, height): for i in range(0, len(data)): rect = rs.AddRectangle(rs.WorldXYPlane(), width, height) rs.MoveObject(rect, [data[i][0], data[i][2], 0]) export_string = '!_Export ' + '"' + str(output_directory + 'placements') + '"' rs.Command(export_string)
def placeSlits(data, width, height): for i in range(0, len(data)): rect = rs.AddRectangle(rs.WorldXYPlane(), height, width) rs.MoveObject(rect, [data[i][0], data[i][2], 0]) rs.LastCreatedObjects(select=True) # export_string = '!_Export ' + '"' + str(output_directory + 'placements') + '"' # rs.Command(export_string) filename = 'placements.ai' rs.Command("_-Export " + output_directory + filename + " _Enter _Color=RGB _Enter")
def draw_x(self, point, size=CELL_SIZE): """Drawing X""" x = point[0] - size * .025 y = point[1] - (size * .75) / 2 r = rs.AddRectangle((x, y, 0), size * .05, size * .75) rectangles = [ rs.RotateObject(r, point, 45, copy=True), rs.RotateObject(r, point, -45, copy=True) ] rs.DeleteObject(r) rs.CurveBooleanUnion(rectangles) rs.DeleteObjects(rectangles)
def main(): max_flrs = 9999 # maximum number of folders to open max_fils = 9999 # maximum number of files to open in each folder folder_tic = time.clock() fdr_cnt = 0 for root, dirs, files in walklevel(src_path): print("{}\t {}".format(fdr_cnt, root)) #if (root == src_path): continue fil_cnt = 0 for full_filename in files: filename, file_extension = os.path.splitext(full_filename) if file_extension != ".3dm": continue file_tic = time.clock() filepath = os.path.join(root, full_filename) rs.DocumentModified(False) rs.Command('_-Open {} _Enter'.format('"' + filepath + '"')) pln = rs.PlaneFromPoints((100, 0, 0), (0, 100, 0), (100, 100, 0)) rs.AddRectangle(pln, 100, 100) set_active_view("Origin_SW_ISO") view = rs.CurrentView() set_disp_mode(disp_mode) rs.Redraw() """ rs.ViewProjection(view,2) rs.ViewCameraTarget(view,cam_pos,tar_pos) rs.ViewCameraLens(view,lens_len) rs.ZoomExtents(view) #rs.ViewCameraLens(view,25) """ capture_view_antialias( os.path.join(tar_path, "{}.png".format(filename)), image_size) t = round(time.clock() - file_tic) print(filename + "\ttime:\t" + str(t)) fil_cnt += 1 if fil_cnt > max_fils: break fdr_cnt += 1 if fdr_cnt > max_flrs: break t = round(time.clock() - folder_tic) print("TOTAL\ttime:\t" + str(t))
def RunCommand( is_interactive ): margin = 5 L, W = 810, 455 basept = Rhino.Geometry.Point3d(0,0,0) L = unit_convert(L) W = unit_convert(W) margin = unit_convert(margin) go = Rhino.Input.Custom.GetPoint() opt_L = Rhino.Input.Custom.OptionDouble(L,0.2,10000) opt_W = Rhino.Input.Custom.OptionDouble(W,0.2,10000) go.SetCommandPrompt("Pick lower left corner of lasercut area or Enter to place at origin. Default sheet size is L=%.2f, W=%.2f" % (L,W)) go.AddOptionDouble("Length", opt_L) go.AddOptionDouble("Width", opt_W) go.AcceptNothing(True) while True: res = go.Get() if res == Rhino.Input.GetResult.Option: continue elif res == Rhino.Input.GetResult.Cancel: return elif res == Rhino.Input.GetResult.Nothing: pass elif res == Rhino.Input.GetResult.Point: basept = go.Point() break layer_dict = wla.get_lcut_layers() plane = rs.WorldXYPlane() plane = rs.MovePlane(plane,basept) inner_rect = rs.AddRectangle(plane,L-margin*2,W-margin*2) plane = rs.MovePlane(plane, rs.PointAdd(basept, [-margin,-margin,0])) outer_rect = rs.AddRectangle(plane, L, W) rs.ObjectLayer([inner_rect, outer_rect],"XXX_LCUT_00-GUIDES") rs.SelectObjects([inner_rect,outer_rect]) return True
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 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 get_inner_box(bb_dims, tol, T_IBOX, TOL_INSIDE): """input: bbdims float(w,l,h). l is longest dimension. tol float: percentage "give" to have T_IBOX: thickness in mm T_OBOX: thickness in mm TOL_INSIDE: additional absolute tolerance added to the inner dimension of the box return: br: list of four points representing the bounding rectangle of the output. """ W = (1 + tol) * bb_dims[0] + T_IBOX * 2 + TOL_INSIDE * 2 L = (1 + tol) * bb_dims[1] + T_IBOX * 2 + TOL_INSIDE * 2 H = (1 + tol) * bb_dims[2] + T_IBOX * 2 + TOL_INSIDE * 1 - 0.1 * T_IBOX bottom = rs.AddRectangle(ORIGIN_IB, L - 2, W - 2) # top: overall dim - material + rabet - lid tolerance # print L - T_IBOX*2 - TOL_LID_ABSOLUTE*2 # print L - T_IBOX*2 - TOL_LID_ABSOLUTE*2 top = rs.AddRectangle([0, W + LCUT_GAP, 0], L - T_IBOX * 2 - TOL_LID_ABSOLUTE * 2, W - T_IBOX * 2 - TOL_LID_ABSOLUTE * 2) short_a = rs.AddRectangle([L + LCUT_GAP, 0, 0], W - 2 * T_IBOX, H - T_IBOX) short_b = rs.AddRectangle([L + LCUT_GAP, H + LCUT_GAP - T_IBOX, 0], W - 2 * T_IBOX, H - T_IBOX) long_a = rs.AddRectangle([L + W + LCUT_GAP * 2 - 2 * T_IBOX, 0, 0], L, H - T_IBOX) long_b = rs.AddRectangle( [L + W + LCUT_GAP * 2 - 2 * T_IBOX, H + LCUT_GAP - T_IBOX, 0], L, H - T_IBOX) grip_data = make_slots(bb_dims[0], bb_dims[1]) desired_grip_gap = 130 if bb_dims[1] > desired_grip_gap * 1.4: slots = add_slots(top, grip_data, desired_grip_gap) else: slots = add_slots(top, grip_data, bb_dims[1] / 20) rs.ObjectLayer(slots, LCUT_NAMES[1]) all_geo = [bottom, top, short_a, short_b, long_a, long_b] rs.ObjectLayer(all_geo, LCUT_NAMES[1]) br = rs.BoundingBox(all_geo)[:4] SELECT_GUIDS.extend(all_geo) SELECT_GUIDS.extend(slots) return br
def add_cube_w_material(count): for i in xrange(count): for j in xrange(count): ### define pt, plane tmp_pt = rs.AddPoint(i * 2, j * 2, 0) tmp_pln = rs.PlaneFromPoints(tmp_pt, rs.PointAdd(tmp_pt, (1,0,0)), rs.PointAdd(tmp_pt, (0,1,0))) ### define extrude line line_ex = rs.AddLine((0,0,0), (0,0,1)) ### draw rect tmp_crv = rs.AddRectangle(tmp_pln, 1,1) tmp_surf = rs.AddPlanarSrf(tmp_crv) tmp_box = rs.ExtrudeSurface(tmp_surf, line_ex, True) ### set color rs.AddMaterialToObject(tmp_box) index = rs.ObjectMaterialIndex(tmp_box) rs.MaterialName(index, str(i) + "_" +str(j)) rs.MaterialColor(index, ((255 / count) * i, 255 - ((255 / count) * j), 255 - ((255 / count) * j))) # name = rs.MaterialName(index) # print name ### delete rs.DeleteObject(tmp_pt) rs.DeleteObject(tmp_crv) rs.DeleteObject(tmp_surf) rs.DeleteObject(line_ex)
def row(x, y, counter=0): print 'new height is {}'.format(y) selH = heights[random.randint(0, len(heights) - 1)] lastH.append(selH) print 'selected height is {}'.format(lastH[-1]) for i in range(panelX): o = [x, y, 0] plane = rs.PlaneFromNormal(o, [0, 0, 1]) selW = widths[random.randint(0, len(widths) - 1)] if len(lastW) > panelX and selW == lastW[-panelX]: selW = widths[random.randint(0, len(widths) - 1)] else: lastW.append(selW) rect = rs.AddRectangle(plane, selW, selH) bricks.append(rect) x += lastW[-1] + 5 counter += 1 newx = 0 newy = sum(lastH) + 5 * len(lastH) print 'new y is {}'.format(newy) if counter <= panelY: print 'continue, count {}'.format(counter) row(newx, newy, counter)
def CreateBoard(realWidth, realLength, count, sideSafety): boardCreated = [] # stores all board GUID in order spacing = 550 # unit in mm rowMax = 10 width = realWidth - 2 * sideSafety length = realLength - 2 * sideSafety curPlane = rs.WorldXYPlane() # Create it's own board layer boardLayer = rs.AddLayer("Board Modified", Color.Red, True, True) rs.CurrentLayer(boardLayer) for i in range(0, count): localRowCount = i % rowMax localColCount = i // rowMax if localRowCount == 0 & localColCount != 0: localColCount -= 1 tempBoard = rs.AddRectangle(curPlane, width, length) rs.MoveObject(tempBoard, ((width + spacing) * localRowCount, (length + spacing) * localColCount, 0)) boardCreated.append(tempBoard) del tempBoard # numbering for board created (can consider inside the for loop # of outside but addText works with either a point or plane. return boardCreated
def rc_unroll_ortho(): go = Rhino.Input.Custom.GetObject() go.GeometryFilter = Rhino.DocObjects.ObjectType.Brep default_thickness = sticky["thickness"] if sticky.has_key( "thickness") else 5.5 default_lid = sticky["lid"] if sticky.has_key("lid") else False opt_thickness = Rhino.Input.Custom.OptionDouble(default_thickness, 0.2, 1000) opt_lid = Rhino.Input.Custom.OptionToggle(default_lid, "No", "Yes") go.SetCommandPrompt( "Select breps to unroll. Breps must be orthogonal (faces at 90 degree angles)" ) go.AddOptionDouble("Thickness", opt_thickness) go.AddOptionToggle("Lids", opt_lid) go.GroupSelect = True go.SubObjectSelect = False go.AcceptEnterWhenDone(True) go.AcceptNothing(True) go.EnableClearObjectsOnEntry(False) go.EnableUnselectObjectsOnExit(False) go.GroupSelect = True go.SubObjectSelect = False go.DeselectAllBeforePostSelect = False res = None bHavePreselectedObjects = False while True: res = go.GetMultiple(1, 0) #If new option entered, redraw a possible result if res == Rhino.Input.GetResult.Option: #print res go.EnablePreSelect(False, True) continue #If not correct elif res != Rhino.Input.GetResult.Object: return Rhino.Commands.Result.Cancel if go.ObjectsWerePreselected: bHavePreselectedObjects = True go.EnablePreSelect(False, True) continue break rs.EnableRedraw(False) LID = opt_lid.CurrentValue THICKNESS = opt_thickness.CurrentValue global LCUT_INDICES LCUT_INDICES = wla.get_lcut_layers() #Get geometry and object lists brep_obj_list = [] brep_geo_list = [] brep_ids_list = [] for i in xrange(go.ObjectCount): b_obj = go.Object(i).Object() brep_obj_list.append(b_obj) #For Debug and reference... #brep_geo_list.append(b_obj.Geometry) #brep_ids_list.append(b_obj.Id) #get information for each piece to be output. #future implementation should use bounding dims and curves rather than dimension-based system. unrolled_brep_info = [] lid_info = [] SELECT_GUIDS = [] for i, obj in enumerate(brep_obj_list): #geometry prep: convert extrusions to breps if str(obj.ObjectType) != "Brep": new_brep = wru.extrusion_to_brep(obj.Geometry) else: new_brep = obj.Geometry #pull the brep sides info for this solid this_brep_side_info = get_brep_sides_info(new_brep, THICKNESS) unrolled_brep_info.append(this_brep_side_info) num_sides = len(this_brep_side_info.dims) #pull the lid info for this solid if LID == True: this_brep_lid_info = get_brep_lid_info(new_brep, num_sides, THICKNESS) lid_info.append(this_brep_lid_info) #get dims needed to place this solid's outline curves brep_output_bounding_heights = [] for i, brep_side_info in enumerate(unrolled_brep_info): if LID == True: brep_output_bounding_heights.append( max(brep_side_info.boundingDims.y, lid_info[i].dims.y) ) #lid info needs to become a named tuple as well. else: brep_output_bounding_heights.append(brep_side_info.boundingDims.y) ybase = 0 #each solid for i, brep_side_info in enumerate(unrolled_brep_info): top_label_text = wut.number_to_letter(i) prefix = top_label_text + "-" xbase = 0 #each piece for j, piecedims in enumerate(brep_side_info.dims): face_label = prefix + str(brep_side_info.labelNums[j]) rect = rs.AddRectangle([xbase, ybase, 0], piecedims.x, piecedims.y) dot = rs.AddTextDot(face_label, rs.CurveAreaCentroid(rect)[0]) rs.ObjectLayer(dot, "XXX_LCUT_00-GUIDES") rs.ObjectLayer(rect, "XXX_LCUT_01-CUT") SELECT_GUIDS.extend([rect, dot]) xbase += piecedims[0] + GAP_SIZE #add the lids if LID == True: #transform the lid curve to the basepoint lid_curve = lid_info[i].outline p1 = rs.WorldXYPlane() p2 = rs.PlaneFromNormal([xbase, ybase, 0], [0, 0, 1], [1, 0, 0]) orient = Rhino.Geometry.Transform.ChangeBasis( rs.coerceplane(p2), rs.coerceplane(p1)) lid_curve.Transform(orient) #add the curve to the document crv_1 = wru.add_curve_to_layer(lid_curve, LCUT_INDICES[1]) crv_2 = rs.CopyObject( crv_1, [lid_info[i].dims.x + GAP_SIZE, 0, 0 ]) #change this to use a transform; it's nasty. #add text dot face_label_1 = prefix + str(len(brep_side_info.dims)) face_label_2 = prefix + str(len(brep_side_info.dims) + 1) dot_1 = rs.AddTextDot(face_label_1, rs.CurveAreaCentroid(crv_1)[0]) dot_2 = rs.AddTextDot(face_label_2, rs.CurveAreaCentroid(crv_2)[0]) rs.ObjectLayer([dot_1, dot_2], "XXX_LCUT_00-GUIDES") SELECT_GUIDS.extend([crv_1, crv_2, dot_1, dot_2]) top_label = rs.AddTextDot(top_label_text, brep_side_info.topLabelPt) rs.ObjectLayer(top_label, "XXX_LCUT_00-GUIDES") ybase += brep_output_bounding_heights[i] + GAP_SIZE * 4 sticky["thickness"] = THICKNESS sticky["lid"] = LID rs.UnselectAllObjects() rs.SelectObjects(SELECT_GUIDS) rs.Redraw() rs.EnableRedraw(True)
__author__ = "billpower" __version__ = "2019.12.25" import rhinoscriptsyntax as rs plane = rs.WorldXYPlane() #获取xy以原点为中心的参考平面 rectangle = rs.AddRectangle(plane,40,40) dpointsCoordinate = rs.DivideCurve(rectangle,10) #等分10矩形 dpoints = rs.AddPoints(dpointsCoordinate) #增加等分点 print(dpoints) format = "point_%s" #格式化字符串的模式 dpointe = [] i = 0 for i in range(len(dpoints)): dpointe.append(format % str(i)) #格式化字符串并逐一追加到列表 print(dpointe) dpointx = list(range(len(dpoints))) #建立等分点索引 print(dpointx)
rs.AddPoint(mpoint1) #在rhino空间中增加每次移动的点 rangeh = 4 #定义Y方向上复制点的次数 dpoints = {} #定义空的字典,放置所有移动的点,每一横排的点放置于一个单独的列表中,作为值 mpointh = [] #放置所有点的空列表 deletep = [] #放置每一次内部循环即横排点的空列表,用于字典 #循环Y方向上的复制点的次数 for i in range(rangeh): matrixh = rs.XformTranslation((0, i * multiplev, 0)) #建立Y方向上的变换矩阵 for m in range(len(mpoints)): pointh = rs.PointTransform(mpoints[m], matrixh) #按照变换矩阵逐个移动每一个点 rs.AddPoint(pointh) #在rhino空间中增加每次移动点 mpointh.append(pointh) #将点加入列表 deletep.append(pointh) dpoints[i] = deletep #加入字典 deletep = [] print(dpoints) #提取字典键的值 hifirst = dpoints.get(1) print(len(hifirst)) #建立矩形 plane = rs.WorldXYPlane() #定义参考平面,建立矩形 h = 5 w = 5 for i in range(len(mpointh)): mplane = rs.MovePlane(plane, mpointh[i]) rectangle = rs.AddRectangle(mplane, w, h)
def make_floor_board(b): l = b.tof[4].section - b.tof[3].section - .5 / 12 rs.AddRectangle([0, 0, 0], l, 2. / 12)
import rhinoscriptsyntax as rs plane = rs.WorldYZPlane() j = 0 for i in range(8): plane = rs.RotatePlane(plane, j, [1, 1, 0]) j = j + 45 rs.AddRectangle(plane, 10.0, 25.0)
def piece(layers, maxScale): curves = [] initialRadii = [] results = [] for i in range(count): initialRadii.append(random.uniform(minScale * maxScale, maxScale)) # outerExtrusions outerExtrusions = [] radii = initialRadii[:] for layer in range(layers): height = layer * layerHeight smooth(radii, smoothAmount) shrink(radii, outerReduce) scale(radii, random.uniform(1 - wiggle, 1 + wiggle)) scale(radii, upwardsShaping(layer / (layers - 1))) vertices = [] for i in range(count): theta = 2 * math.pi * i / count vertices.append((math.sin(theta) * radii[i], math.cos(theta) * radii[i], height)) vertices.append(vertices[0]) curve = rs.AddCurve(vertices, 5) curves.append(curve) if complete: extrusion = rs.ExtrudeCurveStraight(curve, (0, 0, 0), (0, 0, layerHeight)) rs.CapPlanarHoles(extrusion) outerExtrusions.append(extrusion) if not hollow: results.append(extrusion) if hollow: for i in range(shrinkPasses): shrink(radii, innerReduce) # innerExtrusions for layer in range(layers): actualLayer = layers - layer - 1 height = actualLayer * layerHeight smooth(radii, smoothAmount) shrink(radii, innerReduce) vertices = [] for i in range(count): theta = 2 * math.pi * i / count vertices.append((math.sin(theta) * radii[i], math.cos(theta) * radii[i], height)) vertices.append(vertices[0]) curve = rs.AddCurve(vertices, 5) curves.append(curve) if complete: extrusion = rs.ExtrudeCurveStraight(curve, (0, 0, 0), (0, 0, layerHeight)) rs.CapPlanarHoles(extrusion) result = rs.BooleanDifference(outerExtrusions[actualLayer], extrusion) results.append(result) if downwards: radii = initialRadii[:] for layer in range(downwardsLayers): height = -(layer + 1) * layerHeight smooth(radii, smoothAmount) shrink(radii, downwardsReduce) scale(radii, random.uniform(1 - wiggle, 1 + wiggle)) scale(radii, downwardsShaping(layer / (downwardsLayers - 1))) vertices = [] for i in range(count): theta = 2 * math.pi * i / count vertices.append((math.sin(theta) * radii[i], math.cos(theta) * radii[i], height)) vertices.append(vertices[0]) curve = rs.AddCurve(vertices, 5) curves.append(curve) if complete: extrusion = rs.ExtrudeCurveStraight(curve, (0, 0, 0), (0, 0, layerHeight)) rs.CapPlanarHoles(extrusion) outerExtrusions.append(extrusion) if not hollow: results.append(extrusion) if buildScaffolding: scaffoldBase = rs.AddRectangle( (-scaffoldSide / 2, -scaffoldSide / 2, 0), scaffoldSide, scaffoldSide) scaffold = rs.ExtrudeCurveStraight(scaffoldBase, (0, 0, 0), (0, 0, (layers - 1) * layerHeight)) rs.CapPlanarHoles(scaffold) rs.DeleteObject(scaffoldBase) results.append(scaffold) if complete: rs.DeleteObjects(curves) rs.AddObjectsToGroup(results, rs.AddGroup()) return results else: rs.AddObjectsToGroup(curves, rs.AddGroup()) return curves
def rectFrame(): return rs.AddRectangle(rs.WorldXYPlane(), Secx, Secy)
bottom_planes.append(planes) # Rotate planes on ZAxis rotated_planes = [] for i in bottom_planes: plane = rs.ViewCPlane() rndm_angle = random.randrange(-5, 5) rotated_z = rs.RotatePlane(i, rndm_angle, planes.ZAxis) # Tilt control tilt = random.randrange(-5, 5) * max_tilt rotated_x = rs.RotatePlane(rotated_z, tilt, planes.XAxis) rotated_planes.append(rotated_x) # Create solids solids = [] lines = [] for j in range(0, len(rotated_planes)): line = rs.AddLine(bottom_pts[j], top_pts[j]) lines.append(line) tilt = random.randrange(-5, 5) * max_tilt rot_lines = rs.RotateObject(line, bottom_pts[j], tilt, planes.XAxis, copy=False) rct = rs.AddRectangle( rotated_planes[j], rg.Interval(-0.5 * block_w, 0.5 * block_w), rg.Interval(-0.5 * block_d, 0.5 * block_d)) solid = rs.ExtrudeCurve(rct, rot_lines) sld = rs.CapPlanarHoles(solid) solids.append(solid) print('Ivan Perez | [email protected] | Bogotá | Colombia')
import rhinoscriptsyntax as rs plane = rs.WorldYZPlane() j = 0 for i in range(8): plane = rs.RotatePlane(plane, j, [1, 1, 1]) j = j + 45 rs.AddRectangle(plane, 25.0, 25.0) plane = rs.WorldZXPlane() for i in range(8): plane = rs.RotatePlane(plane, j, [1, 1, 1]) j = j + 45 rs.AddRectangle(plane, 25.0, 25.0) plane = rs.WorldXYPlane() for i in range(8): plane = rs.RotatePlane(plane, j, [1, 1, 1]) j = j + 45 rs.AddRectangle(plane, 25.0, 25.0)
rs.MoveObject( listOfLists[i + 1], rs.VectorCreate(findAnchorPoint(listOfLists[i]), findAnchorPoint(listOfLists[i + 1]))) rs.MoveObject(listOfLists[i + 1], (0, findVOffset(listOfLists[i + 1]), 0)) #Now to create the square bounding box for it. initialBox = rs.BoundingBox(sortedCurves) iBoxX = rs.Distance(initialBox[0], initialBox[1]) iBoxY = rs.Distance(initialBox[0], initialBox[3]) if iBoxX >= iBoxY: boxDim = iBoxX else: boxDim = iBoxY initialBorder = rs.AddRectangle(rs.WorldXYPlane(), boxDim, boxDim) iBBox = rs.BoundingBox(initialBorder) rs.MoveObject(initialBorder, rs.VectorCreate(initialBox[3], iBBox[3])) centroid = rs.CurveAreaCentroid(initialBorder) initialBorder = rs.ScaleObject(initialBorder, centroid[0], [1.125, 1.125, 1.125], False) #Align all the rows horizontally tCenterLine = boxDim / 2 for group in listOfLists: gBox = rs.BoundingBox(group) gBoxDim = rs.Distance(gBox[0], gBox[1]) iCenterLine = gBoxDim / 2 htranslation = tCenterLine - iCenterLine rs.MoveObject(group, (htranslation, 0, 0))
nRows = 6 wSquare = 100 plane = rs.WorldXYPlane() allRects = [] gridRects = [] # Add random rect from the grid rs.AddLayer("Rects") for r in range(0,nRows): for c in range(0, nCols): origin = (start[0] + wSquare*r, start[1] + wSquare*c, start[2]) plane = rs.MovePlane(plane,origin) rn = random.uniform(0,10) if(rn<2): newRect = rs.AddRectangle(plane, wSquare, wSquare) rs.ObjectLayer(newRect, "Rects") gridRects.append(newRect) allRects.append(newRect) # Rotate all rects from the grid for rect in gridRects: for ntimes in range(1,4): newRect = rs.RotateObject( rect , start , 15.0*ntimes, None, True ) rs.ObjectLayer(newRect, "Rects") allRects.append(newRect) # Mirror all rects using Y axe mirrorYRects = [] for rect in allRects: newRect = rs.MirrorObject( rect, start, end, True )
def makeFireStair(rect, landingLevels): #HARD VARIABLES minStairWidth = 1.118 minHeadroom = 2.032 maxRunRise = 3.658 minNumRisers = 3 minGapSize = .2 minTread = .280 maxTread = .400 minRiser = .100 maxRiser = .180 thickness = .25 maxRisersInRun = 16 maxWidth = 2.4 scissorStair = False hdrlHeight = .900 #hdrlTopExtension = .305 #hdrlBtmExtension = 1*treadDepth #hdrlMaxProjection = .114 #(1)Determine Run Direction rs.SimplifyCurve(rect) rectSegments = rs.ExplodeCurves(rect) edge1 = rectSegments[0] edge3 = rectSegments[1] if rs.CurveLength(edge1) > rs.CurveLength(edge3): longEdge = edge1 shortEdge = edge3 else: longEdge = edge3 shortEdge = edge1 longVec = rs.VectorCreate(rs.CurveStartPoint(longEdge), rs.CurveEndPoint(longEdge)) longVecRev = rs.VectorReverse(longVec) shortVec = rs.VectorCreate(rs.CurveStartPoint(shortEdge), rs.CurveEndPoint(shortEdge)) shortVecRev = rs.VectorReverse(shortVec) #(2)Stair Width stairWidth = (rs.CurveLength(shortEdge) - minGapSize) / 2 if stairWidth < .6: print "ERROR: Stair is ridiculously too narrow." return #(3)Run Length runLength = rs.CurveLength(longEdge) - (stairWidth * 2) if runLength < 1: print "ERROR: Stair is ridiculously too short." return #LandingRect landing1Plane = rs.PlaneFromFrame(rs.CurveStartPoint(shortEdge), shortVecRev, longVecRev) landing1 = rs.AddRectangle(landing1Plane, rs.CurveLength(shortEdge), stairWidth) landing2Plane = rs.PlaneFromFrame(rs.CurveEndPoint(longEdge), shortVec, longVec) landing2 = rs.AddRectangle(landing2Plane, rs.CurveLength(shortEdge), stairWidth) #RunRects run1Plane = rs.PlaneFromFrame( rs.CurveEditPoints(landing1)[3], shortVecRev, longVecRev) run1Rect = rs.AddRectangle(run1Plane, stairWidth, runLength) run2Plane = rs.PlaneFromFrame( rs.CurveEditPoints(landing2)[3], shortVec, longVec) run2Rect = rs.AddRectangle(run2Plane, stairWidth, runLength) #(4)Num Flights between Landings numLevels = len(landingLevels) deltaLevels = [] runsPerLevel = [] mostRisersInRun = math.floor(runLength / minTread) if mostRisersInRun > maxRisersInRun: mostRisersInRun = maxRisersInRun numRuns = 0 for i in range(0, numLevels - 1): deltaLevels.append(landingLevels[i + 1] - landingLevels[i]) minNumRisers = math.ceil(deltaLevels[i] / maxRiser) runsPerLevel.append(math.ceil(minNumRisers / mostRisersInRun)) numRuns = numRuns + int(runsPerLevel[i]) #(5) Which flights listOfRuns = [] for i in range(0, numRuns): if i % 2: #if even listOfRuns.append(rs.CopyObject(run1Rect)) else: listOfRuns.append(rs.CopyObject(run2Rect)) #(6) Num Treads per run runsDeltaHeight = [] for i in range(0, numLevels - 1): for j in range(0, int(runsPerLevel[i])): runsDeltaHeight.append(deltaLevels[i] / runsPerLevel[i]) numRisersPerRun = [] for i in range(0, numRuns): numRisersPerRun.append(math.ceil(runsDeltaHeight[i] / maxRiser)) #(7) Move Runs elevation = 0 landings = [] for i in range(0, numRuns): elevation = elevation + runsDeltaHeight[i] translation = rs.VectorCreate([0, 0, elevation], [0, 0, 0]) rs.MoveObject(listOfRuns[i], translation) if i % 2: landings.append(rs.MoveObject(rs.CopyObject(landing2), translation)) else: landings.append(rs.MoveObject(rs.CopyObject(landing1), translation)) #(8) Make Landings stairGeo = [] for i in range(0, numRuns): dir = rs.VectorCreate([0, 0, 0], [0, 0, runsDeltaHeight[i]]) #rs.MoveObject(landings[i], dir) path = rs.AddLine([0, 0, 0], [0, 0, -thickness]) geo = rs.ExtrudeCurve(landings[i], path) rs.CapPlanarHoles(geo) stairGeo.append(geo) rs.DeleteObject(path) rs.DeleteObjects(landings) #(9) Draw Stairs runs = [] for i in range(0, numRuns): runs.append( Run(listOfRuns[i], runsDeltaHeight[i], numRisersPerRun[i], thickness, i, maxTread)) stairGeo.append(runs[i].make()) runs[i].makeHandrail(hdrlHeight, minGapSize) runs[i].printStats() runs[i].cleanup() finalGeo = rs.BooleanUnion(stairGeo, delete_input=True) #(10) Scissor Stairs if scissorStair: pt0 = rs.CurveMidPoint(rectSegments[0]) pt1 = rs.CurveMidPoint(rectSegments[1]) pt2 = rs.CurveMidPoint(rectSegments[2]) pt3 = rs.CurveMidPoint(rectSegments[3]) mir1 = rs.MirrorObject(finalGeo, pt0, pt2, copy=True) mirroredStair = rs.MirrorObject(mir1, pt1, pt3, copy=False) #(11)Label rs.SetUserText(finalGeo, "Brew", "Hot Coffee") if scissorStair: rs.SetUserText(mirroredStair, "Brew", "Hot Coffee") #Cleanup rs.DeleteObjects(listOfRuns) rs.DeleteObjects(rectSegments) rs.DeleteObject(landing1) rs.DeleteObject(landing2) rs.DeleteObject(run1Rect) rs.DeleteObject(run2Rect) print "done" return None
def makeFireStair(rect, landingLevels): #HARD VARIABLES minGapSize = .2 minTread = .260 maxRiser = .180 thickness = .15 #(1)Determine Run Direction rs.SimplifyCurve(rect) rectSegments = rs.ExplodeCurves(rect) edge1 = rectSegments[0] edge3 = rectSegments[1] rs.DeleteObject(rectSegments[2]) rs.DeleteObject(rectSegments[3]) if rs.CurveLength(edge1) > rs.CurveLength(edge3): longEdge = edge1 shortEdge = edge3 else: longEdge = edge3 shortEdge = edge1 longVec = rs.VectorCreate(rs.CurveStartPoint(longEdge), rs.CurveEndPoint(longEdge)) longVecRev = rs.VectorReverse(longVec) shortVec = rs.VectorCreate(rs.CurveStartPoint(shortEdge), rs.CurveEndPoint(shortEdge)) shortVecRev = rs.VectorReverse(shortVec) rs.CurveArrows(longEdge, 2) rs.CurveArrows(shortEdge, 2) #(2)Stair Width stairWidth = (rs.CurveLength(shortEdge) - minGapSize) / 2 #LandingRect landing1Plane = rs.PlaneFromFrame(rs.CurveStartPoint(shortEdge), shortVecRev, longVecRev) landing1 = rs.AddRectangle(landing1Plane, rs.CurveLength(shortEdge), stairWidth) landing2Plane = rs.PlaneFromFrame(rs.CurveEndPoint(longEdge), shortVec, longVec) landing2 = rs.AddRectangle(landing2Plane, rs.CurveLength(shortEdge), stairWidth) #(3)Run Length runLength = rs.CurveLength(longEdge) - (stairWidth * 2) #RunRects run1Plane = rs.PlaneFromFrame( rs.CurveEditPoints(landing1)[3], shortVecRev, longVecRev) run1Rect = rs.AddRectangle(run1Plane, stairWidth, runLength) run2Plane = rs.PlaneFromFrame( rs.CurveEditPoints(landing2)[3], shortVec, longVec) run2Rect = rs.AddRectangle(run2Plane, stairWidth, runLength) #(4)Num Flights between Landings numLevels = len(landingLevels) deltaLevels = [] runsPerLevel = [] maxRisersPerRun = math.floor(runLength / minTread) numRuns = 0 for i in range(0, numLevels - 1): deltaLevels.append(landingLevels[i + 1] - landingLevels[i]) minNumRisers = math.ceil(deltaLevels[i] / maxRiser) runsPerLevel.append(math.ceil(minNumRisers / maxRisersPerRun)) numRuns = numRuns + int(runsPerLevel[i]) #(5) Which flights listOfRuns = [] for i in range(0, numRuns): if i % 2: #if even listOfRuns.append(rs.CopyObject(run1Rect)) else: listOfRuns.append(rs.CopyObject(run2Rect)) #(6) Num Treads per run runsDeltaHeight = [] for i in range(0, numLevels - 1): for j in range(0, int(runsPerLevel[i])): runsDeltaHeight.append(deltaLevels[i] / runsPerLevel[i]) numRisersPerRun = [] for i in range(0, numRuns): numRisersPerRun.append(math.ceil(runsDeltaHeight[i] / maxRiser)) #(7) Move Runs elevation = 0 landings = [] for i in range(0, numRuns): elevation = elevation + runsDeltaHeight[i] translation = rs.VectorCreate([0, 0, elevation], [0, 0, 0]) rs.MoveObject(listOfRuns[i], translation) if i % 2: landings.append( rs.MoveObject(rs.CopyObject(landing2), translation)) else: landings.append( rs.MoveObject(rs.CopyObject(landing1), translation)) #(8) Make Landings stairGeo = [] for i in range(0, numRuns): dir = rs.VectorCreate([0, 0, 0], [0, 0, runsDeltaHeight[i]]) #rs.MoveObject(landings[i], dir) path = rs.AddLine([0, 0, 0], [0, 0, -thickness]) geo = rs.ExtrudeCurve(landings[i], path) rs.CapPlanarHoles(geo) stairGeo.append(geo) rs.DeleteObject(path) rs.DeleteObjects(landings) #(9) Draw Stairs runs = [] for i in range(0, numRuns): runs.append( Run(listOfRuns[i], runsDeltaHeight[i], numRisersPerRun[i])) stairGeo.append(runs[i].make()) finalGeo = rs.BooleanUnion(stairGeo, delete_input=True) #Cleanup rs.DeleteObjects(listOfRuns) rs.DeleteObjects(rectSegments) rs.DeleteObject(landing1) rs.DeleteObject(landing2) rs.DeleteObject(run1Rect) rs.DeleteObject(run2Rect) print "done" return finalGeo