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 RemoveFromBlock():
block = rs.GetObject("Select Block to extract objects from",
rs.filter.instance,
preselect=True)
if not block: return
blockName = rs.BlockInstanceName(block)
objref = rs.coercerhinoobject(block)
idef = objref.InstanceDefinition
idefIndex = idef.Index
XformBlock = rs.BlockInstanceXform(block)
blockObjects = rs.BlockObjects(blockName)
blockInstanceObjects = rs.TransformObjects(blockObjects, XformBlock, True)
objs = rs.GetObjects("Select Objects to extract from Block",
objects=blockInstanceObjects)
if not objs:
rs.DeleteObjects(blockInstanceObjects)
return
keep = [] #List to keep in block
delete = [] #list to delete from block and add to doc
rs.EnableRedraw(False)
for object in blockInstanceObjects:
if object in objs: delete.append(object)
else: keep.append(object)
if rs.IsBlockReference(blockName):
print "Block is referenced from file; unable to modify block"
rs.DeleteObjects(keep)
return
rs.TransformObjects(keep, rs.XformInverse(XformBlock), False)
newGeometry = []
newAttributes = []
for object in keep:
newGeometry.append(rs.coercegeometry(object))
ref = Rhino.DocObjects.ObjRef(object)
attr = ref.Object().Attributes
newAttributes.append(attr)
InstanceDefinitionTable = sc.doc.ActiveDoc.InstanceDefinitions
InstanceDefinitionTable.ModifyGeometry(idefIndex, newGeometry,
newAttributes)
rs.DeleteObjects(keep)
rs.EnableRedraw(True)
def BlockTxt(block, str = False, cstr = False, boolFlipHeb=True):
if not block: return
blockName = rs.BlockInstanceName(block)
objref = rs.coercerhinoobject(block)
idef = objref.InstanceDefinition
idefIndex = idef.Index
XformBlock = rs.BlockInstanceXform(block)
blockObjects = rs.BlockObjects(blockName)
txtobjs = False
for obj in blockObjects:
if rs.IsText(obj):
if not str: txtobjs = True
elif rs.TextObjectText(obj) == str: txtobjs = True
if txtobjs:
blockInstanceObjects = rs.TransformObjects(blockObjects, XformBlock, True)
keep = []
rs.EnableRedraw(False)
for obj in blockInstanceObjects:
if rs.IsText(obj):
if not str and not cstr:
str = rs.TextObjectText(obj)
cstr = ConvTxt(str, boolFlipHeb)
if not cstr == str:
rs.TextObjectText(obj, cstr)
keep.append(obj)
else: keep.append(obj)
rs.TransformObjects(keep, rs.XformInverse(XformBlock), False)
newGeometry = []
newAttributes = []
for object in keep:
newGeometry.append(rs.coercegeometry(object))
ref = Rhino.DocObjects.ObjRef(object)
attr = ref.Object().Attributes
newAttributes.append(attr)
InstanceDefinitionTable = sc.doc.ActiveDoc.InstanceDefinitions
InstanceDefinitionTable.ModifyGeometry(idefIndex, newGeometry, newAttributes)
rs.DeleteObjects(keep)
def teardown(cfg):
print("teardown")
cfg['view'].Close()
"""
activate_display_mode(cfg['view_restore']['disp_mode'], cfg)
cfg['view'].Maximized = cfg['view_restore']['maximized']
cfg['view'].Size = cfg['view_restore']['size']
"""
if 'pad_obj_ids' in cfg and cfg['pad_obj_ids']:
print("... deleting padding objects")
rs.DeleteObjects(cfg['pad_obj_ids'])
if 'tmp_obj_ids' in cfg and cfg['tmp_obj_ids']:
print("... deleting xformed objects")
rs.DeleteObjects(cfg['tmp_obj_ids'])
if 'rot_group' in cfg and cfg['rot_group']:
print("... rotating objects back to their starting position")
rxf = rs.XformRotation2(-cfg['tot_rot'], (0, 0, 1),
cfg['rot_group']['bbox'].Center)
rs.TransformObjects(cfg['rot_group']['obj_ids'], rxf)
show_all_groups(cfg)
sc.doc.RenderSettings = cfg['render_settings']
for mode in cfg['display_modes'].keys():
if mode == 'rndr': continue
if not Rhino.Display.DisplayModeDescription.DeleteDiplayMode(
cfg['display_modes'][mode].Id):
print(
"Temporary display mode {} was not deleted. Consider removing this yourself."
.format(cfg['display_modes'][mode].EnglishName))
delete_residual_display_modes()
return
def RunCommand(is_interactive):
global params
pitch_line = rs.GetObject(message="Select pitch line",
filter=rs.filter.curve,
preselect=True)
if pitch_line is None:
return 1 # Cancel
if not rs.IsLine(pitch_line):
print "Selected curve is not a line!"
return 1 # Cancel
rs.SelectObjects(pitch_line)
m = rs.GetReal(message="Rack module", number=params["m"])
pa = rs.GetReal(message="Pressure angle",
number=params["pa"],
minimum=0,
maximum=45)
if m is None or pa is None:
return 1 # Cancel
params["m"] = m
params["pa"] = pa
pitch_line_center = rs.CurveMidPoint(pitch_line)
pitch_line_start = rs.CurveStartPoint(pitch_line)
pitch_line_end = rs.CurveEndPoint(pitch_line)
angle, reflex_angle = rs.Angle2(line1=((0, 0, 0), (1, 0, 0)),
line2=(pitch_line_start, pitch_line_end))
x_vector = rs.VectorCreate(pitch_line_end, pitch_line_start)
y_vector = rs.VectorRotate(x_vector, 90.0, [0, 0, 1])
cplane = rs.PlaneFromFrame(origin=pitch_line_center,
x_axis=x_vector,
y_axis=y_vector)
xform = rs.XformChangeBasis(cplane, rs.WorldXYPlane())
rs.EnableRedraw(False)
old_plane = rs.ViewCPlane(plane=rs.WorldXYPlane())
rack = draw_rack(length=rs.CurveLength(pitch_line),
module=params["m"],
pressure_angle=params["pa"])
rs.ViewCPlane(plane=old_plane)
rs.TransformObjects(rack, xform)
rs.EnableRedraw(True)
rs.UnselectAllObjects()
rs.SelectObjects(rack)
return 0 # Success
def ScaleObjectWorld000(ObjectId, Scaling):
# Scales an object in the World coordinate system. Similar functionality to
# Rhino's ScaleObject, but the latter uses the current construction plane.
# The scaling is done with respect to the origin of the World system (0,0,0)
# Arguments: ObjectId - the object to be scaled
# Scaling - a three element list or tuple containg the scaling
# factors along x, y and z respectively
xform = rs.XformScale(Scaling)
ObjectId = rs.TransformObjects(ObjectId, xform)
return ObjectId
def reorient_objects(objects, basePlane, targetPlane, copy=True):
"""performs a plane to plane reorient on an object w/ or w/out copying"""
if targetPlane == None:
return None
else:
world = rs.WorldXYPlane()
xform1 = rs.XformChangeBasis(world, basePlane)
xform2 = rs.XformChangeBasis(targetPlane, world)
xform_final = rs.XformMultiply(xform2, xform1)
transform = rs.TransformObjects(objects, xform_final, copy)
return transform
def applyXform(target, source):
targetXform = rs.BlockInstanceXform(target)
sourceXform = rs.BlockInstanceXform(source)
if targetXform is not None:
plane = rs.PlaneTransform(rs.WorldXYPlane(), targetXform)
# 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(sourceXform, cob)
xform = rs.XformMultiply(cob_inverse, temp)
rs.TransformObjects(target, xform)
def MakeBlockUnique(block, newName):
"""
Explodes a block and makes a new one with 'newName'
"""
xform = rs.BlockInstanceXform(block)
insertPt = rs.BlockInstanceInsertPoint(block)
objs = rs.ExplodeBlockInstance(block, False)
rs.TransformObjects(objs, rs.XformInverse(xform))
pt = rs.TransformObject(insertPt, rs.XformInverse(xform))
rs.AddBlock(objs, insertPt, newName, True)
newBlock = rs.InsertBlock2(newName, xform)
rs.DeleteObject(pt)
return newBlock
def convertToPolylines(obj):
# get object properties
text = rs.TextObjectText(obj)
pt = rs.TextObjectPoint(obj)
origin = rs.coerce3dpoint([0,0,0])
ht = rs.TextObjectHeight(obj)
object_layer = rs.ObjectLayer(obj)
plane = rs.TextObjectPlane(obj)
diff = rs.coerce3dpoint([pt.X, pt.Y, pt.Z])
p1 = rs.WorldXYPlane()
matrix = rs.XformRotation4(p1.XAxis, p1.YAxis, p1.ZAxis, plane.XAxis, plane.YAxis, plane.ZAxis)
rs.DeleteObject(obj)
# set current layer to put strings in
prevlayer = rs.CurrentLayer()
layer = rs.AddLayer('temptextlayer')
rs.CurrentLayer('temptextlayer')
# split text at enters
text = text.split('\r\n')
opts='GroupOutput=No FontName="timfont" Italic=No Bold=No Height='+ str(ht)
opts+=" Output=Curves AllowOpenCurves=Yes LowerCaseAsSmallCaps=No AddSpacing=No "
origin.Y += ht * len(text) *1.2
for item in text:
rs.Command("_-TextObject " + opts + '"'+item+'"' + " " + str(origin) , False)
origin.Y -= ht *1.5
#restore current layer
rs.CurrentLayer(prevlayer)
#select newly created texts
polylines = rs.ObjectsByLayer('temptextlayer')
# transform to old position
rs.TransformObjects(polylines, matrix, copy=False)
rs.MoveObjects(polylines, diff)
rs.ObjectLayer(polylines, object_layer)
return polylines
def blkObjs(blkid):
blockName = rs.BlockInstanceName(blkid)
# objref = rs.coercerhinoobject(blkid)
# idef = objref.InstanceDefinition
# idefIndex = idef.Index
lvl = levels[rs.GetUserText(blkid, 'level')]
height = lvl['height']
xform = rs.BlockInstanceXform(blkid)
objects = [x for x in rs.BlockObjects(blockName) if rs.IsPolysurfaceClosed(x)]
objects = map(lambda x: rs.SetUserText(x, 'level', lvl), objects)
# map(lambda x: rs.SetUserText(x, 'height', lvl))
blockInstanceObjects = rs.TransformObjects(objects, xform, True)
def convertTextToPolylines2(obj):
# get object properties
text = rs.TextObjectText(obj)
pt = rs.TextObjectPoint(obj)
origin = rs.coerce3dpoint([0, 0, 0])
ht = rs.TextObjectHeight(obj)
object_layer = rs.ObjectLayer(obj)
plane = rs.TextObjectPlane(obj)
diff = rs.coerce3dpoint([pt.X, pt.Y, pt.Z])
p1 = rs.WorldXYPlane()
#restore view cplane
rs.ViewCPlane(None, p1)
matrix = rs.XformRotation4(p1.XAxis, p1.YAxis, p1.ZAxis, plane.XAxis,
plane.YAxis, plane.ZAxis)
rs.DeleteObject(obj)
# split text at enters
text = text.split('\r\n')
opts = 'GroupOutput=No FontName="' + EXPORT_FONT + '" Italic=No Bold=No Height=' + str(
ht)
opts += " Output=Curves AllowOpenCurves=Yes LowerCaseAsSmallCaps=No AddSpacing=No "
n_lines = len(text)
origin.Y += 1.6 * ht * (len(text) - 1)
polylines = []
for item in text:
rs.Command(
"_-TextObject " + opts + '"' + item + '"' + " " + str(origin),
False)
polylines += rs.LastCreatedObjects()
origin.Y -= ht * 1.6
rs.ObjectLayer(polylines, object_layer)
polylines = rs.ScaleObjects(polylines, (0, 0, 0), (0.7, 1, 1), True)
# transform to old position
rs.TransformObjects(polylines, matrix, copy=False)
rs.MoveObjects(polylines, diff)
return polylines
def redefineBlockScale(block):
block_name = rs.BlockInstanceName(block)
# rs.RenameBlock (block_name, "{}-old".format(block_name))
blockXform = rs.BlockInstanceXform(block)
plane = rs.PlaneTransform(rs.WorldXYPlane(), blockXform)
cob = rs.XformChangeBasis(plane, rs.WorldXYPlane())
cob_inverse = rs.XformChangeBasis(rs.WorldXYPlane(), plane)
refBlock = rs.TransformObjects(block, cob_inverse, True)
exploded = rs.ExplodeBlockInstance(refBlock)
rs.AddBlock(exploded, rs.WorldXYPlane().Origin, block_name, True)
newBlock = rs.InsertBlock2(block_name, cob)
copySourceLayer(newBlock, block)
try:
copySourceData(newBlock, block)
except:
pass
rs.DeleteObjects(block)
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 blkObjs(blkid):
blockName = rs.BlockInstanceName(blkid)
# objref = rs.coercerhinoobject(blkid)
# idef = objref.InstanceDefinition
# idefIndex = idef.Index
# lvl = levels[rs.GetUserText(blkid, 'level')]
# height = lvl['height']
xform = rs.BlockInstanceXform(blkid)
# objects = [x for x in rs.BlockObjects(blockName) if 'mass' in rs.ObjectLayer(x)]
objects = filter(lambda x: 'mass' in rs.ObjectLayer(x),
rs.BlockObjects(blockName))
# objects = filter(lambda x: 'mass' in rs.ObjectLayer(x) and rs.GetUserText(x, 'class') != 'na', rs.BlockObjects(blockName))
# objects = map(lambda x: rs.SetUserText(x, 'level', lvl), objects)
# map(lambda x: rs.SetUserText(x, 'height', lvl))
blockInstanceObjects = rs.TransformObjects(objects, xform, True)
masses.extend(blockInstanceObjects)
def calcFootprint(_zoneObjs, _opaqueSurfaces):
# Finds the 'footprint' of the building for 'Primary Energy Renewable' reference
# 1) Re-build the zone Breps
# 2) Join all the zone Breps into a single brep
# 3) Find the 'box' for the single joined brep
# 4) Find the lowest Z points on the box, offset another 10 units 'down'
# 5) Make a new Plane at this new location
# 6) Projects the brep onto the new Plane
#-----
zoneBreps = []
for zone in _zoneObjs:
zoneSurfaces = []
for srfc in _opaqueSurfaces:
if srfc.HostZoneName == zone.ZoneName:
zoneSurfaces.append(ghc.BoundarySurfaces(srfc.Boundary))
zoneBrep = ghc.BrepJoin(zoneSurfaces).breps
zoneBreps.append(zoneBrep)
bldg_mass = ghc.SolidUnion(zoneBreps)
if bldg_mass == None:
return None
#------- Find Corners, Find 'bottom' (lowest Z)
bldg_mass_corners = [v for v in ghc.BoxCorners(bldg_mass)]
bldg_mass_corners.sort(reverse=False, key=lambda point3D: point3D.Z)
rect_pts = bldg_mass_corners[0:3]
#------- Project Brep to Footprint
projection_plane1 = ghc.Plane3Pt(rect_pts[0], rect_pts[1], rect_pts[2])
projection_plane2 = ghc.Move(projection_plane1, ghc.UnitZ(-10)).geometry
matrix = rs.XformPlanarProjection(projection_plane2)
footprint_srfc = rs.TransformObjects(bldg_mass, matrix, copy=True)
footprint_area = rs.Area(footprint_srfc)
#------- Output
Footprint = namedtuple('Footprint',
['Footprint_surface', 'Footprint_area'])
fp = Footprint(footprint_srfc, footprint_area)
return fp
def AddToBlock():
objects = rs.GetObjects("Choose Objects to Add to Block", preselect=True)
if not objects: return
block = rs.GetObject("Choose Block to Add Object to", rs.filter.instance)
if not block: return
rs.EnableRedraw(False)
blockName = rs.BlockInstanceName(block)
objref = rs.coercerhinoobject(block)
idef = objref.InstanceDefinition
idefIndex = idef.Index
if rs.IsBlockReference(blockName):
print "Block is referenced from file; unable to add object(s)"
return
blnCopy = False
XformBlock = rs.BlockInstanceXform(block)
rs.TransformObjects(objects, rs.XformInverse(XformBlock), blnCopy)
objects.extend(rs.BlockObjects(blockName))
newGeometry = []
newAttributes = []
for object in objects:
newGeometry.append(rs.coercegeometry(object))
ref = Rhino.DocObjects.ObjRef(object)
attr = ref.Object().Attributes
newAttributes.append(attr)
InstanceDefinitionTable = sc.doc.ActiveDoc.InstanceDefinitions
InstanceDefinitionTable.ModifyGeometry(idefIndex, newGeometry,
newAttributes)
rs.DeleteObjects(objects)
rs.EnableRedraw(True)
def SampleArrayCrv():
obj_ids = rs.GetObjects("Select objects to array")
if not obj_ids: return
base_pt = rs.GetPoint("Base point")
if not base_pt: return
plane = rs.ViewCPlane()
plane.Origin = base_pt
crv_id = rs.GetObject("Select path curve")
if not crv_id: return
count = rs.GetInteger("Number of items", 2, 2)
if not count: return
if rs.IsCurveClosed(crv_id): count -= 1
crv_t = rs.DivideCurve(crv_id, count, False, False)
for t in crv_t:
frame = rs.CurveFrame(crv_id, t)
xform = rs.XformRotation1(plane, frame)
rs.TransformObjects(obj_ids, xform, True)
def drawRhombusOnRegularOffsetLine(emblem):
tmpObjs = []
for rhomboid in emblem.rhomboids:
objs = []
# 中点長方形の対角四角形
for i in range(len(rhomboid.midPts)):
p0 = rhomboid.midPts[i]
if (i == 0):
nextMidPt = rhomboid.midPts[i + 1]
prevtMidPt = rhomboid.midPts[len(rhomboid.midPts) - 1]
elif (i == len(rhomboid.midPts) - 1):
nextMidPt = rhomboid.midPts[0]
prevtMidPt = rhomboid.midPts[i - 1]
else:
nextMidPt = rhomboid.midPts[i + 1]
prevtMidPt = rhomboid.midPts[i - 1]
p1 = rs.VectorAdd(p0, nextMidPt)
p1 = rs.VectorDivide(p1, 2.0)
p2 = rhomboid.ellipsePts[0]
p3 = rs.VectorAdd(p0, prevtMidPt)
p3 = rs.VectorDivide(p3, 2.0)
pts = [p0, p1, p2, p3, p0]
obj = rs.AddPolyline(pts)
if (i % 2 == 0):
rs.ObjectLayer(obj, "srf%s" % rhomboid.lines[1].no)
else:
rs.ObjectLayer(obj, "srf%s" % rhomboid.lines[0].no)
objs.append(obj)
# 外周面
pts = []
for pt in rhomboid.pts:
pts.append(pt)
pts.append(pts[0])
obj = rs.AddPolyline(pts)
rs.ObjectLayer(obj, "srfRhomboid")
objs.append(obj)
# 外周線
for i in range(len(rhomboid.pts)):
if (i == len(rhomboid.pts) - 1):
obj = rs.AddLine(rhomboid.pts[i], rhomboid.pts[0])
else:
obj = rs.AddLine(rhomboid.pts[i], rhomboid.pts[i + 1])
rs.ObjectLayer(obj, "lineBlack")
objs.append(obj)
# move to center
objs = rs.MoveObjects(objs, [
-rhomboid.ellipsePts[0][0], -rhomboid.ellipsePts[0][1],
-rhomboid.ellipsePts[0][2]
])
# rotate
xform = rs.XformRotation2(rhomboid.rotateAng, [0, 0, 1], [0, 0, 0])
rs.TransformObjects(objs, xform)
# move
pts = rs.LineLineIntersection(
[rhomboid.lines[0].sPt, rhomboid.lines[0].ePt],
[rhomboid.lines[1].sPt, rhomboid.lines[1].ePt])
rs.MoveObjects(objs, pts[0])
# tmpObjs
for obj in objs:
tmpObjs.append(obj)
return tmpObjs
def FixedFractureGen(n, aspect_ratio=None, sides=None):
"""
A function to add a fixed number of circles in a cube. It also writes data
to fracture data text file for regenerating fracture networks.
"""
if fracture_shape == 'circle':
# initialize a to store fractures
fracture_list = []
# a loop to insert the fixed number of fractures
for i in range(n):
#layer name for the frcature
layer_name = "FRACTURE_" + str(i + 1)
#create an istance of Fracture class
frac = Fracture()
#store fracture name
frac.fracture_name = layer_name
#generate origin for fracture
origin = GeneratePoint(boxlength)
#store farcture center
frac.fracture_center = origin
#convert the origin to a plane
plane = InclinePlane(origin)
#add layer and color
rs.AddLayer(layer_name, rs.CreateColor(0, 255, 0))
#make current layer
rs.CurrentLayer(layer_name)
#insert the fracture in the domain
my_circle = rs.AddCircle(plane, radius)
#circle_list.append(my_circle)
surf = rs.AddPlanarSrf(my_circle)
#delete initial fracture drawn which is a curve
rs.DeleteObject(my_circle)
#save fracture's GUID
frac.fracture_GUID = surf[0]
#append fracture into fracture list
fracture_list.append(frac)
elif fracture_shape == 'ellipse':
#list to store fracture surface GUIDs
fracture_list = []
for i in range(n):
#layer name for the frcature
layer_name = "FRACTURE_" + str(i + 1)
#create an istance of Fracture class
frac = Fracture()
frac.fracture_name = layer_name
#generate fracture origin
origin = GeneratePoint(boxlength)
frac.fracture_center = origin
#plane for fracture
plane = InclinePlane(origin)
#calculate r_y
ry = radius / aspect_ratio
#create layer for fracture
rs.AddLayer(layer_name, rs.CreateColor(0, 255, 0))
rs.CurrentLayer(layer_name)
#draw ellipse
fracture = rs.AddEllipse(plane, radius, ry)
# write the plane, r_x and r_y to file for re-plotting
##file.write("\n" + str(plane[0]) + "," + str(plane[1]) + "," + str(plane[2]) + "," + str(radius) + ","+ str(ry))
#make fracture a surface
frac_surf = rs.AddPlanarSrf(fracture)
#delete initial fracture drawn which is a curve
rs.DeleteObject(fracture)
#append surface GUID to list of fracture surfaces
frac.fracture_GUID = frac_surf[0]
fracture_list.append(frac)
elif fracture_shape == 'polygon':
#list to store fracture surface GUIDs
fracture_list = []
#write the shape type
##file.write('\npolygon\n')
for i in range(n):
layer_name = "FRACTURE_" + str(i + 1)
frac = Fracture()
frac.fracture_name = layer_name
#theta in radian
theta_rad = (2 * math.pi) / sides
#theta in degree (interior angles)
theta_deg = theta_rad * (180 / math.pi)
#generate origin
origin = GeneratePoint(boxlength)
frac.fracture_center = origin
#create a 3D point object which isn't visible to the rhino document
pt_01 = rs.coerce3dvector(
[radius + origin[0], origin[1], origin[2]])
#empty list to store all points
points = []
#a rotation axis
ax = rs.coerce3dvector([0, 0, 1])
#loop to generate points for polygon vertices
#file.write("\n")
for j in range(sides):
#rotation transform with rotation from the origin
trans = rs.XformRotation2(theta_deg * j, ax, origin)
#transform the original 3D point and append to list
points.append(rs.PointTransform(pt_01, trans))
# append the initial point to close the polygon
points.append(pt_01)
# create layer for fracture
# layer_name = "FRACTURE_" + str(i+1)
rs.AddLayer(layer_name, rs.CreateColor(0, 255, 0))
rs.CurrentLayer(layer_name)
# get GUID of created polygon
polygon = rs.AddPolyline(points)
# polygon = rs.AddPolyline(points)
plane = InclinePlane(origin, boxlength)
cob = rs.XformChangeBasis(rs.WorldXYPlane(), plane)
shear2d = rs.XformIdentity()
shear2d[0, 2] = math.tan(math.radians(45.0))
cob_inverse = rs.XformChangeBasis(plane, rs.WorldXYPlane())
temp = rs.XformMultiply(shear2d, cob)
xform = rs.XformMultiply(cob_inverse, temp)
fracture = rs.TransformObjects(polygon, xform, False)
# make fracture a surface
frac_surf = rs.AddPlanarSrf(fracture)
# delete initial fracture drawn which is a curve
rs.DeleteObject(fracture)
frac.fracture_GUID = frac_surf[0]
fracture_list.append(frac)
return fracture_list
def main():
# get our curves
profile, cross = get_two_curves()
if profile is None or cross is None:
return
##################################################
# get bounding box for cross section
cross_bbox = rs.BoundingBox([cross])
cmin, cmax = box_to_points(cross_bbox)
cz_range = cmax[2] - cmin[2]
cz = 0.5 * (cmax[2] + cmin[2])
c_ctr, _ = rs.CurveAreaCentroid(cross)
# make sure it's planar in XY
if cz_range > 1e-9:
print 'cross section curve should be planar in XY plane'
return
##################################################
# get bounding box for profile
profile_bbox = rs.BoundingBox([profile])
# make sure it's planar in in YZ
pmin, pmax = box_to_points(profile_bbox)
px_range = pmax[0] - pmin[0]
if px_range > 1e-9:
print 'profile curve should be planar in YZ plane'
return
##################################################
# get the point closest to the center for the
# cross-section curve
r, pc = get_inscribed_radius(cross, c_ctr)
##################################################
# get the range of z-values for the profile curve
_, _, z0 = pmin
_, _, z1 = pmax
##################################################
# build list of rings and list of points
points = []
ring_pipes = []
# for each level
for i in range(num_levels):
# get the Z value of the ith plane
u = float(i) / (num_levels-1)
z = z0 + u*(z1 - z0)
# build the i'th plane
plane = rs.PlaneFromNormal([0, 0, z], [0, 0, 1], [1, 0, 0])
# find out where the plane intersects the profile curve
intersect = rs.PlaneCurveIntersection(plane, profile)
# there should be exactly one intersection of type 1 (point)
if intersect is None or len(intersect) > 1 or intersect[0][0] != 1:
print 'bad intersection'
return
# get the intersection point
pi = intersect[0][1]
# get the desired XY radius at this z value
ri = abs(pi[1])
# we need to set up some transformations:
# translate cross section curve down to z=0
T1 = rs.XformTranslation(mz.vec_mul(list(c_ctr), -1.0))
# scale it along XY by the ratio of radii
S1 = rs.XformScale([ri/r, ri/r, 1.0])
# scale a piped cross section along Z by a vertical scale factor
S2 = rs.XformScale([1.0, 1.0, ring_vscale])
# translate piped cross section up to our desired z value
T2 = rs.XformTranslation([0, 0, z])
# scale and translate cross section curve
ci = rs.TransformObject(cross, rs.XformMultiply(S1, T1), copy=True)
# pipe it
ring = rs.AddPipe(ci, [0, 1], [ring_rad, ring_rad])
# scale vertically and transform up
ring = rs.TransformObject(ring, rs.XformMultiply(T2, S2))
# delete the copy of the cross section curve
rs.DeleteObject(ci)
# add to list of ring pipes
ring_pipes.append(ring)
# create a rotation by the i'th angle
angle_i_deg = i*360.0/num_sides
Ri = rs.XformRotation2(angle_i_deg, [0, 0, 1], [0, 0, 0])
# transform the closest point by rotation and scale
pci = rs.PointTransform(pc,
rs.XformMultiply(rs.XformMultiply(Ri, T2), S1))
# add to list of points
points.append(pci)
# we have built up a list of points for a single spiral of struts to connect,
# now we need to pipe them all together and do the ArrayPolar thing around
# the z axis
# first build a single spiral of struts
strut_pipes = []
for i0 in range(num_levels-1):
i1 = i0+1
p0 = points[i0]
p1 = points[i1]
l01 = rs.AddLine(p0, p1)
pipe = rs.AddPipe(l01, [0, 1], [strut_rad, strut_rad], cap=2)
rs.DeleteObject(l01)
strut_pipes.append(pipe)
# then array polar around Z axis
all_strut_pipes = []
all_strut_pipes += strut_pipes
for j in range(1, num_sides):
angle_j_deg = j*360.0/num_sides
Rj = rs.XformRotation2(angle_j_deg, [0, 0, 1], [0, 0, 0])
all_strut_pipes += rs.TransformObjects(strut_pipes, Rj, copy=True)
# now just select all the objects we created
rs.SelectObjects(ring_pipes + all_strut_pipes)
# done!
print 'yay'
def MultiNestedBoundaryTrimCurves():
msg="Select closed boundary curves for trimming"
TCrvs = rs.GetObjects(msg, 4, preselect=False)
if not TCrvs: return
cCrvs=[crv for crv in TCrvs if rs.IsCurveClosed(crv)]
if len(cCrvs)==0:
print "No closed trim curves found"
return
rs.LockObjects(cCrvs)
origCrvs = rs.GetObjects("Select curves to trim", 4)
rs.UnlockObjects(cCrvs)
if not origCrvs : return
#plane which is active when trim curve is chosen
refPlane = rs.ViewCPlane()
if sc.sticky.has_key("TrimSideChoice"):
oldTSChoice = sc.sticky["TrimSideChoice"]
else:
oldTSChoice=True
choice = [["Trim", "Outside", "Inside"]]
res = rs.GetBoolean("Side to trim away?", choice, [oldTSChoice])
if not res: return
trimIns = res[0] #False=Outside
tol=sc.doc.ModelAbsoluteTolerance
bb=rs.BoundingBox(origCrvs,refPlane) #CPlane box, world coords
if not bb: return
zVec=refPlane.ZAxis
rs.EnableRedraw(False)
botPlane=Rhino.Geometry.Plane(bb[0]-zVec,zVec) #check
xform=rs.XformPlanarProjection(botPlane)
cutCrvs=rs.TransformObjects(cCrvs,xform,True)
ccc=CheckPlanarCurvesForCollision(cutCrvs)
if ccc:
msg="Boundary curves overlap, results may be unpredictable, continue?"
res=rs.MessageBox(msg,1+32)
if res!= 1: return
bSrfs=rs.AddPlanarSrf(cutCrvs)
rs.DeleteObjects(cutCrvs)
if bSrfs == None: return
line=rs.AddLine(bb[0]-zVec,bb[4]+zVec)
vols=[]
for srf in bSrfs:
ext=rs.ExtrudeSurface(srf,line,True)
if ext != None: vols.append(ext)
rs.DeleteObjects(bSrfs)
rs.DeleteObject(line)
if len(vols)==0: return
exGroup=rs.AddGroup()
rs.AddObjectsToGroup(vols,exGroup)
rs.Prompt("Splitting curves...")
rs.SelectObjects(origCrvs)
rs.Command("_Split _-SelGroup " + exGroup + " _Enter", False)
splitRes=rs.LastCreatedObjects()
rs.DeleteGroup(exGroup)
rs.Prompt("Classifying trims...")
noSplit=[]
for crv in origCrvs:
#add curve to list if it has not been split (still exists in doc)
id=sc.doc.Objects.Find(crv)
if id != None: noSplit.append(crv)
errors=0
if splitRes:
if len(noSplit)>0: splitRes.extend(noSplit)
for crv in splitRes:
inside=MultiTestInOrOut(crv,vols)
if inside != None:
if (inside and trimIns) or (not inside and not trimIns):
rs.DeleteObject(crv)
else:
errors+=1
rs.DeleteObjects(vols)
if errors>0: print "Problems with {} curves".format(errors)
sc.sticky["TrimSideChoice"] = trimIns
def projectLayersToClpane(layers):
for layer in layers:
curves = rs.ObjectsByLayer(layer)
xform = rs.XformPlanarProjection(rs.WorldXYPlane())
rs.TransformObjects(curves, xform, False)
def alingBlock(block_a, block_b, model_inside):
"""
Scale box to the correct dimentions
Align box a and what is inside to box b
The dimention of the box is expected to be equal lenght
:param block_a:
:param block_b: block to align block_a to
:param model_inside: models inside block_a
"""
# Find center of box_a
exp_a = rs.ExplodePolysurfaces(block_a)
cen_a = Vector3d(0, 0, 0)
for exp in exp_a:
cen_a += rs.SurfaceAreaCentroid(exp)[0]
cen_a /= 6.0
# Find center of box_b
exp_b = rs.ExplodePolysurfaces(block_b)
cen_b = Vector3d(0, 0, 0)
for exp in exp_b:
cen_b += rs.SurfaceAreaCentroid(exp)[0]
cen_b /= 6.0
# Find side Lenght
c = rs.DuplicateEdgeCurves(exp_a[0])
L = float(rs.CurveLength(c[0]))
def sqrt_length(a, b, c):
return math.sqrt(a * a + b * b + c * c)
def create_matrix(a, b, c, d):
M = [[a[0], a[1], a[2], d[0]], [b[0], b[1], b[2], d[1]],
[c[0], c[1], c[2], d[2]], [0, 0, 0, 1]]
return M
# find basic function of box_a
basic_0 = cen_a - rs.SurfaceAreaCentroid(exp_a[0])[0]
basic_0 /= sqrt_length(basic_0[0], basic_0[1], basic_0[2])
basic_1 = rs.SurfaceAreaCentroid(exp_a[1])[0] - cen_a
basic_1 /= sqrt_length(basic_1[0], basic_1[1], basic_1[2])
basic_2 = cen_a - rs.SurfaceAreaCentroid(exp_a[4])[0]
basic_2 /= sqrt_length(basic_2[0], basic_2[1], basic_2[2])
# create tranformation matrix
M = create_matrix(basic_0, basic_1, basic_2, [0, 0, 0])
# scale
rs.ScaleObjects([block_a] + model_inside, cen_a,
[200 / L, 200 / L, 200 / L])
# move to [0,0,0]
rs.MoveObjects([block_a] + model_inside, -cen_a)
# rotate
rs.TransformObjects([block_a] + model_inside, M)
# move to object
rs.MoveObjects([block_a] + model_inside, cen_b)
rs.DeleteObjects(exp_a)
rs.DeleteObjects(exp_b)
rs.DeleteObjects(c)
def main():
cfg = setup()
rs.CurrentView(cfg['view'].ActiveViewportID)
# MAIN LOOP
msg0 = "{} views at {} zoom levels across {} xforms of {} objects.".format(
cfg['view_count'], len(cfg['obj_bbox_pads']), cfg['xform_count'],
len(cfg['groups_info']))
msg1 = "{} images will result.".format(cfg['total_image_count'])
print(msg0)
print(msg1)
if rs.MessageBox(
"This script will plot {}\n{}\nThe folder {} has been created for this purpose.\nShall we proceed?"
.format(msg0, msg1, cfg['pth_save']), 4,
"Ready to plot {} images?".format(cfg['total_image_count'])) != 6:
teardown(cfg)
exit()
cfg['tmp_obj_ids'] = False
cfg['rot_group'] = False
cfg['tot_rot'] = False
try:
#raise Exception("nope")
for g, group_info in enumerate(cfg['groups_info']):
print("##### {} ({} of {})".format(group_info['name'].lower(),
g + 1, len(cfg['groups_info'])))
#print("{} objects in this group".format(len(group_info['obj_ids'])))
#set_camera(group_info['bbox'], cfg)
isolate_group(g, cfg)
deg = 360.0 / cfg['view_count']
rxf = rs.XformRotation2(deg, (0, 0, 1), group_info['bbox'].Center)
cfg['rot_group'] = group_info
cfg['tot_rot'] = 0
for r in range(cfg['view_count']):
for x, xf in enumerate(
xforms_to_apply(group_info['bbox'], cfg, DEBUG)):
all_layers_on(cfg)
cfg['tmp_obj_ids'] = apply_xf(
xf, group_info['obj_ids']) # apply this transformation
rs.RemoveObjectsFromGroup(cfg['tmp_obj_ids'],
group_info['name'])
rs.HideGroup(group_info['name'])
for p, pad in enumerate(cfg['obj_bbox_pads']):
xbbox = bbox_of_objects(cfg['tmp_obj_ids'])
set_camera(xbbox, pad, cfg)
name = "{}_r{:03}_x{:02}_p{:02}_{}".format(
group_info['name'].lower(), r, x, p,
cfg['layer_info']['parent'].Name.lower())
is_first = (r == 0 and x == 0)
do_capture(name, is_first, cfg) # capture view
isolate_group(g, cfg)
all_layers_on(cfg)
rs.DeleteObjects(cfg['tmp_obj_ids'])
cfg['tmp_obj_ids'] = False
Rhino.RhinoApp.Wait()
if (sc.escape_test(False)):
raise Exception('Esc key caught in main()')
rs.TransformObjects(group_info['obj_ids'], rxf)
cfg['tot_rot'] += deg
cfg['rot_group'] = False
cfg['tot_rot'] = 0
except Exception as e:
print("!!!! SCRIPT STOPPED !!!!")
print e
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print(exc_type, fname, exc_tb.tb_lineno)
finally:
teardown(cfg)
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 drawEhombusTilingByRegularOffsetLine(emblem):
tmpObjs = []
# self.rhomboids
for rhomboid in emblem.rhomboids:
objs = []
# 中点長方形の対角四角形
for i in range(len(rhomboid.midPts)):
p0 = rhomboid.midPts[i]
if (i == 0):
nextMidPt = rhomboid.midPts[i + 1]
prevtMidPt = rhomboid.midPts[len(rhomboid.midPts) - 1]
elif (i == len(rhomboid.midPts) - 1):
nextMidPt = rhomboid.midPts[0]
prevtMidPt = rhomboid.midPts[i - 1]
else:
nextMidPt = rhomboid.midPts[i + 1]
prevtMidPt = rhomboid.midPts[i - 1]
p1 = rs.VectorAdd(p0, nextMidPt)
p1 = rs.VectorDivide(p1, 2.0)
p2 = rhomboid.ellipsePts[0]
p3 = rs.VectorAdd(p0, prevtMidPt)
p3 = rs.VectorDivide(p3, 2.0)
pts = [p0, p1, p2, p3, p0]
obj = rs.AddPolyline(pts)
if (i % 2 == 0):
rs.ObjectLayer(obj, "srf%s" % rhomboid.lines[1].no)
else:
rs.ObjectLayer(obj, "srf%s" % rhomboid.lines[0].no)
objs.append(obj)
# 外周面
pts = []
for pt in rhomboid.pts:
pts.append(pt)
pts.append(pts[0])
obj = rs.AddPolyline(pts)
rs.ObjectLayer(obj, "srfRhomboid")
objs.append(obj)
# 外周線
for i in range(len(rhomboid.pts)):
if (i == len(rhomboid.pts) - 1):
obj = rs.AddLine(rhomboid.pts[i], rhomboid.pts[0])
else:
obj = rs.AddLine(rhomboid.pts[i], rhomboid.pts[i + 1])
rs.ObjectLayer(obj, "lineBlack")
objs.append(obj)
# rotate
xform = rs.XformRotation2(rhomboid.rotateAng, [0, 0, 1], [0, 0, 0])
rs.TransformObjects(objs, xform)
# move
rs.MoveObjects(objs, rhomboid.movePt)
# text
txt = "%s" % (rhomboid.name)
pt = rhomboid.getAbsolutePt(rhomboid.ellipsePts[0])
height = 1.2
pt = [pt[0], pt[1] + height / 2.0, pt[2]]
obj = rs.AddText(txt,
pt,
height,
font,
font_style=0,
justification=2 + 65536)
rs.ObjectLayer(obj, "textRhomboid")
objs.append(obj)
# tmpObjs
for obj in objs:
tmpObjs.append(obj)
# move to center
pts = rs.BoundingBox(tmpObjs)
center = rs.VectorAdd(pts[0], pts[2])
center = rs.VectorScale(center, 0.5)
center = rs.VectorSubtract([0, 0, 0], center)
rs.MoveObjects(tmpObjs, center)
return tmpObjs
rs.CapPlanarHoles(surf)
#Draw spines
cone = rs.AddCone([0, 0, -sh], sh, sr)
basis = []
theta = ma.pi / 8
dphi = 2 * ma.pi / m
for k in range(0, m):
phi = k * dphi
x = ma.sin(theta) * ma.cos(phi)
y = ma.sin(theta) * ma.sin(phi)
z = ma.cos(theta)
matrix = rs.XformRotation3([0, 0, 1], [x, y, z], [0, 0, 0])
basis.append(rs.TransformObject(cone, matrix, True))
rs.DeleteObject(cone)
for crv in ridges:
domain = rs.CurveDomain(crv)
dt = (domain[1] - domain[0]) / 10
for j in range(1, 10):
t = domain[0] + j * dt
point = rs.EvaluateCurve(crv, t)
xaxis = rs.CurveTangent(crv, t)
yaxis = rs.VectorCrossProduct(xaxis, point)
zaxis = rs.VectorCrossProduct(xaxis, yaxis)
matrix = rs.XformRotation3([0, 0, 1], zaxis, [0, 0, 0])
copy = rs.TransformObjects(basis, matrix, True)
matrix = rs.XformTranslation(point)
rs.TransformObjects(copy, matrix)
rs.DeleteObjects(basis)
def profileXform(sec, plane, vec):
xvec = rs.XformTranslation(vec)
cob = rs.XformChangeBasis(plane, rs.WorldXYPlane())
xform = rs.XformMultiply(cob, xvec)
return rs.TransformObjects(sec, xform, False)
import rhinoscriptsyntax as rs
import operator
hatch = rs.GetObject(message="Pick any hatch", filter=rs.filter.hatch)
trim_lines = rs.GetObjects(message="Select cutting lines", filter=rs.filter.curve)
# Project trim_lines to cplane
plane = rs.ViewCPlane()
matrix = rs.XformPlanarProjection(plane)
rs.TransformObjects(trim_lines, matrix, copy=False)
selected_objects = []
selected_objects.append(trim_lines)
if hatch:
# Store original hatch settings
hatch_pattern = rs.HatchPattern(hatch)
hatch_rotation = rs.HatchRotation(hatch)
hatch_scale = rs.HatchScale(hatch)
# Make hatch solid so we able to explode it and get surface instead
if hatch_pattern != "Solid":
rs.HatchPattern(hatch, "Solid")
dup_border_surface = []
dup_border_surface.append(rs.ExplodeHatch(hatch)[0])
rs.SurfaceIsocurveDensity(dup_border_surface, 100)
selected_objects.append(dup_border_surface)
reduced_selected_objects = reduce(operator.add, selected_objects)
rs.SelectObjects(reduced_selected_objects)
rs.HideObject(hatch)
rs.Command("_Trim")
