def finish():
items = ("Points", "Reserve", "Delete")
results = rs.GetBoolean("Delete options", items, (True))
if results[0]:
for object in ltObjectPoint:
rs.DeleteObject(object)
return 0
def GetOptions():
restore = rs.GetBoolean("Rhino Appearance Settings",
[("Option", "Save", "Restore")], [False])
if restore is None: return
restore = restore[0]
name = rs.GetString("Scheme Name")
if name: return name, restore
def DelOffScreen():
try:
obj = rs.GetObjects('Select objects to test', preselect=True)
bool = rs.GetBoolean('Delete or Hide', ('Option', 'Delete', 'Hide'),
(False))
if obj:
rs.EnableRedraw(False)
for i in obj:
isVisible = rs.IsVisibleInView(i)
if isVisible == False:
if bool[0] == True:
rs.HideObject(i)
if bool[0] == False:
rs.DeleteObject(i)
rs.EnableRedraw(True)
except:
print("Failed to execute")
rs.EnableRedraw(True)
return
def continue_or_not():
items = ("Continue", "False", "True")
results = rs.GetBoolean("Continue options", items, (True))
if results:
return results[0]
else:
return 1
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 main():
"""
Creates a part list for all blocks in a document. Numbers will correspond with
balloons, but balloons don't need to be present for the table to be generated
version 1.3
www.studiogijs.nl
version 1.1 adds table heading
version 1.2 option for choosing between all or only top level blocks
version 1.3 adds block description. Use change_block_description.py
or change in block manager
"""
t = sc.sticky['top_level_only'] if sc.sticky.has_key(
'top_level_only') else 0 #0 = top level only, 1= all blocks
if t == None:
t = 0
top_level_only = rs.GetBoolean("annotate top level blocks only?",
["top_level_only", "yes", "no"], t)
if not top_level_only:
return
sc.sticky['top_level_only'] = top_level_only[0]
previous_layer = rs.CurrentLayer()
#check if layer 'annotation' exist, else create it
if not rs.IsLayer("annotation"): rs.AddLayer("annotation")
rs.LayerColor("annotation", Col.Black)
rs.CurrentLayer("annotation")
groups = sc.doc.ActiveDoc.Groups
partlist = []
blocknames = get_block_names()
if not blocknames:
print "This file does not contain block items (titleblock will be ignored)"
return
#add headings
texts = ["ITEM", "PART NAME", "DESCR", "QTY"]
partlist.append(texts)
texts = []
for block_nr, blockname in enumerate(blocknames, 1):
texts.append(str(block_nr))
texts.append(blockname)
description = rs.BlockDescription(blockname)
if description is None:
description = ""
texts.append(description)
blockcount = get_block_count(blockname)
texts.append(str(blockcount))
partlist.append(texts)
texts = []
create_table(partlist)
#change back to previous layer
rs.CurrentLayer(previous_layer)
def annotation_balloon():
"""
Adds a numbered balloon to the document based on the numbering in part list.
Works only with block items, similar to how this works in 'solid modelers'
on parts in assemblies
www.studiogijs.nl
version 1.1: option for choosing between all or only top level blocks
"""
t = sc.sticky['top_level_only'] if sc.sticky.has_key('top_level_only') else 0 #0 = top level only, 1= all blocks
if t==None:
t=0
top_level_only = rs.GetBoolean("annotate top level blocks only?", ["top_level_only", "yes", "no"],t)
if not top_level_only:
return
sc.sticky['top_level_only'] = top_level_only[0]
name = get_blockname()
if not name:
return
previous_layer = rs.CurrentLayer()
#check if layer 'annotation' exist, else create it
if not rs.IsLayer("annotation"): rs.AddLayer("annotation")
rs.LayerColor("annotation",Col.Black)
rs.CurrentLayer("annotation")
block_nr = get_block_index(name)+1
curve, size = get_input()
if curve and size:
aCircle, aText, aCurve = add_annotation_circle(curve, block_nr, size)
aEndDot = add_end_dot(curve, size)
else:
rs.CurrentLayer(previous_layer)
return
#create annotation object
groupname = 'annotation-object_'+str(block_nr)
rs.AddGroup(groupname)
rs.AddObjectsToGroup([aCircle, aText, aCurve, aEndDot], groupname)
groups = sc.doc.ActiveDoc.Groups
for group in groups:
if group.Name == groupname:
group.SetUserString("group-nr", str(block_nr))
group.SetUserString("block-name", name)
#change back to previous layer
rs.CurrentLayer(previous_layer)
def main():
objs = rs.GetObjects("Select Objects to Send to CAD", preselect = True)
if objs is None:
return
items = [ ["Units", "Millimeters", "Meters"] ]
defaults = [False]
CADinMeters = rs.GetBoolean("Autocad DWG units", items, defaults)[0]
if CADinMeters is None:
return
coordRaw = rs.GetDocumentData("Project Info", "CAD coordinate (X,Y,Z)")
if len(coordRaw) == 0:
print "You have not specified a CAD Coordinate. Sending to 0,0,0."
coord = [0,0,0]
else:
coordTemp = coordRaw.split(',')
coord = []
for x in coordTemp:
coord.append(float(x.lstrip()))
send2CAD(objs, coord, CADinMeters)
def main():
sourceObjects = rs.GetObjects(
message="Select Objects to Move to Other Layers.",
preselect=True,
select=True)
copy = rs.GetBoolean("Do you want to copy this layer?",
("Copy", "No", "Yes"), False)
includeList = None
excludeList = [".3dm", "Make2D"]
targetLayers = sorted(getLayerList.getLayers(includeList, excludeList))
targetLayers = [(x, False) for x in targetLayers]
destinationLayer = rs.CheckListBox(targetLayers)
if not destinationLayer:
return False
rs.EnableRedraw(enable=False)
sourceObjects = list(
filter(lambda x: not rs.IsLayerReference(rs.ObjectLayer(x)),
sourceObjects))
for obj in sourceObjects:
objLayer = rs.ObjectLayer(obj)
parent, child = objLayer.split("::")[-2:]
for dLayer in destinationLayer:
if dLayer[1] == True:
fullDLayer = dLayer[0] + "::" + child
if not rs.IsLayer(fullDLayer):
print(dLayer[0] + "::" + child, objLayer)
fullDLayer = duplicateLayer(child, objLayer, dLayer[0])
if copy[0] == True:
copyObj = rs.CopyObject(obj, translation=None)
rs.ObjectLayer(copyObj, layer=fullDLayer)
else:
rs.ObjectLayer(obj, layer=fullDLayer)
rs.EnableRedraw(enable=True)
def LayerObjectRandomizer():
prefix = "RandomLayer"
separator = "_"
objs = rs.GetObjects("Select objects", preselect=True)
if not objs: return
intObjLen = len(objs)
leadZero = len(str(abs(intObjLen)))
layer_count = rs.GetInteger("Number of layers to create?",
minimum=1,
maximum=intObjLen)
if not layer_count: return
layer_state = rs.GetBoolean("Group the new layers?",
("ParentLayer", "Off", "On"), True)
if layer_state is None: return
if layer_state[0]:
parentLayer = "Random Layer Parent"
rs.AddLayer(parentLayer)
else:
parentLayer = ""
rs.EnableRedraw(False)
layer_set = []
for i in range(layer_count):
iZero = str(i + 1).zfill(leadZero)
layer = "{}{}{}".format(prefix, separator, iZero)
if not rs.IsLayer(layer):
layer_set.append(
rs.AddLayer(layer, RandomColor(), parent=parentLayer))
if layer_count == intObjLen:
for obj in objs:
popIndex = random.choice(layer_set)
rs.ObjectLayer(obj, popIndex)
layer_set.remove(popIndex)
else:
for obj in objs:
rs.ObjectLayer(obj, random.choice(layer_set))
def wallJoin(layer):
if not rs.IsLayer("Wall"):
util.initCaadLayer("Wall")
if not rs.IsLayer("Axis"):
util.initCaadLayer("Axis")
haveLayer = True
items = (layer, "Off", "On")
result = rs.GetBoolean("current layer option", items, True)
if result:
haveLayer = result[0]
oldLockMode = rs.LayerLocked("Axis", True)
while True:
go = Rhino.Input.Custom.GetObject()
go.SetCommandPrompt("Select 4 lines, each two parallel to anthor")
go.GeometryFilter = Rhino.DocObjects.ObjectType.Curve
go.GetMultiple(4, 4)
if go.CommandResult() != Rhino.Commands.Result.Success:
rs.LayerLocked("Axis", oldLockMode)
return go.CommandResult()
if go.ObjectCount != 4: return Rhino.Commands.Result.Failure
crv = []
for obj in go.Objects():
crv.append(obj.Geometry().Line)
rc, doubleLines = DoubleLine.GetIntersectedDoubleline(crv)
if rc:
doubleLine0 = doubleLines[0]
doubleLine1 = doubleLines[1]
if haveLayer:
oldLayer = rs.CurrentLayer(layer)
doubleLine0.drawIntersectionWithDoubleLine(doubleLine1)
if haveLayer:
rs.CurrentLayer(oldLayer)
rs.DeleteObjects(go.Objects())
else:
print "Error: no two doubleLines"
def MultiOffset():
try:
obj = rs.GetObjects('Select Closed Curves for Offset', preselect=True)
bool = rs.GetBoolean('Offset Direction',
('Direction', 'Inward', 'Outward'), (False))
if bool:
bool = bool[0]
offset = rs.GetReal('Distance to Offset')
for i in obj:
if rs.IsCurveClosed(i):
if bool == False:
pt = rs.CurveAreaCentroid(i)
pt = pt[0]
rs.OffsetCurve(i, pt, offset)
if bool == True:
pt = [1000000, 1000000, 1000000]
rs.OffsetCurve(i, pt, offset)
except:
print("Failed to execute")
rs.EnableRedraw(True)
return
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 ScatterBlocks():
try:
################################################################################
# GET OBJECTS AND VARIABLE #
################################################################################
obj = rs.GetObject(message="Select surface to scatter on", filter=8 | 16 |
32, preselect=False, select=False, custom_filter=None, subobjects=False)
if not obj:
return
blocks = rs.GetObjects(message="Select blocks to scatter", filter=4096, group=True, preselect=False,
select=False, objects=None, minimum_count=1, maximum_count=0, custom_filter=None)
if not blocks:
return
scatterNum = rs.GetInteger(
message="Enter scatter amount", number=100, minimum=1, maximum=10000)
if not scatterNum:
return
userScale = rs.GetReal(
"enter scale multiplyer (0 for no scaling)", number=0, minimum=None, maximum=None)
userRotation = rs.GetBoolean(
"random rotation of blocks?", ("Rotation", "No", "Yes"), (True))
if not userRotation:
return
isMesh = rs.IsMesh(obj)
ptBucket = 0
pointList = []
blockList = []
worldZVector = (rs.WorldXYPlane()).ZAxis
rs.EnableRedraw(False)
def MeshBrep(brep_id, params):
brep = rs.coercebrep(brep_id)
if brep:
mesh = Rhino.Geometry.Mesh()
mesh_parts = Rhino.Geometry.Mesh.CreateFromBrep(brep, params)
for mesh_part in mesh_parts:
mesh.Append(mesh_part)
mesh.Compact()
return mesh
def TestMeshBrep():
mesh_params = Rhino.Geometry.MeshingParameters.Coarse
mesh_brep = MeshBrep(obj, mesh_params)
if mesh_brep:
mesh = sc.doc.Objects.AddMesh(mesh_brep)
return mesh
def chunks(lst, n): # list split generator
for i in xrange(0, len(lst), n):
yield lst[i:i + n]
if isMesh == False:
mesh = TestMeshBrep()
else:
mesh = obj
# Get and format vertex points in mesh, format from point3d object to float list
meshVerts = rs.MeshFaces(mesh, face_type=False)
totalArea = rs.MeshArea(mesh)
meshFaceCount = rs.MeshFaceCount(mesh)
PT01 = meshVerts[0::3]
PT01S = []
for i in PT01:
i = (i.X, i.Y, i.Z)
PT01S.append(i)
PT02 = meshVerts[1::3]
PT02S = []
for i in PT02:
i = (i.X, i.Y, i.Z)
PT02S.append(i)
PT03 = meshVerts[2::3]
PT03S = []
for i in PT03:
i = (i.X, i.Y, i.Z)
PT03S.append(i)
# format list together in order to loop through
triangleList = zip(PT01S, PT02S, PT03S)
################################################################################
# POINT SCATTER LOOP #
################################################################################
# loop through the three vertexes forming individual triangles
for i in triangleList:
a = i[0] # triangle vert 1
b = i[1] # triangle vert 2
c = i[2] # triangle vert 3
# Find area of triangle
dist01 = rs.Distance(a, b)
dist02 = rs.Distance(a, c)
dist03 = rs.Distance(b, c)
# Herons formula to find area of triangle by sides
s = (dist01 + dist02 + dist03) / 2
tArea = math.sqrt(s*(s-dist01)*(s-dist02)*(s-dist03))
# assign portion of points base on area of triangle, if assignment of points is lower then one, add that to the next assignment
numPtsPerUnit = totalArea[1] / scatterNum
ptAllocation = tArea / numPtsPerUnit
ptBucket = ptBucket + ptAllocation
if ptBucket < 1:
continue
else:
pointShare = int(math.floor(ptBucket))
ptBucket = 0
# Vectors from origin to either corner of triangle
ac = rs.VectorCreate(c, a)
ab = rs.VectorCreate(b, a)
originVector = rs.VectorCreate(a, (0, 0, 0))
# Generate random numbers between 0,1. Random scatter onto triangle
for i in range(pointShare):
r1 = random.random()
r2 = random.random()
if r1 + r2 < 1:
p = r1 * ac + r2 * ab
else:
p = (1 - r1) * ac + (1 - r2) * ab
points = rs.AddPoint(p)
pointList.append(points)
rs.MoveObjects(points, originVector)
################################################################################
# MOVE BLOCKS TO POINTS WITH ROTATION / SCALE #
################################################################################
# shuffle point list then split list by the number of blocks to scatter. Copy blocks to split lists
random.shuffle(pointList)
ptDivision = int(len(pointList) / len(blocks))
genList = chunks(pointList, ptDivision)
blockIndex = 0
for pts in genList: # looping through split point list and blocks and copying blocks to scatter
blockPt = rs.BlockInstanceInsertPoint(blocks[blockIndex])
for pt in pts:
vector = rs.VectorCreate(pt, blockPt)
newBlock = rs.CopyObject(blocks[blockIndex], vector)
# create list of blocks for later modification
blockList.append(newBlock)
if blockIndex < (len(blocks) - 1):
blockIndex += 1
# apply random scaling and rotation to blocks
if userRotation[0] == True:
for block in blockList:
centerPt = rs.BlockInstanceInsertPoint(block)
angle = random.randint(0, 360)
rs.RotateObject(block, centerPt, angle, worldZVector)
for block in blockList:
centerPt = rs.BlockInstanceInsertPoint(block)
scale = random.uniform((userScale/4), userScale)
rs.ScaleObject(block, centerPt, (scale, scale, scale))
# If a mesh was created, delete it, general cleanup
if isMesh == False:
rs.DeleteObject(mesh)
rs.DeleteObjects(pointList)
rs.EnableRedraw(True)
except:
print("Failed to execute")
rs.EnableRedraw(True)
return
import rhinoscriptsyntax as rs
copy = rs.GetBoolean("Do you want to copy this layer?", ("Copy", "No", "Yes"), True)
print(copy)
def duplicateLayer(name, source, destination):
newLayer = rs.AddLayer(name, color=rs.LayerColor(source), parent = destination)
matchLayer(newLayer, source)
return(newLayer)
def matchLayer(name, source):
rs.LayerLinetype(name, linetype = rs.LayerLinetype(source))
rs.LayerPrintColor(name, color = rs.LayerPrintColor(source))
rs.LayerPrintWidth(name, width = rs.LayerPrintWidth(source))
sourceObjects = rs.GetObjects(message="Select Object to Move", preselect=True, select=False)
allLayers = rs.LayerNames()
topList = []
for layer in allLayers:
if rs.LayerChildCount(layer) > 0:
topList.append(layer)
destinationLayer = rs.ListBox(topList)
rs.EnableRedraw(enable=False)
for obj in sourceObjects:
objLayer = rs.ObjectLayer(obj)
parent, child = objLayer.split("::")
fullDLayer = destinationLayer + "::" + child
def main():
# create globally used array of copies
copies = []
biesse_layers = []
# promt convert for biesse
items = (
['convert_to_biesse_layers', 'no', 'yes'],
['export_clamex_txt', 'no', 'yes'],
['open_after_export', 'no', 'yes'],
)
default_values = getDefaultValues()
options = rs.GetBoolean("conversion options", items, default_values)
if not options or len(options) < 2:
print "checkAndExport aborted"
return
convert_for_biesse = options[0]
export_clamex_txt = options[1]
open_after_export = options[2]
storeDefaultValues(convert_for_biesse, export_clamex_txt,
open_after_export)
# get objects to export
objs = rs.GetObjects("select objects to export", 0, True, True)
if not objs:
print "checkAndExport aborted"
return
rs.EnableRedraw(False)
# create copies of all block contents
copies = rs.CopyObjects(objs)
# explodeblock
copies = explodeBlock(copies)
copies = explodeTextObjects(copies)
# filter objects to only curves and textobjects
copies = filterObjects(copies)
# check curves for deviation from c-plane
if checkCurvePosition(copies):
clamexdata = None
if export_clamex_txt:
clamexdata = extractClamexOrientation(copies)
# obj properties are lost here
copies = joinCurves(copies)
simplify(copies)
if checkCurveIntegrity(copies):
# rs.UnselectAllObjects()
# check curve dir
if not setCurveDir(copies):
print "checkAndExport aborted"
return
#get left bottom
rs.EnableRedraw(True)
selection_origin = rs.GetPoint("Pick export base point")
rs.EnableRedraw(False)
# move to origin
result = moveToOrigin(copies, selection_origin)
if convert_for_biesse:
biesse_layers = convertLayers(copies)
if result:
# export
rs.SelectObjects(copies)
redraw()
filename = rs.SaveFileName("Save", "dxf Files (*.dxf)|*.dxf||")
if filename:
result = rs.Command('! _-Export "' + filename + '" _Enter',
False)
if open_after_export:
if os.path.isfile(
'C:\Program Files\Rhinoceros 5 (64-bit)\System\Rhino.exe'
):
print(
'"C:\Program Files\Rhinoceros 5 (64-bit)\System\Rhino.exe" /nosplash /runscript="_-open ""'
+ filename + '"" _Enter"')
Popen(
'"C:\Program Files\Rhinoceros 5 (64-bit)\System\Rhino.exe" /nosplash /runscript="_-open ""'
+ filename + '"" _Enter"')
else:
rs.MessageBox(
'dxf cannot be openened automatically. Could not find:\nC:\Program Files\Rhinoceros 5 (64-bit)\System\Rhino.exe'
)
filename_stripped, file_extension = os.path.splitext(
filename)
if clamexdata:
with open(filename_stripped + '.txt', 'w') as the_file:
the_file.write('')
with open(filename_stripped + '.txt', 'a') as the_file:
for line in clamexdata:
str = 'CLAMEX POSX=%.3f POSY=%.3f RICHTING="%s"\n' % (
line[0], line[1], line[2])
print str
the_file.write(str)
if result: print 'exported succesfully'
rs.DeleteObjects(copies)
if biesse_layers and len(biesse_layers) > 0:
for layer in biesse_layers:
rs.PurgeLayer(layer)
rs.EnableRedraw(True)
def getLayerType(object):
""" Will get the type of hatch based on the layer structure "LAYER::A-HATCH-TYPE" """
if getParent(object) in parentLayers and rs.ObjectLayer(
object) in hatchLayers:
return (rs.ObjectLayer(object).split("-")[2])
areasTable = {}
hatchnames = set([])
layers = rs.LayerNames()
levelLayers = [x for x in layers if re.match("^L\d+|^P\d+|^M\d+", x)]
parentLayers = [x for x in levelLayers if "::" not in x]
hatchLayers = [x for x in levelLayers if "HATCH" in x]
requestType = rs.GetBoolean("Choose output data",
("Output", "Gross_Area", "Unit_Areas"), False)
requestType = requestType[0]
#Gather all the different hatch types for area analysis
for layer in levelLayers:
hlayers = [
x.split("::")[1] for x in rs.LayerChildren(layer) if "HATCH" in x
]
if len(hlayers) > 0:
sublay = ([x.split("-")[2] for x in hlayers])
hatchnames = hatchnames.union(sublay)
# sort the level keys
L1 = False
M1 = False
outputLevels = []
inputLevels = list(parentLayers)
if pick == 'pick_face':
fkey = mesh_select_face(cell)
target_area = rs.GetReal('set target area', 1, 0.1, 1000.0)
target_areas[fkey] = target_area
elif pick == 'exit':
break
artist = MeshArtist(cell)
artist.draw_facelabels(text=target_areas)
rs.EnableRedraw(True)
# arearisation options -------------------------------------------------
fix_normal = rs.GetBoolean('Fix face normals?',
items=[('fix_normals', 'no', 'yes')],
defaults=[False])
target_normals = {}
if fix_normal:
for fkey in cell.faces():
target_normals[fkey] = cell.face_normal(fkey)
# arearise -------------------------------------------------------------
initial_flatness = cell_face_flatness(cell)
conduit = MeshConduit(cell)
def callback(cell, k, args):
current_flatness = cell_face_flatness(cell)
def main():
#select a brep and 2 guide curves
filter = ObjectType.Mesh | ObjectType.Brep
result, obj = RhinoGet.GetOneObject('选择多重曲面或者网格', False, filter)
brep = obj.Brep() or obj.Mesh()
id1 = rs.GetCurveObject('第一条引导曲线')[0]
curve1 = rs.coercecurve(id1)
id2 = rs.GetCurveObject('第二条引导曲线')[0]
while id2 == id1:
id2 = rs.GetCurveObject('选择一条不同的曲线！')[0]
curve2 = rs.coercecurve(id2)
step1 = rs.GetInteger('沿第一条曲线的切割间距', number = 5)
step2 = rs.GetInteger('沿第二条曲线的切割间距', number = 5)
global solid
solid = rs.GetBoolean('是否切穿实体？',('选择','否','是'),False)[0]
offset_dist = rs.GetReal('生成条带的偏移宽度？（正值向外，负值向内,决定标注字体大小）', number = 2)
thickness = rs.GetReal('材料的厚度', number = 0.3)
#make ribs
breps1, outline1 = make_ribs(brep, curve1, step1, offset_dist, thickness)
breps2, outline2 = make_ribs(brep, curve2, step2, offset_dist, thickness)
offset_dist = abs(offset_dist)
#cutline stroage
for s in breps1:
cutlines[str(s)] = []
for s in breps2:
cutlines[str(s)] = []
#find intersect and make notch line
brep_surf = breps1 + breps2
out_lines = outline1 + outline2
intsect(brep_surf, thickness)
#arrange to xy plane
y1 = 0
y2 = 0
x_max = 0
for i, b in enumerate(brep_surf):
outline = out_lines[i]
cut = cutlines[str(b)]
for c in cut:
count = 0
for c2 in outline[:-1]:
event = Intersect.Intersection.CurveCurve(c, c2, 0.2, tol)
if event:
count += 1
if count > 1:
outline = outline[0:-1]
#0: orient to worldXY plane
surf = b.Surfaces[0]
from_pl = surf.TryGetPlane()[1]
to_pl = Plane.WorldXY
xform = Transform.PlaneToPlane(from_pl, to_pl)
group1 = Group(str(b))
group1.Add(cut)
group1.Add(outline)
group = Group('new' + str(b))
group.Add(group1.objects)
b_in_breps1 = 0
if b in breps1:
text = 'x%d'%i
b_in_breps1 = 1
else:
text = 'y%d'%(i-len(breps1))
original_box = group1.bbox(plane = from_pl)
group1.Add([TextDot(text,from_pl.Origin)])
group1.Display()
#arrange 1 : get boundingbox
group.Transform(xform)
bbox = group.bbox()
bbox.Inflate(offset_dist, offset_dist, 0)
xlen = (bbox.Max-bbox.Min).X
ylen = (bbox.Max-bbox.Min).Y
#arrange 2 : rotate according to x,y size
if ylen > xlen:
xlen, ylen = ylen, xlen
rot = Transform.Rotation(math.pi/2, Vector3d.ZAxis,bbox.Center)
group.Transform(rot)
x_max = xlen if xlen > x_max else x_max
#arrange 3 : align bbox cornor to worldXY origin
cornor_plane = Plane(bbox.Min, Vector3d.ZAxis)
align_xform = Transform.PlaneToPlane(cornor_plane, to_pl)
group.Transform(align_xform)
#arrange 4 : translate each group to proper position
center = bbox.Center
if b_in_breps1:
move = Vector3d(0,y1,0)
y1 += ylen
else:
move = Vector3d(x_max ,y2,0)
y2 += ylen
group.Transform(Transform.Translation(move))
group.label(text,offset_dist)
group.Display()
render(brep_surf)
doc.Objects.Hide(obj,True)
doc.Views.Redraw()
import rhinoscriptsyntax as rs
import Rhino
import sys
#rs.DeleteObjects(rs.AllObjects())
def check_input(input): #check if user hits cancel
if input is None:
rs.MessageBox("canceling...quitting scripts...")
sys.exit()
"""Ask for inputs"""
type = rs.GetBoolean("Select stairs type",
("type", "straight", "curvy/spiral"), True)[0]
check_input(type)
curve = rs.GetObject(
"Select a curve and make sure it's not parallel to the xy plane",
rs.filter.curve)
check_input(curve)
start_pt = rs.CurveStartPoint(curve)
end_pt = rs.CurveEndPoint(curve)
if type:
spiral = rs.GetBoolean("Select stairs type", ("type", "curvy", "spiral"),
True)[0]
if spiral:
center = rs.GetPoint("Select the center point for your spiral stairs")
stair_width = rs.GetReal(message="Enter stair width", number=5)
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 OffsetCrvLoose():
crv = rs.GetObject("select curve to offset loosely", rs.filter.curve, True)
if crv == None:
return
if not rs.IsCurvePlanar(crv):
print "Sorry, but that curve is not planar."
return
if rs.IsPolyCurve(crv):
print "This simple script works only for single open or closed curves"
return
offset = rs.GetReal("offset amount", 5)
if offset == None or offset == 0:
return
both_sides = rs.GetBoolean("Offset both sides?",
["both_sides", "off", "on"], False)[0]
bPeriodic = False
#rs.EnableRedraw(False)
pts = rs.CurvePoints(crv)
degree = rs.CurveDegree(crv)
if rs.IsCurvePeriodic(crv):
pts = rs.CullDuplicatePoints(pts, 0.01)
bPeriodic = True
offset_pts = []
offset_pts2 = [] #if both_sides=true
plane = rs.CurvePlane(crv)
axis = plane.ZAxis
for pt in pts:
cp = rs.CurveClosestPoint(crv, pt)
v = rs.CurveTangent(crv, cp)
v = rs.VectorUnitize(v)
v *= offset
v = rs.VectorRotate(v, 90, axis)
pt_ = rs.AddPoint(pt)
#create points for offset on one side of the curve
movedpt = rs.MoveObject(pt_, v)
newpt = rs.coerce3dpoint(movedpt)
offset_pts.append(newpt)
#create points for offset on other side of the curve
movedpt = rs.MoveObject(pt_, -2 * v)
newpt = rs.coerce3dpoint(movedpt)
offset_pts2.append(newpt)
rs.DeleteObject(pt_)
nc = Rhino.Geometry.NurbsCurve.Create(bPeriodic, degree, offset_pts)
nc2 = Rhino.Geometry.NurbsCurve.Create(bPeriodic, degree, offset_pts2)
if not both_sides:
if nc.GetLength(0.1) > nc2.GetLength(0.1): #get the longest curve...
if offset > 0: #...and add it to the document for positive offsets...
sc.doc.Objects.AddCurve(nc)
else: #...or the shortest for negative offsets.
sc.doc.Objects.AddCurve(nc2)
else:
if offset > 0:
sc.doc.Objects.AddCurve(nc2)
else:
sc.doc.Objects.AddCurve(nc)
else: #add both curves to the document
sc.doc.Objects.AddCurve(nc)
sc.doc.Objects.AddCurve(nc2)
rs.EnableRedraw(True)
sc.doc.Views.Redraw()
def RunCommand(is_interactive):
sc.doc.EndUndoRecord(sc.doc.CurrentUndoRecordSerialNumber)
if '3GS' not in sc.sticky:
compas_rhino.display_message('3GS has not been initialised yet.')
return
scene = sc.sticky['3GS']['scene']
if not scene:
return
# get ForceVolMeshObject from scene ----------------------------------------
objects = scene.find_by_name('force')
if not objects:
compas_rhino.display_message("There is no force diagram in the scene.")
return
force = objects[0]
# get global settings ------------------------------------------------------
kmax = scene.settings['Solvers']['arearization.kmax']
refresh = scene.settings['Solvers']['arearization.refreshrate']
tol = scene.settings['Solvers']['arearization.tol']
options = [
'Iterations', 'Refreshrate', 'Set_target_areas', 'Fix_face_normals',
'Fix_vertices', 'Tolerance'
]
# options ------------------------------------------------------------------
fix_vertices = []
target_areas = {}
target_text = {}
target_colors = {}
target_normals = {}
while True:
rs.EnableRedraw(True)
option = compas_rhino.rs.GetString(
'Press Enter to run or ESC to exit.', strings=options)
if option is None:
scene.clear_layers()
scene.clear()
scene.update()
print("Arearization aborted!")
return
if not option:
break
if option == 'Iterations':
new_kmax = compas_rhino.rs.GetInteger('Enter number of iterations',
kmax, 1, 10000)
if new_kmax or new_kmax is not None:
kmax = new_kmax
elif option == 'RefreshRate':
new_refresh = compas_rhino.rs.GetInteger(
'Refresh rate for dynamic visualisation', refresh, 0, 1000)
if new_refresh or new_refresh is not None:
refresh = new_refresh
elif option == 'Set_target_areas':
while True:
areas = {
face: round(force.diagram.face_area(face), 2)
for face in force.diagram.faces()
if face not in target_areas
}
force.artist.draw_facelabels(text=areas)
rs.EnableRedraw(True)
faces = force.select_faces()
if not faces or faces is None:
break
target_area = rs.GetReal("Enter target area value",
minimum=0.1,
maximum=10000.0)
if target_area:
for face in faces:
current_area = force.diagram.face_area(face)
if current_area > target_area:
color = (255, 0, 0)
text = str(round(current_area,
2)) + ' ---> ' + str(
round(target_area, 2))
else:
color = (0, 0, 255)
text = str(round(current_area,
2)) + ' ---> ' + str(
round(target_area, 2))
target_areas[face] = target_area
target_text[face] = text
target_colors[face] = color
scene.clear_layers()
scene.clear()
scene.update()
force.artist.draw_facelabels(text=target_text,
color=target_colors)
elif option == 'Fix_face_normals':
target_normals = {}
items = ("Boundary_faces", "No", "Yes"), ("Interior_Faces", "No",
"Yes")
boundary, interior = rs.GetBoolean("Fix normals of...", items,
(False, False))
if boundary:
target_normals.update({
face: force.diagram.face_normal(face)
for face in force.diagram.halffaces_on_boundaries()
})
if interior:
for face in force.diagram.faces():
if not force.diagram.is_halfface_on_boundary(face):
target_normals[face] = force.diagram.face_normal(face)
elif option == 'Fix_vertices':
fix_vertices += force.select_vertices()
elif option == 'Tolerance':
new_tol = compas_rhino.rs.GetReal('Enter areaness tolerance', tol,
0.001, 1.0)
if new_tol or new_tol is not None:
tol = new_tol
if refresh > kmax:
refresh = 0
scene.settings['Solvers']['planarization.kmax'] = kmax
scene.settings['Solvers']['planarization.refreshrate'] = refresh
scene.settings['Solvers']['arearization.tol'] = tol
# --------------------------------------------------------------------------
# planarization
# --------------------------------------------------------------------------
if refresh > 0:
initial_flatness = volmesh_face_areaness(force.diagram, target_areas)
conduit = VolmeshConduit(force.diagram)
def callback(forcediagram, k, args, refreshrate=refresh):
if k % refreshrate:
return
current_flatness = volmesh_face_areaness(force.diagram,
target_areas)
face_colordict = compare_initial_current(current_flatness,
initial_flatness,
color_scheme=i_to_red)
conduit.face_colordict = face_colordict
conduit.redraw()
# planarise
with conduit.enabled():
volmesh_planarise(
force.diagram,
kmax=kmax,
target_areas=target_areas,
target_normals=target_normals,
fix_vkeys=fix_vertices,
fix_boundary_normals=False,
tolerance_flat=scene.settings['Solvers']['planarization.tol'],
tolerance_area=tol,
callback=callback,
print_result_info=True)
# check if there is form diagram -------------------------------------------
objects = scene.find_by_name('form')
if not objects:
force.check_eq()
scene.update()
return
form = objects[0]
# update -------------------------------------------------------------------
form.diagram.update_angle_deviations()
form.check_eq()
force.check_eq()
scene.update()
scene.save()
def importTEN_CAD():
savePath0 = rs.OpenFileName("Open", "Autocad (*.dwg)|*.dwg||")
items = [["Units", "Meters", "Millimeters"]]
defaults = [False]
CADinMilli = rs.GetBoolean("Is that CAD file in meters or mm?", items,
defaults)[0]
explodeBlockBoo = True
if savePath0 is None:
return
rs.EnableRedraw(False)
#setup the layers
rs.AddLayer("7_REF")
rs.AddLayer("CAD", parent="7_REF")
fileNameExt = savePath0.split('\\')[-1]
fileName = fileNameExt.split('.')[0]
savePath1 = '"' + savePath0 + '"'
#create layer name
now = datetime.date.today()
dateList = []
if len(str(now.month)) > 1:
month = str(now.month)
else:
month = "0" + str(now.month)
if len(str(now.day)) > 1:
day = str(now.day)
else:
day = "0" + str(now.day)
time = str(now.year) + month + day
layerName = time + "_" + fileName + "_01"
children = rs.LayerChildren("7_REF::CAD")
finalNums = []
for child in children:
num = rs.LayerName(child, fullpath=False).split("_")[-1]
try:
finalNums.append(int(num))
except:
finalNums.append(0)
finalNums.sort()
if rs.IsLayer("7_REF::CAD::" + layerName):
num = int(finalNums[-1]) + 1
if len(str(num)) < 2:
finalNum = "0" + str(num)
else:
finalNum = str(num)
layerName = time + "_" + fileName + "_" + finalNum
par = rs.AddLayer("7_REF")
cat = rs.AddLayer("CAD", parent=par)
element = rs.AddLayer(layerName, parent=cat)
rs.CurrentLayer(element)
#get intial list of all layers in the file
currentLayers = rs.LayerNames()
rs.Command('_-Import ' + savePath1 + ' _Enter')
#get new layers added
endLayersNames = rs.LayerNames()
#newLayers = [item for item in currentLayers if item not in endLayersNames]
newLayers = diff(endLayersNames, currentLayers)
print newLayers
for layer in newLayers:
rs.ParentLayer(layer, element)
objects = rs.ObjectsByLayer(layer)
if rs.IsLayerEmpty(layer):
rs.DeleteLayer(layer)
else:
for obj in objects:
if rs.IsDimension(obj):
rs.DeleteObject(obj)
elif rs.IsHatch(obj):
rs.DeleteObject(obj)
#Get all the imported geometry
allObjects = []
finalLayers = rs.LayerChildren(rs.CurrentLayer())
for finalLayer in finalLayers:
allObjects.append(rs.ObjectsByLayer(finalLayer))
finalAllObjects = [item for sublist in allObjects for item in sublist]
#Format Coordinate
try:
rawCoordinate = rs.GetDocumentData("Project Info",
"CAD coordinate (X,Y,Z)")
except:
print "No CAD Coordinate specified in the Project Info"
rawCoordinate = (0, 0, 0)
coordinate = rawCoordinate.split(",")
print "Aa"
try:
for i in range(0, 3):
coordinate[i] = float(coordinate[i])
except:
coordinate = None
if coordinate is None:
print "CAD coordinate has an error"
else: #move all objects
negVec = rs.VectorReverse(coordinate)
rs.MoveObjects(finalAllObjects, negVec)
if CADinMilli:
rs.ScaleObjects(finalAllObjects, [0, 0, 0], [.001, .001, .001])
importGroup = rs.AddGroup(str(layerName))
rs.AddObjectsToGroup(finalAllObjects, importGroup)
rs.ZoomSelected()
print "Import EXECUTED"
rs.EnableRedraw(True)
return None
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
# first point
pt_sum = rs.PointCoordinates(rs.CreatePoint(ids[0]))
# sum rest of points
for i in xrange(1, len(ids)):
pt_sum += rs.PointCoordinates(ids[i])
# divide with amount of points to get average
pt_sum = pt_sum / len(ids)
return pt_sum
widgets = rs.GetObjects()
rotate = rs.GetBoolean("Rotate items?", ("Rotate", "No", "Yes"), (True))
bounds = rs.BoundingBox(widgets)
print(bounds)
x_dist = rs.Distance(bounds[0], bounds[1])
y_dist = rs.Distance(bounds[1], bounds[2])
z_dist = rs.Distance(bounds[3], bounds[4])
for ind, w in enumerate(widgets):
# print(rotate)
# if rotate:
# print("ROTATE")
# centerPt = FindCentroidOfPoints(bounds)
# print(centerPt)
# rs.RotateObject(w, centerPt, random.uniform(0,360))
#
x = random.uniform(0, x_dist)
y = random.uniform(0, y_dist)
