def addplane(m, n, dx, dy):
for i in range(m):
for j in range(n):
plane = rs.WorldXYPlane()
origin = (i * dx, j * dy, 0)
newplane = rs.MovePlane(plane, origin)
rs.AddPlaneSurface(newplane, dx, dy)
def RunCommand(is_interactive):
ringSize = rs.GetReal("Ring size", 8.5, 0, 16)
center = rs.GetPoint("Location")
plane = rs.MovePlane(rs.ViewCPlane(), center)
radius = (11.63 + 0.8128 * ringSize) * 0.5
objId = rs.AddCircle(plane, radius)
rs.SelectObject(objId)
def get_brep_section_planes(brep, section_heights):
base_plane = wge.get_brep_base_plane(brep)
section_planes = []
for height in section_heights:
new_plane = rs.MovePlane(base_plane, [
base_plane.OriginX, base_plane.OriginY, base_plane.OriginZ + height
])
section_planes.append(new_plane)
return section_planes
def get_drawing_planes(section_dims, baseplane, increment):
"""generate planes for placing the bottom-left corner of output curves."""
drawing_planes = [baseplane]
p = baseplane #temp plane
for dim in section_dims[:-1]:
o = [p.OriginX + dim.X + increment, p.OriginY, p.OriginZ]
p = rs.MovePlane(p, o)
drawing_planes.append(p)
return drawing_planes
def RunCommand(is_interactive):
global params
center = rs.GetPoint(message="Select center point")
n = rs.GetInteger(message="Number of teeth", number=params["n"], minimum=4)
r = rs.GetReal(message="Outside Diameter", number=params["r"])
m = rs.GetReal(message="Gear module", number=params["m"])
pa = rs.GetReal(message="Pressure angle",
number=params["pa"],
minimum=0,
maximum=45)
bool_opts = rs.GetBoolean(message="Output options",
items=(("PitchCircle", "No", "Yes"), ),
defaults=(params["pc"], ))
if None in [center, n, m, pa, bool_opts]:
return 1 # Cancel
pc = bool_opts[0]
params["n"] = n
params["m"] = m
params["r"] = r
params["pa"] = pa
params["pc"] = pc
cplane = rs.ViewCPlane() # Get current CPlane
cplane = rs.MovePlane(cplane, center)
xform = rs.XformChangeBasis(cplane, rs.WorldXYPlane())
rs.EnableRedraw(False)
old_plane = rs.ViewCPlane(plane=rs.WorldXYPlane())
gear = generate_gear_crv_with_outside(teeth=params["n"],
module=params["m"],
outside_diam=params["r"],
pressure_angle=params["pa"])
rs.ViewCPlane(plane=old_plane)
rs.TransformObjects(gear, xform)
rs.EnableRedraw(True)
if pc:
circle = generate_pitch_circle_crv(teeth=params["n"],
module=params["m"])
rs.TransformObjects(circle, xform)
rs.SelectObjects([gear, circle])
else:
rs.SelectObjects(gear)
return 0 # Success
def get_section_planes(brep, thickness):
bb = rs.BoundingBox(brep)
start_height = bb[0].Z
end_height = bb[4].Z
xy_plane = rs.WorldXYPlane()
heights = wut.frange(start_height, end_height, thickness)
planes = [rs.MovePlane(xy_plane, [0, 0, z]) for z in heights]
return planes
def createNewPopulation(self):
x = 0
y = 0
for p in range(0, self.totalPopulation):
if (x > numCols - 1):
x = 0
y += 1
newLoc = rs.MovePlane(rs.WorldXYPlane(), (x * 20, y * -10, 0))
d = DNA()
pl = Plane(newLoc, d, p)
self.population.append(pl)
x += 1
def CreateCircle(circumference=None):
center = rs.GetPoint("Center point of circle")
if center:
plane = rs.MovePlane(rs.ViewCPlane(), center)
length = circumference
if length is None: length = rs.GetReal("Circle circumference")
if length and length > 0:
radius = length / (2 * math.pi)
objectId = rs.AddCircle(plane, radius)
rs.SelectObject(objectId)
return length
return None
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 evolvePlanes(self):
x = 0
y = 0
for i in range(0, self.totalPopulation):
if (x > numCols - 1):
x = 0
y += 1
newLoc = rs.MovePlane(rs.WorldXYPlane(), (x * 20, y * -10, 0))
a = random.choice(self.selectedPlanes.values())
b = random.choice(self.selectedPlanes.values())
d = self.crossover(a, b)
d.mutate()
pl = Plane(newLoc, d, i)
self.population.append(pl)
x += 1
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)
import System
import clr
clr.AddReference("Grasshopper")
import rhinoscriptsyntax as rs
from Grasshopper import DataTree
import Rhino.Geometry as rg
import ghpythonlib.components as ghc
import ghpythonlib.treehelpers as ght
a = []
# Checks whether the input geometry is brep, mesh or curve
# If it is a brep or mesh, the input height is used to create the contour, in
# the given height
# Curves are then projected onto world xy-plane
for i in range (len(geometry)):
if (geometry[i].ToString().split(".")[-1]).Contains("Brep"):
a.append(geometry[i].CreateContourCurves(geometry[i],rs.MovePlane(rs.WorldXYPlane(),[0,0,height])))
elif (geometry[i].ToString().split(".")[-1]).Contains("Mesh"):
a.append(geometry[i].CreateContourCurves(geometry[i],rs.MovePlane(rs.WorldXYPlane(),[0,0,height])))
elif (geometry[i].ToString().split(".")[-1]).Contains("Curve"):
a.append(geometry[i].ProjectToPlane(geometry[i],rs.WorldXYPlane()))
a = ght.list_to_tree(a)
a.Flatten()
def mesh_spheres(count):
tmp_sp = []
for i in xrange(count):
tmp_sp.append(ghpc.MeshSphere(
rs.MovePlane(rs.WorldXYPlane(), (i,i,0)), 0.5, 8, 8))
return tmp_sp
def SampleGardenPath():
# Acquire information for the garden path
start_point = rs.GetPoint('Start point of path')
if start_point is None: return
end_point = rs.GetPoint('End point of path', start_point)
if end_point is None: return
half_width = rs.GetDistance(start_point, None, 'First width point',
'Half width of path')
if half_width is None: return
tile_radius = rs.GetReal('Radius of tiles', 1.0)
if tile_radius is None: return
if tile_radius <= 0.0: return
tile_spacing = rs.GetReal('Distance between tiles', 1.0)
if tile_spacing is None: return
if tile_spacing < 0.0: return
# To increase speed, disable redrawing
rs.EnableRedraw(False)
# Calculate angles
angle_rc = rs.Angle(start_point, end_point)
angle = angle_rc[0]
length = rs.Distance(start_point, end_point)
width = half_width * 2
angle_p90 = angle + 90.0
angle_m90 = angle - 90.0
# Draw the outline of the path
polyline = []
polyline.append(rs.Polar(start_point, angle_m90, half_width))
polyline.append(rs.Polar(polyline[0], angle, length))
polyline.append(rs.Polar(polyline[1], angle_p90, width))
polyline.append(rs.Polar(polyline[2], angle + 180.0, length))
polyline.append(polyline[0])
rs.AddPolyline(polyline)
# Draw the rows of tiles
plane = rs.WorldXYPlane()
distance = tile_radius + tile_spacing
offset = 0.0
while (distance <= length - tile_radius):
# Place one row of tiles given polyline along path and possibly offset it
first = rs.Polar(start_point, angle, distance)
current = rs.Polar(first, angle_p90, offset)
next = current
while (rs.Distance(first, next) < half_width - tile_radius):
plane = rs.MovePlane(plane, next)
rs.AddCircle(plane, tile_radius)
next = rs.Polar(next, angle_p90,
tile_spacing + tile_radius + tile_radius)
next = rs.Polar(current, angle_m90,
tile_spacing + tile_radius + tile_radius)
while (rs.Distance(first, next) < half_width - tile_radius):
plane = rs.MovePlane(plane, next)
rs.AddCircle(plane, tile_radius)
next = rs.Polar(next, angle_m90,
tile_spacing + tile_radius + tile_radius)
distance = distance + ((tile_spacing + tile_radius + tile_radius) *
math.sin(60.0 * 180.0 / math.pi))
if (offset == 0.0):
offset = (tile_spacing + tile_radius + tile_radius) * math.cos(
60.0 * 180.0 / math.pi)
else:
offset = 0.0
rs.EnableRedraw(True)
def rc_plot_volumes(use_epsilon):
#get sticky
default_thickness = sticky["defaultThickness"] if sticky.has_key(
"defaultThickness") else 5.5
go = Rhino.Input.Custom.GetObject()
go.GeometryFilter = Rhino.DocObjects.ObjectType.Brep
opt_thickness = Rhino.Input.Custom.OptionDouble(default_thickness, 0.2,
1000)
opt_sections = Rhino.Input.Custom.OptionToggle(False, "No", "Yes")
opt_inplace = Rhino.Input.Custom.OptionToggle(False, "No", "Yes")
opt_heights = Rhino.Input.Custom.OptionToggle(False, "No", "Yes")
go.SetCommandPrompt("Select breps to extract plan cuts")
go.AddOptionDouble("Thickness", opt_thickness)
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)
global THICKNESS
THICKNESS = opt_thickness.CurrentValue
global LCUT_INDICES
LCUT_INDICES = wla.get_lcut_layers()
#Get brep representations of objects
brep_geo_list = []
for i in xrange(go.ObjectCount):
b_obj = go.Object(i).Object()
brep_geo_list.append(b_obj.Geometry)
#...brep conversion may be necessary
new_brep_list = []
for i, geo in enumerate(brep_geo_list):
if geo.GetType() != Rhino.Geometry.Brep:
new_brep_list.append(wru.extrusion_to_brep(geo))
else:
new_brep_list.append(geo)
#set base for output.
xbase = 0
ybase = 0
#set the amount to move up from the bottom of the brep for cutting the lower outline.
#this should be replaced by a projection of the bottom face of the brep.
epsilon = D_TOL * 2
select_items = []
for i, brep in enumerate(new_brep_list):
#get label prefix and bounding dims for this brep
bdims = wge.get_bounding_dims(brep)
baseplane = rs.MovePlane(rs.WorldXYPlane(), [xbase, ybase, 0])
label_letter = wut.number_to_letter(i)
label_prefix = label_letter + "-"
#prepare heights and labels for each section cut
num_sections = 1
remaining_thickness = 0
cuts_at = [epsilon] if use_epsilon else [0]
brep_label = label_letter
section_labels = [label_letter]
num_sections, remaining_thickness, cuts_at = get_section_division(
bdims.Z, THICKNESS)
if use_epsilon: cuts_at[0] = epsilon
brep_label = label_letter + " r: " + str(round(remaining_thickness, 2))
section_labels = [label_prefix + str(i) for i in xrange(len(cuts_at))]
#get section information for each cut
section_planes = get_brep_section_planes(brep, cuts_at)
#get lowest curve info
section_curves, section_dims = [[], []]
for i, plane in enumerate(section_planes):
curve, dims = [0, 0]
if (not use_epsilon) and (i == 0):
curve, dims = get_lowest_curve_info(brep, D_TOL * 2)
else:
curve, dims = get_section_curve_info_multi_no_ortho(
brep, plane)
section_curves.append(curve)
section_dims.append(dims)
##DO WORK HERE##
drawing_planes = get_drawing_planes(section_dims, baseplane, GAP_SIZE)
#place curves in drawing location
for sp, dp, sc in zip(section_planes, drawing_planes, section_curves):
t = Rhino.Geometry.Transform.ChangeBasis(dp, sp)
for c in sc:
c.Transform(t)
#THIS IS STILL A MESS: LABEL ADDING
#draw curves and add text dots
top_label_pt = get_brep_label_pt(brep)
brep_textdot = rs.AddTextDot(brep_label, top_label_pt)
rs.ObjectLayer(brep_textdot, "XXX_LCUT_00-GUIDES")
label_pts = []
for sc, label in zip(section_curves, section_labels):
temp_area = 0
for i, c in enumerate(sc):
crv = wru.add_curve_to_layer(c, LCUT_INDICES[1])
select_items.append(crv)
if i == 0:
label_pts.append(rs.CurveAreaCentroid(crv)[0])
temp_area = rs.CurveArea(crv)
else:
if rs.CurveArea(crv) > temp_area:
label_pts[-1] = rs.CurveAreaCentroid(crv)[0]
temp_area = rs.CurveArea(crv)
fab_tags = wfa.add_fab_tags(label_pts, section_labels, TEXTSIZE)
for tag in fab_tags:
rs.ObjectLayer(tag, "XXX_LCUT_02-SCORE")
group_name = rs.AddGroup()
rs.AddObjectsToGroup(tag, group_name)
ybase += max([s.Y for s in section_dims]) + GAP_SIZE * 1
for tag in fab_tags:
select_items.extend(tag)
#THIS IS STILL A MESS: LABEL ADDING
sticky["defaultThickness"] = THICKNESS
rs.UnselectAllObjects()
rs.SelectObjects(select_items)
rs.Redraw()
rs.EnableRedraw(True)
def CreateCircularSurface(self, b, radius):
plane = rs.MovePlane(rs.WorldXYPlane(), (0, 0, b))
circle = rs.AddCircle(plane, radius)
surface = rs.AddPlanarSrf([circle])
rs.DeleteObject(circle)
return surface
def RunCommand(is_interactive):
global params
center = rs.GetPoint(message="Select center point")
n = rs.GetInteger(message="Number of teeth",
number=params["n"], minimum=4)
m = rs.GetReal(message="Gear module",
number=params["m"])
pa = rs.GetReal(message="Pressure angle",
number=params["pa"], minimum=0, maximum=45)
ha = rs.GetReal(message="Helix angle",
number=params["ha"], minimum=-45, maximum=45)
t = rs.GetReal(message="Thickness",
number=params["t"], minimum=0)
bool_opts = rs.GetBoolean(message="Output options",
items=(("PitchCylinder", "No", "Yes"),),
defaults=(params["pc"],))
if None in [center, n, m, pa, ha, t, bool_opts]:
return 1 # Cancel
pc = bool_opts[0]
params["n"] = n
params["m"] = m
params["pa"] = pa
params["ha"] = ha
params["t"] = t
params["pc"] = pc
cplane = rs.ViewCPlane() # Get current CPlane
cplane = rs.MovePlane(cplane, center)
xform = rs.XformChangeBasis(cplane, rs.WorldXYPlane())
rs.EnableRedraw(False)
old_plane = rs.ViewCPlane(plane=rs.WorldXYPlane())
gear = generate_gear_crv(teeth=params["n"],
module=params["m"],
pressure_angle=params["pa"])
pitch = abs((n * m * pi) / tan(radians(ha)))
turns = t / pitch
if ha < 0:
# Left handed helix
turns = -turns
centerline = rs.AddLine([0, 0, 0], [0, 0, t])
helix = rs.AddSpiral([0, 0, 0],
[0, 0, t],
pitch=pitch,
turns=turns,
radius0=(m * n) / 2)
helical_gear_srf = rs.AddSweep2(rails=[centerline, helix], shapes=[gear])
rs.DeleteObjects([centerline, helix, gear])
rs.ViewCPlane(plane=old_plane)
rs.TransformObjects(helical_gear_srf, xform)
if pc:
circle = generate_pitch_circle_crv(teeth=params["n"],
module=params["m"])
pitch_cyl_srf = rs.ExtrudeCurveStraight(circle,
start_point=[0, 0, 0],
end_point=[0, 0, t])
rs.TransformObjects(pitch_cyl_srf, xform)
rs.DeleteObject(circle)
rs.SelectObjects([helical_gear_srf, pitch_cyl_srf])
else:
rs.SelectObjects(helical_gear_srf)
rs.EnableRedraw(True)
return 0 # Success
def rc_plot_volumes(use_epsilon):
go = Rhino.Input.Custom.GetObject()
go.GeometryFilter = Rhino.DocObjects.ObjectType.Brep
default_inplaceBool = sticky["inplaceBool"] if sticky.has_key(
"inplaceBool") else False
default_heightsBool = sticky["heightsBool"] if sticky.has_key(
"heightsBool") else False
opt_inplace = Rhino.Input.Custom.OptionToggle(default_inplaceBool, "No",
"Yes")
opt_heights = Rhino.Input.Custom.OptionToggle(default_heightsBool, "No",
"Yes")
go.SetCommandPrompt("Select breps to extract plan cuts")
go.AddOptionToggle("InPlace", opt_inplace)
go.AddOptionToggle("PrintPieceHeights", opt_heights)
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)
DIRPT1 = rs.coerce3dpoint([0, 0, 0])
DIRPT2 = rs.coerce3dpoint([1, 0.001, 0])
global BOOL_HEIGHTS
global LCUT_INDICES
global SORTDIR
BOOL_HEIGHTS = opt_heights.CurrentValue
LCUT_INDICES = wla.get_lcut_layers()
SORTDIR = DIRPT2 - DIRPT1
#Get boolean for "inplace"
INPLACE = opt_inplace.CurrentValue
#Get brep representations of objects
brep_geo_list = []
for i in xrange(go.ObjectCount):
b_obj = go.Object(i).Object()
brep_geo_list.append(b_obj.Geometry)
#...brep conversion may be necessary
new_brep_list = []
for i, geo in enumerate(brep_geo_list):
if geo.GetType() != Rhino.Geometry.Brep:
new_brep_list.append(wru.extrusion_to_brep(geo))
else:
new_brep_list.append(geo)
#set base for output.
xbase = 0
ybase = 0
#set the amount to move up from the bottom of the brep for cutting the lower outline.
#this should be replaced by a projection of the bottom face of the brep.
epsilon = D_TOL * 2
select_items = []
centroids = [
c.GetBoundingBox(rs.WorldXYPlane()).Center for c in new_brep_list
]
brep_collection = zip(centroids, new_brep_list)
brep_collection = sorted(brep_collection, sortcompare)
_, new_brep_list = zip(*brep_collection)
for i, brep in enumerate(new_brep_list):
#get lowest curve info
#get label prefix and bounding dims for this brep
bdims = wge.get_bounding_dims(brep)
baseplane = rs.MovePlane(rs.WorldXYPlane(), [xbase, ybase, 0])
label_letter = wut.number_to_letter(i)
#prepare heights and labels for each section cut
num_sections = 1
remaining_thickness = 0
cuts_at = [epsilon] if use_epsilon else [0]
brep_label = label_letter
section_labels = [label_letter]
if BOOL_HEIGHTS == True:
section_labels = [
label + "\n" + str(round(bdims.Z, 1))
for label in section_labels
]
#get section information for each cut
section_planes = get_brep_section_planes(brep, cuts_at)
section_curves, section_dims = [[], []]
for i, plane in enumerate(section_planes):
curve, dims = [0, 0]
if (not use_epsilon) and (i == 0):
curve, dims = get_lowest_curve_info(brep, D_TOL * 2)
else:
curve, dims = get_section_curve_info_multi_no_ortho(
brep, plane)
section_curves.append(curve)
section_dims.append(dims)
##DO WORK HERE##
drawing_planes = get_drawing_planes(section_dims, baseplane, GAP_SIZE)
#place curves in drawing location
for sp, dp, sc in zip(section_planes, drawing_planes, section_curves):
if INPLACE == True:
t = Rhino.Geometry.Transform.Translation(0, 0, 0)
else:
t = Rhino.Geometry.Transform.ChangeBasis(dp, sp)
for c in sc:
c.Transform(t)
#THIS IS STILL A MESS: LABEL ADDING
#draw curves and add text dots
top_label_pt = get_brep_label_pt(brep)
brep_textdot = rs.AddTextDot(brep_label, top_label_pt)
rs.ObjectLayer(brep_textdot, "XXX_LCUT_00-GUIDES")
label_pts = []
for sc, label in zip(section_curves, section_labels):
for i, c in enumerate(sc):
crv = wru.add_curve_to_layer(c, LCUT_INDICES[1])
select_items.append(crv)
if i == 0:
label_pts.append(rs.CurveAreaCentroid(crv)[0])
fab_tags = wfa.add_fab_tags(label_pts, section_labels, TEXTSIZE)
for tag in fab_tags:
rs.ObjectLayer(tag, "XXX_LCUT_02-SCORE")
group_name = rs.AddGroup()
rs.AddObjectsToGroup(tag, group_name)
ybase += max([s.Y for s in section_dims]) + GAP_SIZE * 1
for tag in fab_tags:
select_items.extend(tag)
sticky["inplaceBool"] = INPLACE
sticky["heightsBool"] = BOOL_HEIGHTS
rs.UnselectAllObjects()
rs.SelectObjects(select_items)
rs.Redraw()
rs.EnableRedraw(True)
def createAirplane(self):
#CREATE FUSELAGE
rectangleFuselage = rs.AddRectangle(self.location,
self.genes.values['Fw'],
self.genes.values['Fh'])
endPointsF = rs.PolylineVertices(rectangleFuselage)
fPtsB = offsetPoints(self.genes.values['Fpb'], endPointsF[0],
endPointsF[1])
fPtsR = offsetPoints(self.genes.values['Fpr'], endPointsF[1],
endPointsF[2])
fPtsT = offsetPoints(self.genes.values['Fpt'], endPointsF[2],
endPointsF[3])
fPtsL = offsetPoints(self.genes.values['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],
(self.genes.values['Fwx'], self.genes.values['Fwy'], 0))
wingSlotEnd = rs.VectorAdd(
wingSlotStart,
(self.genes.values['Fw'] - self.genes.values['Fwx'] +
maxPointOffset * 2, 0, 0))
wingSlot = rs.AddLine(wingSlotStart, wingSlotEnd)
#guideLine = rs.AddLine(wingSlotStart,rs.VectorAdd(wingSlotStart,(0,0.2,0)))
#rs.ObjectColor(guideLine,(0,0,200))
#wingSlotOffset = rs.OffsetCurve(wingSlot,(0,1,0),1/32)
#rs.AddLine(rs.CurveStartPoint(wingSlot),rs.CurveStartPoint(wingSlotOffset))
#CREATE WING
wPlaneOffY = self.genes.values['Wh'] + 1
wPlaneOffX = self.genes.values['Fw'] / 2
wingPlane = rs.MovePlane(self.location,
(wPlaneOffX + self.location[0].X,
-wPlaneOffY + self.location[0].Y, 0))
rectangleWing = rs.AddRectangle(wingPlane, self.genes.values['Ww'],
self.genes.values['Wh'])
endPointsW = rs.PolylineVertices(rectangleWing)
wPtsB = offsetPoints(self.genes.values['Wpb'], endPointsW[0],
endPointsW[1])
wPtsR = offsetPoints(self.genes.values['Wps'], endPointsW[1],
endPointsW[2])
wPtsT = offsetPoints(self.genes.values['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])
wingCurveM = rs.MirrorObject(wingCurve, endPointsW[3], endPointsW[0],
True)
#CREATE WING GROOVE
wingGrooveStart = rs.VectorAdd(endPointsW[3], (0, maxPointOffset, 0))
wingGrooveEnd = rs.VectorAdd(
wingGrooveStart,
(0, -(maxPointOffset +
self.genes.values['Wh'] * self.genes.values['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)
textPlane = rs.MovePlane(
self.location,
(self.location[0].X + .25, self.location[0].Y + .25, 0))
text = rs.AddText(self.number, textPlane, 0.25)
textCurves = rs.ExplodeText(text, True)
rs.ObjectColor(textCurves, (0, 0, 200))
planeGroup = rs.AddGroup()
rs.AddObjectsToGroup(
[fCurveOpen, wingCurveM, wingSlot, wingCurve, wingGroove, text],
planeGroup)
#coding=utf-8
import rhinoscriptsyntax as rs
plane = rs.WorldXYPlane() #建立XY工作平面
mplane = rs.MovePlane(plane, [6, 6.5, 0]) #移动平面
rectangle = rs.AddCircle(mplane, 5) #建立圆形
dpointsc = rs.DivideCurve(rectangle, 20) #等分矩形
dpoints = rs.AddPoints(dpointsc) #增加等分点
for i in range(len(dpoints)):
rs.AddText(str(i), dpoints[i], 1) #添加字
print(dpoints)
#sphere = rs.AddSphere(dpoints[3],1)
#cube = rs.AddBox(rs.BoundingBox(sphere))
sdpoints = dpoints[:] #切片提取点
for i in range(len(sdpoints)):
sphere = rs.AddSphere(sdpoints[i], 0.5)
cube = rs.AddBox(rs.BoundingBox(sphere))
rs.DeleteObject(sphere) #删除不再使用的球体
xform = rs.XformTranslation([i, i * 1.3, i * 1.3]) #分步骤执行比gh同步更灵活
trancube = rs.TransformObject(cube, xform)
def xf_scale(ctr, scale=(1, 1, 1)):
if 0 in scale: raise Exception("Attempted to scale by 0%")
pln = rs.MovePlane(rs.WorldXYPlane(), ctr)
xs, ys, zs = scale
xform = Rhino.Geometry.Transform.Scale(pln, xs, ys, zs)
return xform
def RunCommand(is_interactive):
global params
center = rs.GetPoint(message="Select center point")
n = rs.GetInteger(message="Number of teeth",
number=params["n"], minimum=4)
m = rs.GetReal(message="Gear module",
number=params["m"])
pa = rs.GetReal(message="Pressure angle",
number=params["pa"], minimum=0, maximum=45)
ca = rs.GetReal(message="Cone angle",
number=params["ca"], minimum=0, maximum=180)
bool_opts = rs.GetBoolean(message="Output options",
items=(("PitchCone", "No", "Yes"),),
defaults=(params["pc"],))
if None in [center, n, m, pa, ca, bool_opts]:
return 1 # Cancel
pc = bool_opts[0]
params["n"] = n
params["m"] = m
params["pa"] = pa
params["ca"] = ca
params["pc"] = pc
cplane = rs.ViewCPlane() # Get current CPlane
cplane = rs.MovePlane(cplane, center)
xform = rs.XformChangeBasis(cplane, rs.WorldXYPlane())
rs.EnableRedraw(False)
old_plane = rs.ViewCPlane(plane=rs.WorldXYPlane())
gear = generate_gear_crv(teeth=params["n"],
module=params["m"],
pressure_angle=params["pa"],
cone_angle=params["ca"])
# Calculate pitch cone tip
cone_tip = [0, 0, (m * n / 2) / tan(radians(ca/2))]
bevel_gear_srf = rs.ExtrudeCurvePoint(gear, cone_tip)
rs.ViewCPlane(plane=old_plane)
rs.TransformObjects(bevel_gear_srf, xform)
if pc:
circle = generate_pitch_circle_crv(teeth=params["n"],
module=params["m"])
pitch_cone_srf = rs.ExtrudeCurvePoint(circle, cone_tip)
rs.TransformObjects(pitch_cone_srf, xform)
rs.DeleteObjects([gear, circle])
rs.SelectObjects([bevel_gear_srf, pitch_cone_srf])
else:
rs.DeleteObject(gear)
rs.SelectObjects(bevel_gear_srf)
rs.EnableRedraw(True)
return 0 # Success
def slicing(self, ghdoc_, path_, geometries, geometry_index, layer_height, whd):
pic_size = 1000
#######################################################################
### Base Size
### Create and Bake
rect_ = cg.create_rect(whd)
bg.bake_breps(ghdoc_, rect_)
### Capture and Delete
file_name = path_ + "size\\size.png"
cmd.capture_image_size_w_all_option(file_name, pic_size, pic_size)
### Create and Bake
rect_ = cg.create_rect(whd)
bg.bake_breps(ghdoc_, rect_)
### Capture and Delete
file_name = path_ + "size\\size.png"
cmd.capture_image_size_w_all_option(file_name, pic_size, pic_size)
#######################################################################
slice_count = int(whd / layer_height) + 1
# print(slice_count)
### Select geometry
target = geometries[geometry_index]
### Slicing Loop
sliced_surface = []
v = []
for i in xrange(slice_count):
current_height = layer_height * i
v.append(current_height)
### Mesh x Plane Intersection
p = rs.MovePlane(rs.WorldXYPlane(), [0, 0, current_height])
pl = self.slice_plane(target, p)
### Polyline to Surface
if pl != None:
# print(pl)
surfaces = cg.create_surface_from_polylines(pl)
# print(surfaces)
# sliced_surface.append(surfaces)
### Bake Geometry
bg.bake_breps(ghdoc_, surfaces)
### Capture and Delete
gi_pad = "%03d"%geometry_index
i_pad = "%05d"%i
file_name = path_ + "{}\\{}.png".format(gi_pad, i_pad)
cmd.capture_image_size(file_name, pic_size, pic_size)
# return sliced_surface
return v
def expand(intStartY): #this function expands the points in the Y direction
global dictPointByNum #all the global vars
global dictPointByCord
global cvBaseCurve
global sfBaseSurface
global reRadius
global reBase
global reDist
global ltObjectPoint
ltStartXY = (0, intStartY) #this is the point we start
if ltStartXY not in dictPointByNum:
return 0
quePoint = Queue.Queue(
maxsize=0) #get point from the queue until it is empty
quePoint.put(dictPointByNum[ltStartXY])
ltNeAndPo = (-1, 1)
while quePoint.qsize() > 0:
ptcordTmpPoint = quePoint.get(
) #this is the point we concern now, we also need the points near it
ltTmpPointNum = dictPointByCord[ptcordTmpPoint]
for intNeOrPo in ltNeAndPo:
ltTmpPointNearNum = (ltTmpPointNum[0] + intNeOrPo,
ltTmpPointNum[1])
if ltTmpPointNearNum not in dictPointByNum:
continue
ptcordTmpPointNear = dictPointByNum[
ltTmpPointNearNum] #get the cord of the near point
planeXYPlane = rs.WorldXYPlane()
planeTmpPlane0 = rs.MovePlane(planeXYPlane, ptcordTmpPoint)
planeTmpPlane1 = rs.MovePlane(planeXYPlane, ptcordTmpPointNear)
ltInterResults = rs.IntersectSpheres(planeTmpPlane0, reRadius,
planeTmpPlane1, reRadius)
#get the intersection results of two spheres
if ltInterResults:
cvInterCircle = rs.AddCircle(ltInterResults[1],
ltInterResults[2])
else:
return
ltTmpIntersection = rs.CurveSurfaceIntersection(
cvInterCircle, sfBaseSurface) #get new points
if ltTmpIntersection is None:
continue
boolAdd = 0
for ltIntersectionPoint in ltTmpIntersection: #Add the points
if ltIntersectionPoint[0] == 1:
ptcordTmpPointInter = ltIntersectionPoint[1]
boolInOrNot = InOrOut(ptcordTmpPointInter)
if boolInOrNot == 0:
boolAdd = 1
if intNeOrPo < 0:
AddPoint(ptcordTmpPointInter, ptcordTmpPoint,
ltTmpPointNearNum, 1)
else:
AddPoint(ptcordTmpPointInter, ptcordTmpPoint,
ltTmpPointNum, 1)
else:
print "Impossible"
return -1
if boolAdd > 0:
quePoint.put(ptcordTmpPointNear)
rs.DeleteObject(cvInterCircle)
'''
for intNeOrPoHigh in ltNeAndPo:
if (ltTmpPointNum[0]+intNeOrPoHigh,ltTmpPointNum[1]) not in dictPointByNum:
for intNeOrPo in ltNeAndPo:
if intNeOrPoHigh==1:
ltTmpPointNearNum = (ltTmpPointNum[0]-intNeOrPoHigh,ltTmpPointNum[1]+intNeOrPo)
else:
ltTmpPointNearNum = (ltTmpPointNum[0],ltTmpPointNum[1]+intNeOrPo)
if ltTmpPointNearNum not in dictPointByNum:
continue
ptcordTmpPointNear = dictPointByNum[ltTmpPointNearNum] #get the cord of the near point
ptcordTmpPointDist = dictPointByNum[(ltTmpPointNum[0]-intNeOrPoHigh,ltTmpPointNum[1])]
reDistanceTmp = rs.Distance(ptcordTmpPointDist,ptcordTmpPoint)
planeXYPlane = rs.WorldXYPlane()
planeTmpPlane0 = rs.MovePlane(planeXYPlane, ptcordTmpPoint)
planeTmpPlane1 = rs.MovePlane(planeXYPlane, ptcordTmpPointNear)
ltInterResults = rs.IntersectSpheres(planeTmpPlane0, reDistanceTmp, planeTmpPlane1, reRadius)
'''
return 0
end = (0,100,0)
nCols = 6
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
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 test():
#Assign variables to the sin and cos functions for use later.
Sin = math.sin
Cos = math.cos
# Acquire information for the garden path
# set default values for the distances
default_hwidth = 1
default_trad = 1
default_tspace = 1
# look for any previously used values stored in sticky and use those if available.
if sc.sticky.has_key("GP_WIDTH"):
default_hwidth = sc.sticky["GP_WIDTH"]
if sc.sticky.has_key("GP_RAD"):
default_trad = sc.sticky["GP_RAD"]
if sc.sticky.has_key("GP_Space"):
default_tspace = sc.sticky["GP_SPACE"]
#get the path direction, length and location from two points entered by the user
sp = rs.GetPoint("Start point of path centerline")
if sp is None: return
ep = rs.GetPoint("End point of path centerline", sp)
if ep is None: return
#now ask the user what the distances should be, offering the defaults arrived at above
hwidth = rs.GetDistance(sp,
default_hwidth,
second_pt_msg="Half width of path")
if hwidth is None: return
#Store the new value in sticky for use next time
sc.sticky["GP_WIDTH"] = hwidth
trad = rs.GetDistance(sp, default_trad, second_pt_msg="Radius of tiles")
if trad is None: return
#Store the new value in sticky for use next time
sc.sticky["GP_RAD"] = trad
tspace = rs.GetDistance(sp,
default_tspace,
second_pt_msg="Distance between tiles")
if tspace is None: return
#Store the new value in sticky for use next time
sc.sticky["GP_SPACE"] = tspace
# Calculate angles
temp = rs.Angle(sp, ep)
pangle = temp[0]
plength = rs.Distance(sp, ep)
width = hwidth * 2
angp90 = pangle + 90.0
angm90 = pangle - 90.0
# To increase speed, disable redrawing
rs.EnableRedraw(False)
# Draw the outline of the path
#make an empty list
pline = []
#add points to the list
pline.append(rs.Polar(sp, angm90, hwidth))
pline.append(rs.Polar(pline[0], pangle, plength))
pline.append(rs.Polar(pline[1], angp90, width))
pline.append(rs.Polar(pline[2], pangle + 180.0, plength))
#add the first point back on to the end of the list to close the pline
pline.append(pline[0])
#create the polyline from the lst of points.
rs.AddPolyline(pline)
# Draw the rows of tiles
#define a plane -
#using the WorldXY plane the reults will always be added parallel to that plane,
#regardless of the active plane where the points are picked.
plane = rs.WorldXYPlane()
pdist = trad + tspace
off = 0.0
while (pdist <= plength - trad):
#Place one row of tiles given distance along path
# and possibly offset it
pfirst = rs.Polar(sp, pangle, pdist)
pctile = rs.Polar(pfirst, angp90, off)
pltile = pctile
while (rs.Distance(pfirst, pltile) < hwidth - trad):
plane = rs.MovePlane(plane, pltile)
rs.AddCircle(plane, trad)
pltile = rs.Polar(pltile, angp90, tspace + trad + trad)
pltile = rs.Polar(pctile, angm90, tspace + trad + trad)
while (rs.Distance(pfirst, pltile) < hwidth - trad):
plane = rs.MovePlane(plane, pltile)
rs.AddCircle(plane, trad)
pltile = rs.Polar(pltile, angm90, tspace + trad + trad)
pdist = pdist + ((tspace + trad + trad) * Sin(math.radians(60)))
if off == 0.0:
off = (tspace + trad + trad) * Cos(math.radians(60))
else:
off = 0.0
def xf_shear(ctr, vx=(1, 0, 0), vy=(0, 1, 0), vz=(0, 0, 1)):
pln = rs.MovePlane(rs.WorldXYPlane(), ctr)
xform = Rhino.Geometry.Transform.Shear(pln, rs.CreateVector(vx),
rs.CreateVector(vy),
rs.CreateVector(vz))
return xform
def rc_cut_plan(boundary_brep, cut_heights, floor_guids, use_epsilon):
bb = rs.BoundingBox(boundary_brep)
max_z = bb[4].Z
min_z = bb[0].Z
crv_list, layer_list, refpt_list, bdims_list = [[], [], [], []]
for i, guids in enumerate(floor_guids):
if not (min_z < cut_heights[i] < max_z): continue
outline_crv, internals, refpt, bdims = process_floor(
guids, boundary_brep, cut_heights[i])
mp = Rhino.Geometry.AreaMassProperties.Compute(outline_crv)
outline_crv_centroid = mp.Centroid
corner_style = Rhino.Geometry.CurveOffsetCornerStyle.Sharp
offset_crv = outline_crv.Offset(outline_crv_centroid,
rs.coerce3dvector([0, 0, 1]),
THICKNESS, D_TOL, corner_style)
offset_crv_geometry = offset_crv[0]
crv_list.append([[offset_crv_geometry], internals])
layer_list.append([LCUT_INDICES[1], LCUT_INDICES[2]])
refpt_list.append(refpt)
bdims_list.append(bdims)
#...brep conversion may be necessary
if len(crv_list) == 0:
print "Error: Cut planes do not intersect the envelope brep"
return None
#set base for output.
xbase = 0
ybase = 0
#set the amount to move up from the bottom of the brep for cutting the lower outline.
#this should be replaced by a projection of the bottom face of the brep.
epsilon = D_TOL * 2
select_items = []
increment = max(d.X for d in bdims_list) + GAP_SIZE * 1
dplane_list = get_drawing_planes(bdims_list, rs.WorldXYPlane(), GAP_SIZE)
refplane_list = [rs.MovePlane(rs.WorldXYPlane(), pt) for pt in refpt_list]
for i, floor in enumerate(crv_list):
t = Rhino.Geometry.Transform.ChangeBasis(dplane_list[i],
refplane_list[i])
for j, layer_crvs in enumerate(floor):
for c in layer_crvs:
c.Transform(t)
select_items.extend(
wru.add_curves_to_layer(layer_crvs, layer_list[i][j]))
labelpt = (bdims_list[i].X / 2 + dplane_list[i].Origin.X,
bdims_list[i].Y / 2 + dplane_list[i].OriginY, 0)
td = rs.AddTextDot(str(i + 1), labelpt)
rs.ObjectLayer(td, "XXX_LCUT_00-GUIDES")
select_items.append(td)
rs.UnselectAllObjects()
rs.SelectObjects(select_items)
rs.Redraw()
rs.EnableRedraw(True)
