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
