def InsulationPanel(left_edge, right_edge):
points = []
#insulation_left = ver_line_split_even[i]
point_1 = rs.CurveStartPoint(left_edge)
point_2 = rs.CurveEndPoint(left_edge)
#insulation_right = ver_line_split_even[i + next_even_Cource]
point_3 = rs.CurveEndPoint(right_edge)
point_4 = rs.CurveStartPoint(right_edge)
trans = rs.XformTranslation((0, 0, ipThick))
point_5 = rs.PointTransform(point_1, trans)
point_6 = rs.PointTransform(point_2, trans)
point_7 = rs.PointTransform(point_3, trans)
point_8 = rs.PointTransform(point_4, trans)
points.append(point_1)
points.append(point_2)
points.append(point_3)
points.append(point_4)
points.append(point_5)
points.append(point_6)
points.append(point_7)
points.append(point_8)
insulation = rs.AddBox(points)
return insulation
def Run(xNum, yNum):
if xNum is None:
rs.MessageBox("No number provided for x")
return
if yNum is None:
rs.MessageBox("No number provided for y")
return
rs.EnableRedraw(False)
boxes = []
for i in range(xNum):
for n in range(yNum):
points = []
for s in range(2):
for t in range(4):
x = math.cos(math.radians(45 + 90 * t)) * math.sqrt(2)
y = math.sin(math.radians(45 + 90 * t)) * math.sqrt(2)
z = -1 + 2 * s
point = geo.Point3d(x, y, z)
points.append(point)
box = rs.AddBox(points)
box = rs.RotateObject(box, geo.Point3d(0, 0, 0),
90 / (xNum - 1) * i, geo.Vector3d.ZAxis)
box = rs.RotateObject(box, geo.Point3d(0, 0, 0),
90 / (yNum - 1) * n, geo.Vector3d.XAxis)
box = rs.MoveObject(box, geo.Vector3d(4 * i, 4 * n, 0))
boxes.append(box)
rs.EnableRedraw(True)
return boxes
#Run()
def createBox():
l, b, h = [float(n) for n in raw_input('Of what dimensions?: "length breadth height"').split()]
x, y, z = [float(n) for n in raw_input('where?: "x y z"').split()]
id = rs.AddBox([(x,y,z),(x,y+b,z),(x+l,y+b,z),(x+l,y,z),(x,y,z+h),(x,y+b,z+h),(x+l,y+b,z+h),(x+l,y,z+h)])
boxes.append(id)
rs.SetUserText(id, key="Box", value=str(len(boxes)))
print('Done.')
def draw_box(self):
# boxを構成する点群
pts = [
[self.origin[0], self.origin[1], self.origin[2]],
[self.origin[0] + self.width, self.origin[1], self.origin[2]],
[
self.origin[0] + self.width, self.origin[1] + self.depth,
self.origin[2]
],
[self.origin[0], self.origin[1] + self.depth, self.origin[2]],
[self.origin[0], self.origin[1], self.origin[2] + self.height],
[
self.origin[0] + self.width, self.origin[1],
self.origin[2] + self.height
],
[
self.origin[0] + self.width, self.origin[1] + self.depth,
self.origin[2] + self.height
],
[
self.origin[0], self.origin[1] + self.depth,
self.origin[2] + self.height
],
]
# ptsを元にboxを描画する
rs.AddBox(pts)
def drawBox( side, location, angle_degrees1, angle_degrees2):
"""画一个2D方块
参数:
side(double): 方块的长度, double
locaiton(tuple(double, double,double)): 方块中心的位置
angle_degrees1(double): xy平面旋转角度degree1
angle_degrees2(double): 到达位置后继续朝z轴方向旋转角度degree2
Returns:
guid
"""
corners = []
corners.append((-side/2,-side/2,0))
corners.append(( side/2,-side/2,0))
corners.append((side/2,side/2,0))
corners.append((-side/2,side/2,0))
corners.append((-side/2,-side/2,side))
corners.append((side/2,-side/2,side))
corners.append((side/2,side/2,side))
corners.append((-side/2,side/2,side))
obj = rs.AddBox(corners)
xform = rs.XformRotation2(angle_degrees1, (0,0,1), (0,0,0))
obj = rs.TransformObject( obj, xform, False )
vectorR1 = rs.VectorRotate( (1,0,0), angle_degrees1, (0,0,0))
vectorR2 = rs.VectorCrossProduct(vectorR1, (0,0,1))
xform = rs.XformRotation2(angle_degrees1, vectorR2, (0,0,0))
obj = rs.TransformObject( obj, xform, False )
xform = rs.XformTranslation( location)
obj = rs.TransformObject( obj, xform, False )
return obj
def draw_box(self):
pts = [
[self.origin[0], self.origin[1], self.origin[2]],
[self.origin[0] + self.width, self.origin[1], self.origin[2]],
[
self.origin[0] + self.width, self.origin[1] + self.depth,
self.origin[2]
],
[self.origin[0], self.origin[1] + self.depth, self.origin[2]],
[self.origin[0], self.origin[1], self.origin[2] + self.height],
[
self.origin[0] + self.width, self.origin[1],
self.origin[2] + self.height
],
[
self.origin[0] + self.width, self.origin[1] + self.depth,
self.origin[2] + self.height
],
[
self.origin[0], self.origin[1] + self.depth,
self.origin[2] + self.height
],
]
# drawing a box based on pts
rs.AddBox(pts)
def add_box(vx1, vy1, vz1, vx2, vy2, vz2):
vA = [vx1, vy1, vz1]
vB = [vx1, vy2, vz1]
vC = [vx2, vy2, vz1]
vD = [vx2, vy1, vz1]
vE = [vx1, vy1, vz2]
vF = [vx1, vy2, vz2]
vG = [vx2, vy2, vz2]
vH = [vx2, vy1, vz2]
allGeometry.append(rs.AddBox([vA, vB, vC, vD, vE, vF, vG, vH]))
def display(self):
pt_1 = self.cp.Origin - self.cp.XAxis * self.xs * 0.5 - self.cp.YAxis * self.ys * 0.5
pt_2 = self.cp.Origin - self.cp.XAxis * self.xs * 0.5 + self.cp.YAxis * self.ys * 0.5
pt_3 = self.cp.Origin + self.cp.XAxis * self.xs * 0.5 + self.cp.YAxis * self.ys * 0.5
pt_4 = self.cp.Origin + self.cp.XAxis * self.xs * 0.5 - self.cp.YAxis * self.ys * 0.5
pt_5 = self.cp.Origin - self.cp.XAxis * self.xs * 0.5 - self.cp.YAxis * self.ys * 0.5 + self.cp.ZAxis * self.zs
pt_6 = self.cp.Origin - self.cp.XAxis * self.xs * 0.5 + self.cp.YAxis * self.ys * 0.5 + self.cp.ZAxis * self.zs
pt_7 = self.cp.Origin + self.cp.XAxis * self.xs * 0.5 + self.cp.YAxis * self.ys * 0.5 + self.cp.ZAxis * self.zs
pt_8 = self.cp.Origin + self.cp.XAxis * self.xs * 0.5 - self.cp.YAxis * self.ys * 0.5 + self.cp.ZAxis * self.zs
rs.AddBox([pt_1,pt_2,pt_3,pt_4,pt_5,pt_6,pt_7,pt_8])
def createSectionBox(obj):
box = rs.BoundingBox(obj)
bb = rs.AddBox(box)
faces = rs.ExplodePolysurfaces(bb)
faces = [rs.FlipSurface(x) for x in faces]
planes = [getSrfFrame(x) for x in faces]
clips = [rs.AddClippingPlane(x, 1000, 1000) for x in planes]
group = rs.AddGroup()
rs.AddObjectsToGroup(clips, group)
return clips
def addBox(node):
box = []
for indx in node.indxList:
box.append(ptsList[indx])
boxBody = rs.AddBox(box)
if (node.state == 1):
rs.ObjectColor(boxBody, [255, 0, 0])
elif (node.state == 3):
rs.ObjectColor(boxBody, [0, 255, 0])
elif (node.state == 4):
rs.ObjectColor(boxBody, [0, 0, 0])
def cube(self, l, w, h):
# a = rs.AddPoint(self.point)
p = rs.rs.PointCoordinates(self.point)
a = rs.AddPoint(p)
b = rs.CopyObject(a, [l, 0, 0])
c = rs.CopyObject(a, [l, w, 0])
d = rs.CopyObject(a, [0, w, 0])
e = rs.CopyObject(a, [0, 0, h])
f = rs.CopyObject(a, [l, 0, h])
g = rs.CopyObject(a, [l, w, h])
h = rs.CopyObject(a, [0, w, h])
box = rs.AddBox([a, b, c, d, e, f, g, h])
def SetUp(offset,h):
sheet = rs.AddBox([[-10,-10,h],[10,-10,h],[10,10,h],[-10,10,h],[-10,-10,0],[10,-10,0],[10,10,0],[-10,10,0]])
bigSheet = sheet
box2 = rs.AddBox([[-5.25,-5.25,1],[5.25,-5.25,1],[5.25,5.25,1],[-5.25,5.25,1],[-5.25,-5.25,-2],[5.25,-5.25,-2],[5.25,5.25,-2],[-5.25,5.25,-2]])
rs.MoveObject(box2, move_it)
ribc = rs.BooleanIntersection([box2],[bigSheet],True)
rs.SelectObject(ribc)
rs.Command("_-Export C:\\" + dirsname + "\\protoslant_walk.igs ENTER")
rs.Command("_SelNone")
Rhino.FileIO.File3dm.Polish
#fileName = Rhino.FileIO.File3dm
#Rhino.FileIO.File3dm.Write(fileName,"C:\\"+dirsname+"\\protoslant_walk.3dm",5)
rs.Command("_-Save C:\\" + dirsname + "\\protoslant_walk.3dm ENTER")
def RectangleCentered(plane,height,length,width):
x = height/2
y = length/2
z = width/2
p0 = plane.PointAt(x,y,-z)
p1 = plane.PointAt(-x,y,-z)
p2 = plane.PointAt(-x,-y,-z)
p3 = plane.PointAt(x,-y,-z)
p4 = plane.PointAt(x,y,z)
p5 = plane.PointAt(-x,y,z)
p6 = plane.PointAt(-x,-y,z)
p7 = plane.PointAt(x,-y,z)
bricks.append(rs.AddBox([p0,p1,p2,p3,p4,p5,p6,p7]))
def Show(self):
"""
displays the domain on the Rhino user interface.
Parameters
----------
None
"""
corners = ([(0, 0, 0), (self.length, 0, 0),
(self.length, self.length, 0), (0, self.length, 0),
(0, 0, self.length), (self.length, 0, self.length),
(self.length, self.length, self.length),
(0, self.length, self.length)])
return rs.AddBox(corners)
def right_cuboid(base=u0(), width=1, height=1, length=1, top=None):
base, dz = base_and_height(base, top or length)
c, dx, dy = add_xy(base, width / -2, height / -2), width, height
return rh.AddBox(
map(Pt, [
c,
add_x(c, dx),
add_xy(c, dx, dy),
add_y(c, dy),
add_z(c, dz),
add_xz(c, dx, dz),
add_xyz(c, dx, dy, dz),
add_yz(c, dy, dz)
]))
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 cubecenter(self, m1, m2, m3):
# a = rs.AddPoint(self.point)
p = rs.GetPoint("Enter center point")
a = rs.AddPoint(p)
l = m1 / 2
w = m2 / 2
h = m3 / 2
b = rs.CopyObject(a, [l, w, -h])
c = rs.CopyObject(a, [l, -w, -h])
d = rs.CopyObject(a, [-l, -w, -h])
e = rs.CopyObject(a, [-l, w, -h])
f = rs.CopyObject(a, [l, w, h])
g = rs.CopyObject(a, [l, -w, h])
h = rs.CopyObject(a, [-l, -w, h])
j = rs.CopyObject(a, [-l, w, (m3 / 2)])
box = rs.AddBox([b, c, d, e, f, g, h, j])
def cuboid(b0=None,
b1=None,
b2=None,
b3=None,
t0=None,
t1=None,
t2=None,
t3=None):
b0 = b0 or u0()
b1 = b1 or add_x(b0, 1)
b2 = b2 or add_y(b1, 1)
b3 = b3 or add_y(b0, 1)
t0 = t0 or add_z(b0, 1)
t1 = t1 or add_x(t0, 1)
t2 = t2 or add_y(t1, 1)
t3 = t3 or add_y(t0, 1)
return rh.AddBox(map(Pt, [b0, b1, b2, b3, t0, t1, t2, t3]))
def bbsolid(obj):
if rs.IsBlockInstance(obj):
arrMatrix = rs.BlockInstanceXform(obj)
if arrMatrix is not None:
# pointId = rs.AddPoint([0,0,0])
plane = rs.PlaneTransform(rs.WorldXYPlane(), arrMatrix)
box = rs.BoundingBox(obj, plane)
bb = rs.AddBox(box)
# if box:
# for i, point in enumerate(box):
# rs.AddTextDot( i, point )
xformscale = rs.XformScale((1.0, 20.0, 1.0))
cob = rs.XformChangeBasis(rs.WorldXYPlane(), plane)
cob_inverse = rs.XformChangeBasis(plane, rs.WorldXYPlane())
temp = rs.XformMultiply(xformscale, cob)
xform = rs.XformMultiply(cob_inverse, temp)
rs.TransformObjects(bb, xform)
return bb
def box(corner=u0(), dx=1, dy=None, dz=None):
dy = dy or dx
dz = dz or dy
c = corner
if isinstance(dx, xyz):
v = loc_in_cs(dx, c.cs) - c
dx, dy, dz = v.coords
return rh.AddBox(
map(Pt, [
c,
add_x(c, dx),
add_xy(c, dx, dy),
add_y(c, dy),
add_z(c, dz),
add_xz(c, dx, dz),
add_xyz(c, dx, dy, dz),
add_yz(c, dy, dz)
]))
def addBox(node):
box = []
lower = node.indxList[0]
upper = node.indxList[6]
center = []
for i in range(3):
center.append((ptsList[lower][i] + ptsList[upper][i]) / 2)
for indx in node.indxList:
box.append(ptsList[indx])
boxBody = rs.AddBox(box)
rs.AddText(node.nid, center, 0.05)
if (node.state == 1):
rs.ObjectColor(boxBody, [255, 0, 0])
elif (node.state == 3):
rs.ObjectColor(boxBody, [0, 255, 0])
elif (node.state == 4):
rs.ObjectColor(boxBody, [0, 0, 0])
def WindowFrame():
surf_int_edge_all = rs.DuplicateSurfaceBorder(surf[1], type=2)
print len(surf_int_edge_all)
window_frame_all = []
for item in range(0, len(surf_int_edge_all), 1):
surf_int_edge = surf_int_edge_all[item]
surf_int_edge = rs.ExplodeCurves(surf_int_edge, True)
trans1 = rs.XformTranslation((0, 0, 2 * ipThick))
trans2 = rs.XformTranslation((0, 0, -2 * ipThick))
point_1 = rs.CurveStartPoint(surf_int_edge[0])
point_2 = rs.CurveStartPoint(surf_int_edge[1])
point_3 = rs.CurveStartPoint(surf_int_edge[2])
point_4 = rs.CurveStartPoint(surf_int_edge[3])
point_5 = rs.PointTransform(point_1, trans1)
point_6 = rs.PointTransform(point_2, trans1)
point_7 = rs.PointTransform(point_3, trans1)
point_8 = rs.PointTransform(point_4, trans1)
point_1 = rs.PointTransform(point_1, trans2)
point_2 = rs.PointTransform(point_2, trans2)
point_3 = rs.PointTransform(point_3, trans2)
point_4 = rs.PointTransform(point_4, trans2)
frame_points = []
frame_points.append(point_1)
frame_points.append(point_2)
frame_points.append(point_3)
frame_points.append(point_4)
frame_points.append(point_5)
frame_points.append(point_6)
frame_points.append(point_7)
frame_points.append(point_8)
window_frame = rs.AddBox(frame_points)
window_frame_all.append(window_frame)
return window_frame_all
from __future__ import print_function
import rhinoscriptsyntax as rs
import scriptcontext as sc
import compas_rhino
guids = compas_rhino.get_objects()
compas_rhino.delete_objects(guids, True)
result = rs.AddBox([[0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0], [0, 0, 1],
[1, 0, 1], [1, 1, 1], [0, 1, 1]])
print(result)
obj = sc.doc.Objects.Find(result)
print(obj)
# Random numbers part II to generate lines
import rhinoscriptsyntax as rs
import random
pts = []
for i in range(0, 100):
x = random.uniform(0, 100)
y = random.uniform(0, 100)
z = random.uniform(0, 100)
pt = [x, y, z]
pts.append(pt)
pl = rs.AddPolyline(pts)
crv = rs.AddCurve(pts)
intCrv = rs.AddInterpCurve(pts)
color01 = [0, 255, 255]
color02 = [255, 0, 255]
color03 = [255, 255, 0]
rs.ObjectColor(pl, color01)
rs.ObjectColor(crv, color02)
rs.ObjectColor(intCrv, color03)
rs.AddBox([[0, 0, 0], [100, 0, 0], [100, 100, 0], [0, 100, 0], [0, 0, 100],
[100, 0, 100], [100, 100, 100], [0, 100, 100]])
boxes = rs.AddGroup("Boxes")
for x in range(numDivX):
for y in range(numDivY):
for z in range(numDivZ):
# add box
box = rs.AddBox(
([minX + x * stepX, minY + y * stepY, minZ + z * stepZ],
[minX + (x + 1) * stepX, minY + y * stepY,
minZ + z * stepZ], [
minX + (x + 1) * stepX, minY + (y + 1) * stepY,
minZ + z * stepZ
],
[minX + x * stepX, minY + (y + 1) * stepY, minZ + z * stepZ],
[minX + x * stepX, minY + y * stepY,
minZ + (z + 1) * stepZ], [
minX + (x + 1) * stepX, minY + y * stepY,
minZ + (z + 1) * stepZ
], [
minX + (x + 1) * stepX, minY + (y + 1) * stepY,
minZ + (z + 1) * stepZ
], [
minX + x * stepX, minY + (y + 1) * stepY,
minZ + (z + 1) * stepZ
]))
# Group boxes
# boxes = rs.AddObjectsToGroup(box, "Boxes")
boxFaces = rs.ExplodePolysurfaces(box)
# Calculate density
#run through clos_pt, if it's x
string_l = rs.ObjectLayer(index)
print string_l
div_num = 3
vector_length = rs.VectorLength(sub_vect) / div_num
#adding spheres to the new lines
#rs.AddSphere(new_pt,vector_length)
#adding boxes to the new lines
rs.AddBox(\
[(new_pt_coord),\
(new_pt_coord[0]+vector_length,new_pt_coord[1],new_pt_coord[2]),\
(new_pt_coord[0]+vector_length,new_pt_coord[1]+vector_length,new_pt_coord[2]),\
(new_pt_coord[0],new_pt_coord[1]+vector_length,new_pt_coord[2]),\
(new_pt_coord[0],new_pt_coord[1],new_pt_coord[2]+vector_length),\
(new_pt_coord[0]+vector_length,new_pt_coord[1],new_pt_coord[2]+vector_length),\
(new_pt_coord[0]+vector_length,new_pt_coord[1]+vector_length,new_pt_coord[2]+vector_length),\
(new_pt_coord[0],new_pt_coord[1]+vector_length,new_pt_coord[2]+vector_length)])
"""
def PassPtName(pt_name):
pt_name = rs.ObjectsByName(pt_name)
if pt_name == "Denver":
pass
index = rs.ObjectsByName("Denver")
print index
rs.MoveObject(index, (0,0,10))
def __generate_individual_levels(self, crosssectionplane, loft_height):
cplane = rs.ViewCPlane(None, crosssectionplane)
level_points = []
spikiness = self.emotion_properties["spikiness"] # max spikiness = 1
scaling_factor_aid = 0.2 * spikiness
#draws profile curves on each spine level
for i in xrange(self.emotion_properties["horizontal_AR"][loft_height]
["points_in_curve"]):
scaling_factor = 1 - scaling_factor_aid if i % 2 == 0 else 1 #ranges from a difference in 0.8 and 1 (no difference)
angle = 2 * math.pi * i / self.emotion_properties["horizontal_AR"][
loft_height]["points_in_curve"]
x_point = scaling_factor * self.dimensions[
"actual_height"] * self.dimensions[
"vertical_AR"] * self.emotion_properties["vertical_AR"][
loft_height] * self.emotion_properties[
"horizontal_AR"][loft_height][
"level_horizontal_AR_x"] * math.cos(angle) / 2
y_point = scaling_factor * self.dimensions[
"actual_height"] * self.dimensions[
"vertical_AR"] * self.emotion_properties["vertical_AR"][
loft_height] * self.emotion_properties[
"horizontal_AR"][loft_height][
"level_horizontal_AR_y"] * math.sin(angle) / 2
z_point = 0
point = rs.XformCPlaneToWorld([x_point, y_point, z_point], cplane)
level_points.append(rs.AddPoint(point))
connecting_point = level_points[0]
level_points.append(rs.AddPoint(connecting_point))
level_curve = rs.AddCurve(
level_points, self.emotion_properties["horizontal_AR"][str(
loft_height)]["horizontal_smoothness"])
#twists curve start point 180deg if it is below the spine_x point (to make sure loft doesn't twist)
crvStart = rs.CurveStartPoint(level_curve)
if crvStart[0] <= self.x_points[int(loft_height) - 1]:
crvDomain = rs.CurveDomain(level_curve)
rs.CurveSeam(level_curve, (crvDomain[0] + crvDomain[1]) / 2)
# add planar surface to top and bottom of bottle
if loft_height == "5" or loft_height == "1":
rs.AddPlanarSrf(level_curve)
# hide curves and points on level profiles
rs.HideObjects(level_curve)
rs.HideObjects(level_points)
# object finishing features
if (self.object_id == "Bottle"):
if loft_height == "5":
rs.AddCylinder(cplane, 14.5, 7.4, cap=True)
if (self.object_id == "Chair"):
if loft_height == "5":
rs.AddCylinder(cplane, 14.5, 7.4, cap=True)
if (self.object_id == "Jewelry"):
if loft_height == "5":
major_radius = 5.0
minor_radius = major_radius - 1.5
# rotated_cplane = rs.RotatePlane(cplane, 45.0, cplane.XAxis)
direction = rs.AddPoint((0, 0, 1))
rs.AddTorus(cplane.Origin, major_radius, minor_radius,
direction)
if (self.object_id == "Totem"):
if loft_height == "1":
base_width = 80
base_length = 60
base_depth = -10
base_points = [(-base_width / 2, -base_length / 2, 0),
(base_width / 2, -base_length / 2, 0),
(base_width / 2, base_length / 2, 0),
(-base_width / 2, base_length / 2, 0),
(-base_width / 2, -base_length / 2, base_depth),
(base_width / 2, -base_length / 2, base_depth),
(base_width / 2, base_length / 2, base_depth),
(-base_width / 2, base_length / 2, base_depth)]
rs.AddBox(base_points)
return level_curve
__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)
#切片索引，建球
sphere = rs.AddSphere(dpoints[y], 3) #提取[y](圆心，半径)
cube = rs.AddBox(rs.BoundingBox(sphere)) #（物体，plane）
z = random.uniform(-10, z_range)
return z
xnum = randX(10)
ynum = randY(10)
znum = randZ(10)
#initializing first point, making empty pts array, appending first point to pts array
pts = []
#ptZero = (0,0,0)
#pts.append(ptZero)
#initializing boxes
boxes = []
array = rs.AddBox([(0,0,0),(xnum,0,0),(xnum,ynum,0),\
(0,ynum,0),(0,0,znum),(xnum,0,znum),(xnum,ynum,znum),(0,ynum,znum)])
boxes.append(array)
#initializing line
start = rs.AddPoint(0, 0, 0)
end = rs.AddPoint(100, 0, 0)
line = rs.AddLine(start, end)
#Points = rs.DivideCurveLength(line,1,True,True)
#pts.append(Points)
for i in range(100):
newPt = rs.AddPoint(i, 0, 0)
xnum = randX(10)
ynum = randY(10)
znum = randZ(10)
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")
