def deleteExistingPlans():
if rs.IsLayer("60_PLANS"):
#delete all sublayers
levelLayers = rs.LayerChildren("60_PLANS")
for levelLayer in levelLayers:
childLayers = rs.LayerChildren(levelLayer)
for childLayer in childLayers:
objects = rs.ObjectsByLayer(childLayer)
rs.DeleteObjects(objects)
rs.DeleteLayer(childLayer)
rs.DeleteLayer(levelLayer)
else:
return
def makePlan():
"""
make2d from above.
input: list of layers to make2d
returns: None
"""
objs = rs.ObjectsByGroup("Below")
#Make2d
rs.SelectObjects(objs)
rs.Command("-_make2d _D _U _Enter")
projLines = rs.GetObjects("", preselect = True)
#Get make2d root layer
make2dRootRaw = rs.ObjectLayer(projLines[0])
make2dRoot = make2dRootRaw.split("::")[0]
#Rename make2d layers
root = rs.AddLayer("60_PLANS")
roofLay = rs.AddLayer("Roof", parent = root)
for projLine in projLines:
linesLayer = rs.ObjectLayer(projLine)
linesColor = rs.ObjectColor(projLine)
linesLayerName = rs.LayerName(linesLayer, fullpath = False)
newLayers = rs.AddLayer(linesLayerName, parent = roofLay, color = linesColor)
rs.ObjectLayer(projLine,newLayers)
rs.ObjectColor(projLine, (200,200,200))
#Delete make2d Layers
rs.DeleteLayer(make2dRoot)
return
def select_quad_mesh_polyedge(mesh):
"""Select quad mesh polyedge. Selecting one edge is equivalent to selecting one polyedge.
Parameters
----------
mesh : QuadMesh
The quad mesh.
Returns
-------
list
The list of polyedge vertices.
"""
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
artist.draw_edgelabels()
artist.redraw()
edge = rhino_helper.mesh_select_edge(mesh)
artist.clear_layer()
artist.redraw()
rs.DeleteLayer('mesh_artist')
return mesh.polyedge(*edge)
def add_handle_artist(mesh):
"""Select two mesh faces and add handle.
Parameters
----------
mesh : Mesh
The mesh.
Returns
-------
fkeys
The new face keys from the handle.
"""
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
artist.draw_facelabels()
artist.redraw()
fkey_1 = rhino_helper.mesh_select_face(mesh, message='fkey_1')
if fkey_1 is not None:
fkey_2 = rhino_helper.mesh_select_face(mesh, message='fkey_2')
if fkey_2 is not None:
fkeys = add_handle(mesh, fkey_1, fkey_2)
else:
fkeys = []
else:
fkeys = []
artist.clear()
rs.DeleteLayer('mesh_artist')
return fkeys
def Export():
count = 0
folder = ChooseFolderPath()
layer_names = rs.LayerNames()
newDefaultLayer = 'NewDefault'
rs.AddLayer(newDefaultLayer)
rs.CurrentLayer(newDefaultLayer)
for l in layer_names:
if l != newDefaultLayer:
for t in layer_names:
if rs.IsLayer(l):
if l != newDefaultLayer:
rs.LayerVisible(t, False)
else:
print "The layer does not exist."
rs.LayerVisible(l, True)
if rs.CurrentLayer() == l:
break
"""answer = rs.MessageBox("Continue?", 1 | 32)
if answer is 2: break
rs.Sleep(1000)"""
Render(folder, count)
count += 1
rs.LayerVisible(l, False)
for l in layer_names:
if l != newDefaultLayer:
rs.LayerVisible(l, False)
rs.CurrentLayer(l)
rs.DeleteLayer(newDefaultLayer)
def select_mesh_polyedge(mesh):
"""Select mesh polyedge.
Parameters
----------
mesh : Mesh
The mesh.
Returns
-------
polyedge : list
The list of polyedge vertices.
"""
# add layer
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
# collect polyedge vertices
polyedge = []
lines = []
while True:
# define candidate vertices for polyedge
if len(polyedge) == 0:
vkey_candidates = mesh.vertices()
else:
vkey_candidates = mesh.vertex_neighbors(polyedge[-1])
# get vertex among candidates
artist.draw_vertexlabels(
text={key: str(key)
for key in vkey_candidates})
artist.redraw()
vkey = rhino_helper.mesh_select_vertex(mesh, message='vertex')
artist.clear_layer()
artist.redraw()
# stop if no vertex is added
if vkey is None:
break
# add vertex to polyedge
polyedge.append(vkey)
if len(polyedge) > 1:
u = mesh.vertex_coordinates(polyedge[-2])
v = mesh.vertex_coordinates(polyedge[-1])
guid = rs.AddLine(u, v)
rs.ObjectColor(guid, [255, 255, 0])
lines.append(guid)
rs.DeleteLayer('mesh_artist')
rs.DeleteObjects(lines)
return polyedge
def editing_geometry_moving(coarse_pseudo_quad_mesh):
"""Edit the geometry of a pattern with moving.
Parameters
----------
coarse_pseudo_quad_mesh : CoarsePseudoQuadMesh
The pattern to edit.
"""
mesh_to_modify = rs.GetString('mesh to modify?',
strings=[
'coarse_pseudo_quad_mesh',
'pseudo_quad_mesh', 'polygonal_mesh'
])
if mesh_to_modify == 'coarse_pseudo_quad_mesh':
mesh = coarse_pseudo_quad_mesh
elif mesh_to_modify == 'pseudo_quad_mesh':
mesh = coarse_pseudo_quad_mesh.get_quad_mesh()
elif mesh_to_modify == 'polygonal_mesh':
mesh = coarse_pseudo_quad_mesh.get_polygonal_mesh()
else:
return 0
while True:
rs.EnableRedraw(False)
artist = rhino_artist.MeshArtist(mesh)
guid = artist.draw_mesh()
rs.EnableRedraw(True)
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
artist.draw_vertexlabels(
text={key: str(key)
for key in mesh.vertices()})
artist.redraw()
vkeys = rhino_helper.mesh_select_vertices(mesh,
message='vertices to move')
artist.clear_layer()
artist.redraw()
rs.DeleteLayer('mesh_artist')
if vkeys == []:
rs.DeleteObject(guid)
break
rhino_helper.mesh_move_vertices(mesh, vkeys)
rs.DeleteObject(guid)
if mesh_to_modify == 'coarse_pseudo_quad_mesh':
coarse_pseudo_quad_mesh = mesh
elif mesh_to_modify == 'pseudo_quad_mesh':
coarse_pseudo_quad_mesh.set_quad_mesh(mesh)
coarse_pseudo_quad_mesh.set_polygonal_mesh(mesh.copy())
elif mesh_to_modify == 'polygonal_mesh':
coarse_pseudo_quad_mesh.set_polygonal_mesh(mesh)
def select_mesh_polyedge(mesh):
"""Select polyedge vertices via artist.
Parameters
----------
mesh : Mesh
The mesh.
Returns
-------
polyedge : list
The list of polyedge vertices.
"""
# add layer
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
# collect polyedge vertices
polyedge = []
count = mesh.number_of_vertices() + 1
while count > 0:
count -= 1
# define candidate vertices ofr polyedge
if len(polyedge) == 0:
vkey_candidates = mesh.vertices()
else:
vkey_candidates = mesh.vertex_neighbors(polyedge[-1])
# get vertex among candidates
artist.draw_vertexlabels(text={
key: str(key)
for key in vkey_candidates if key not in polyedge[1:]
})
artist.redraw()
vkey = rhino_helper.mesh_select_vertex(mesh, message='vertex')
artist.clear_layer()
artist.redraw()
# stop if no vertex is added
if vkey is None:
break
# add vertex to polyedge
polyedge.append(vkey)
# stop if polyedge is closed
if len(polyedge) != 1 and vkey == polyedge[0]:
break
rs.DeleteLayer('mesh_artist')
return polyedge
def _clear_layers(cls): ## clear only user layers
"""Deletes all layers. Leaves Default layer
"""
default_layer_name = s.Settings.default_layer_name
layer_names = rs.LayerNames()
if not default_layer_name in layer_names:
rs.AddLayer(default_layer_name)
rs.CurrentLayer(default_layer_name)
for layer_name in layer_names:
if not layer_name == default_layer_name:
value = rs.DeleteLayer(layer_name)
print('Cleared layer %s: %s' % (layer_name, value))
def RemoveMasterRootLayer(masterRoot):
rs.EnableRedraw(False)
subRoots = []
allLayers = rs.LayerNames()
for each in allLayers:
if rs.ParentLayer(each) == masterRoot:
subRoots.append(each)
for eachLayer in subRoots:
rs.ParentLayer(eachLayer, '')
rs.DeleteLayer(masterRoot)
rs.EnableRedraw(True)
def mergeLayers(layA, layB):
"""
layA is kept, layB is deleted
input: (layA, layB) each is a layer, the top parent in a tree to merge with another.
returns: None
"""
rs.EnableRedraw(False)
Alayers = rs.LayerChildren(layA)
Blayers = rs.LayerChildren(layB)
AlayersShort = []
BlayersShort = []
for Alayer in Alayers:
AlayersShort.append(rs.LayerName(Alayer, False))
for Blayer in Blayers:
BlayersShort.append(rs.LayerName(Blayer, False))
uniqueLayers = list(set(BlayersShort) - set(AlayersShort))
#move unique layers
for uniqueLayer in uniqueLayers:
rs.ParentLayer(uniqueLayer, layA)
#get duplicate name layers
duppedLayers = list(set(BlayersShort) - set(uniqueLayers))
#move objects to layA twin
for duppedLayer in duppedLayers:
newParent = layA + "::" + duppedLayer
duppedObjs = rs.ObjectsByLayer(layB + "::" + duppedLayer)
for duppedObj in duppedObjs:
rs.ObjectLayer(duppedObj, newParent)
#if it has children, recursively move them
if rs.LayerChildCount(layB + "::" + duppedLayer) > 0:
mergeLayers(layA + "::" + duppedLayer, layB + "::" + duppedLayer)
else:
rs.DeleteLayer(layB + "::" + duppedLayer)
rs.DeleteLayer(layB)
rs.EnableRedraw(True)
return None
def new(units="Meter"):
# create new file
successNew = rs.Command("-_New None")
# change units
successProp = rs.Command("-_DocumentProperties Units UnitSystem " + units +
" No Enter Enter")
# delete all but one layer
layerCt = rs.LayerCount()
for i in range(layerCt - 1):
layer = rs.CurrentLayer()
rs.DeleteLayer(layer)
return successNew and successProp
def delete_layers(layers):
"""Delete layers and all contained objects.
Parameters
----------
layers : dict
A dictionary of layers with the keys representing layer names,
and the values also dictionaries defining optional nested layers.
Examples
--------
.. code-block:: python
layers = {'COMPAS': {'layers': {'Datastructures': {'layers': {'Mesh': {}, 'Network': {}}}}}}
create_layers(layers)
delete_layers(['COMPAS::Datastructures::Network'])
delete_layers({'COMPAS': {'layers': {'Datastructures': {'layers': {'Mesh': {}}}}}})
"""
to_delete = []
def recurse(layers, parent=None):
for name in layers:
if not name:
continue
fullname = name
if parent:
fullname = parent + '::' + name
try:
attr = layers[name]
except TypeError:
attr = {}
if 'layers' in attr:
recurse(attr['layers'], fullname)
to_delete.append(fullname)
rs.EnableRedraw(False)
recurse(layers)
for layer in to_delete:
if rs.IsLayer(layer):
rs.DeleteLayer(layer)
rs.EnableRedraw(True)
def ConfirmLayer():
print("■start confirmlayer■")
sc.doc = Rhino.RhinoDoc.ActiveDoc
layers = rs.LayerNames()
if "Make2D" in layers:
dellayer = rs.MessageBox("既に存在する'Make2D'レイヤーは削除されます 問題ないですか？", 4, "レイヤーの確認")
if dellayer == int(6):# Massageboxのはいは6で返却される
rs.DeleteLayer("Make2D")# 作図中にMake2Dレイヤーが作成されるため、前もって削除
layer = True
print("deleted layer")
else:
rs.MessageBox("作図をキャンセルしました")
layer = False
print("canceled writing")
else:
layer = True
print("no make2d layer")
sc.doc = ghdoc
print("■end confirmfolder■")
return layer# "Make2D"レイヤーが存在しないor削除するときはTrueを返却
def ExportAsSKP(objs, newFolder, newFolderName):
tempLayers = []
copiedObjs = []
rs.StatusBarProgressMeterShow('Exporting to SKP', 0, len(objs))
for i, obj in enumerate(objs):
tempCopy = rs.CopyObject(obj)
rs.ObjectLayer(tempCopy, rs.ObjectLayer(obj))
copiedObjs.append(tempCopy)
rs.StatusBarProgressMeterUpdate(i)
for obj in copiedObjs:
shortName = rs.LayerName(rs.ObjectLayer(obj), False)
layerName = newFolderName + '_' + shortName
if rs.IsLayer(layerName):
rs.ObjectLayer(obj, layerName)
else:
matIndex = rs.LayerMaterialIndex(rs.ObjectLayer(obj))
newLayer = rs.AddLayer(layerName, rs.LayerColor(rs.ObjectLayer(obj)))
rs.LayerMaterialIndex(newLayer, matIndex)
tempLayers.append(newLayer)
rs.ObjectLayer(obj, newLayer)
rs.StatusBarProgressMeterHide()
try:
filepath = os.path.join(newFolder,newFolderName + '.skp')
rs.SelectObjects(copiedObjs)
rs.Command('-_Export ' + '"' + filepath + '"' + ' s SketchUp2015 Enter ', False)
#CLEANUP
rs.UnselectAllObjects()
try:
rs.DeleteObjects(copiedObjs)
except:
rs.DeleteObject(copiedObjs)
for layer in tempLayers:
rs.DeleteLayer(layer)
except:
print "export failed"
def makeRoofPlan(layers):
"""
make2d from above.
input: list of layers to make2d
returns: None
"""
rs.EnableRedraw(False)
#Get the objects
objsRaw = []
for layer in layers:
objsRaw.append(rs.ObjectsByLayer(layer))
objs = [item for sublist in objsRaw for item in sublist]
#Make2d
rs.SelectObjects(objs)
rs.Command("-_make2d _D _U _Enter")
projLines = rs.GetObjects("", preselect=True)
#Get make2d root layer
make2dRootRaw = rs.ObjectLayer(projLines[0])
make2dRoot = make2dRootRaw.split("::")[0]
#Rename make2d layers
root = rs.AddLayer("60_PLANS")
roofLay = rs.AddLayer("Roof", parent=root)
for projLine in projLines:
linesLayer = rs.ObjectLayer(projLine)
linesColor = rs.ObjectColor(projLine)
linesLayerName = rs.LayerName(linesLayer, fullpath=False)
newLayers = rs.AddLayer(linesLayerName,
parent=roofLay,
color=linesColor)
rs.ObjectLayer(projLine, newLayers)
#Delete make2d Layers
rs.DeleteLayer(make2dRoot)
rs.EnableRedraw(True)
return
def delete_layers(layers):
to_delete = []
def recurse(layers, parent=None):
for name in layers:
if not name:
continue
fullname = name
if parent:
fullname = parent + '::' + name
try:
attr = layers[name]
except TypeError:
attr = {}
if 'layers' in attr:
recurse(attr['layers'], fullname)
to_delete.append(fullname)
rs.EnableRedraw(False)
recurse(layers)
for layer in to_delete:
if rs.IsLayer(layer):
rs.DeleteLayer(layer)
rs.EnableRedraw(True)
def editing(mesh):
"""Edit a mesh.
Parameters
----------
planar_mesh : Mesh
A planar mesh to remap on the surface.
spatial_surface : Rhino surface guid
A spatial Rhino surface on which to remap the mesh.
Returns
-------
mesh: Mesh
The remapped mesh.
Raises
------
-
"""
# temporary layer for visualisation
rs.AddLayer('temp')
# grammar rules
rules_subdivide = [
'simple_split', 'double_split', 'flat_corner_2', 'flat_corner_3',
'flat_corner_33', 'split_35', 'split_35_diag', 'split_26'
]
rules_poles = [
'face_pole', 'edge_pole', 'vertex_pole', 'insert_pole',
'insert_partial_pole'
]
rules_strips = ['face_strip_collapse', 'face_strip_insert']
rules_genus = [
'add_opening', 'close_opening', 'add_handle', 'close_handle',
'close_handle_2'
]
rules_others = [
'singular_boundary_1', 'singular_boundary_2',
'singular_boundary_minus_1', 'rotate_vertex'
]
rules_geometry = ['move_vertices', 'project_on_surface']
rule_cluster = [
'subdivide', 'poles', 'strips', 'genus', 'others', 'geometry',
'propagate'
]
clusters = {
'subdivide': rules_subdivide,
'poles': rules_poles,
'strips': rules_strips,
'genus': rules_genus,
'others': rules_others,
'geometry': rules_geometry
}
# regular vertices of initial mesh
regular_vertices = list(mesh.vertices())
# first visualisation
rs.EnableRedraw(False)
copy_mesh = mesh.to_mesh()
edges = [
rs.AddLine(copy_mesh.vertex_coordinates(u),
copy_mesh.vertex_coordinates(v))
for u, v in copy_mesh.edges() if u != v and
geometric_key([float(xyz)
for xyz in copy_mesh.vertex_coordinates(u)]) !=
geometric_key([float(xyz) for xyz in copy_mesh.vertex_coordinates(v)])
]
rs.ObjectLayer(edges, 'temp')
rs.EnableRedraw(True)
# start editing
count = 1000
while count > 0:
count -= 1
#ask for rule
cluster = rs.GetString('rule cluster?', strings=rule_cluster)
rs.EnableRedraw(False)
# intermediary propagation
if cluster == 'propagate':
mesh_propagation(mesh, regular_vertices)
for vkey in mesh.vertices():
# update regualr vertices
regular = True
for fkey in mesh.vertex_faces(vkey):
if len(mesh.face_vertices(fkey)) > 4:
regular = False
break
if regular and vkey not in regular_vertices:
regular_vertices.append(vkey)
# apply editing rule
elif cluster in rule_cluster:
if cluster in clusters.keys():
rule = rs.GetString('rule?', strings=clusters[cluster])
apply_rule(mesh, rule)
# if nothing, check if mesh is valid after a final propagation
else:
# propapgate
mesh_propagation(mesh, regular_vertices)
rs.DeleteObjects(edges)
rs.DeleteLayer('temp')
break
# update regular vertices
for vkey in mesh.vertices():
regular = True
for fkey in mesh.vertex_faces(vkey):
if len(mesh.face_vertices(fkey)) != 4:
regular = False
break
if regular and vkey not in regular_vertices:
regular_vertices.append(vkey)
# update edges
rs.EnableRedraw(False)
rs.DeleteObjects(edges)
copy_mesh = mesh.to_mesh()
edges = [
rs.AddLine(copy_mesh.vertex_coordinates(u),
copy_mesh.vertex_coordinates(v))
for u, v in copy_mesh.edges() if u != v and geometric_key(
[float(xyz)
for xyz in copy_mesh.vertex_coordinates(u)]) != geometric_key(
[float(xyz) for xyz in copy_mesh.vertex_coordinates(v)])
]
rs.ObjectLayer(edges, 'temp')
rs.EnableRedraw(True)
return mesh
)
#
# add sublayer for the new toolpath
#
nrOfPaths = rs.LayerChildCount("Toolpaths")
pathLayerName = "path%03d" % nrOfPaths
rs.AddLayer(name="Toolpaths::" + pathLayerName, color=[255, 0, 0])
rs.CurrentLayer(pathLayerName)
#
# generate the toolpath
#
rc = prepareToolpaths(pathLayerName, objects, mode, totalDepth, passDepth,
toolDiameter)
#
# remove toolpath layer if the operation failed
#
if rc == False:
print "Removing layer"
rs.CurrentLayer("Toolpaths")
rs.DeleteLayer("Toolpaths::" + pathLayerName)
#
# enable Layer change event listener
#
func = layerChangeEvent
scriptcontext.sticky["MyLayerChangeEvent"] = func
Rhino.RhinoDoc.LayerTableEvent += func
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
# Origin https://discourse.mcneel.com/t/the-best-way-to-identify-layers-without-objects-to-delete/7690/4
import rhinoscriptsyntax as rs
layers = rs.LayerNames()
for layer in layers:
if rs.IsLayerEmpty(layer): rs.DeleteLayer(layer)
def lb_generate_analysis(self):
try:
if self.m_test_points == None:
print "missing grid objects"
return
#prepare paramters
window_groups = [] #not included yet in eto interface
name = 'default_name'#not included yet in eto interface
sun_path_panel = list(self.Parents)[-1].get_sun_path_panel()
sun_vectors = sun_path_panel.m_vectors
hoys = sun_path_panel.m_hoys
timestep = sun_path_panel.m_timestep
#hb objects data
hb_object_ids = self.m_hb_object_ids
hb_object_types, hb_object_mats = self.lb_get_hb_objects_data()
#project data
folder = self.m_project_path_picker.FilePath
filename = self.m_project_name_text_box.Text
save_file_only = self.m_save_file_check_box.Checked
#turn off last results layers
if 'Eto_DisplayLayerIndex' in sc.sticky and sc.sticky['Eto_DisplayLayerIndex']:
last_layer_index = sc.sticky['Eto_DisplayLayerIndex']
last_layer = Rhino.RhinoDoc.ActiveDoc.Layers.FindIndex(last_layer_index)
last_layer_name = rs.LayerName(last_layer.Id, True)
last_parentLayer = rs.LayerName(last_layer.ParentLayerId, True)
rs.LayerVisible(last_parentLayer, False)
results_layer = None
# generate one analysis merging points/vector and meshes
points_item = []
vectors_item = []
for index in range(len(self.m_test_points)):
points_item += self.m_test_points[index]
vectors_item += self.m_pts_vectors[index]
mesh_item = self.m_output_mesh.pop(0)
if len(self.m_output_mesh):
mesh_item.Append(self.m_output_mesh)
rs.EnableRedraw(False)
LadybugEto.generateAnalysis(points_item,
vectors_item,
name,
window_groups,
sun_vectors,
hoys,
timestep,
hb_object_ids,
hb_object_types,
hb_object_mats,
folder,
filename,
save_file_only,
[mesh_item])
#consolidate multiple result objects into one layer (workaround to
#solve current ladybug_ResultVisualization.bakeObjects behaviour)
layer_index = sc.sticky['Eto_DisplayLayerIndex']
last_layer = Rhino.RhinoDoc.ActiveDoc.Layers.FindIndex(layer_index)
last_layer_name = rs.LayerName(last_layer.Id, True)
p_layer_name = rs.LayerName(last_layer.ParentLayerId, True)
#use first analysis layers
if index == 0:
results_layer_index = layer_index
results_layer = last_layer_name
results_p_layer = p_layer_name
#delte all subsequent analysis layers
elif last_layer_name <> results_layer:
#Move all objects to analysis layer and delete layers
objects_id = rs.ObjectsByLayer(last_layer_name)
res = list(rs.ObjectLayer(obj_id, results_layer) for obj_id in objects_id)
rs.DeleteLayer(last_layer_name)
rs.DeleteLayer(p_layer_name)
rs.EnableRedraw(True)
#replace the sticky to results layer used
sc.sticky['Eto_DisplayLayerIndex'] = results_layer_index
#copy original analysis surfaces hb objects to analisys layer created
rs.EnableRedraw(False)
#copy analysis grid
new_layer_name = rs.AddLayer(results_p_layer+"::Analysis_grid_objects", color=Color.Red)
gridsurfs_ids = list(item.Tag for item in self.m_gridsurfs_list_box.Items)
new_grid_objects = rs.CopyObjects(gridsurfs_ids)
res = list(rs.ObjectLayer(obj_id, new_layer_name) for obj_id in new_grid_objects)
#copy hb objects
new_layer_name = rs.AddLayer(results_p_layer+"::HB_objects", color=Color.LightGreen)
new_grid_objects = rs.CopyObjects(self.m_hb_object_ids)
res = list(rs.ObjectLayer(obj_id, new_layer_name) for obj_id in new_grid_objects)
rs.EnableRedraw(True)
except Exception as e:
print e
def customed_constraints(mesh, constraints, surface_boundaries, surface_constraint):
count = 1000
while count > 0:
count -= 1
all_curve_constraints = []
for vkey, constraint in constraints.items():
constraint_type, constraint_object = constraint
if constraint_type == 'curve' and constraint_object not in all_curve_constraints:
all_curve_constraints.append(constraint_object)
n = len(all_curve_constraints)
rs.EnableRedraw(False)
dots = []
for i, crv in enumerate(all_curve_constraints):
dot = rs.AddTextDot(i, rs.CurveMidPoint(crv))
dots.append(dot)
rs.ObjectColor(dot, [0, float(i) / n * 255, (n - float(i)) / n * 255])
rs.EnableRedraw(True)
# display vertices to select with colour code
vertex_colors = {}
for vkey, constraint in constraints.items():
contraint_type, constraint_object = constraint
if contraint_type == 'point':
rgb = [255, 0, 255]
elif contraint_type == 'curve':
i = all_curve_constraints.index(constraint_object)
rgb = [0, float(i) / n * 255, (n - float(i)) / n * 255]
elif contraint_type == 'surface':
rgb = [255, 255, 255]
else:
rgb = [0, 0, 0]
vertex_colors[vkey] = rgb
artist = rhino.artists.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
artist.draw_vertices(color = vertex_colors)
artist.redraw()
vkeys = rhino.helpers.mesh_select_vertices(mesh, message = 'change vertex constraints?')
artist.clear_layer()
artist.redraw()
rs.DeleteLayer('mesh_artist')
if vkeys == []:
rs.DeleteObjects(dots)
return constraints
rs.EnableRedraw(True)
constraint_types = ['point', 'curve', 'surface', 'none', 'move']
new_constraint_type = rs.GetString('constraint type?', strings = constraint_types)
# set new point constraint
if new_constraint_type == 'point':
for vkey in vkeys:
constraints[vkey] = ['point', mesh.vertex_coordinates(vkey)]
# set new curve constraint
elif new_constraint_type == 'curve':
curve_constraint = rs.GetObject('curve constraint?', filter = 4)
for vkey in vkeys:
constraints[vkey] = ['curve', curve_constraint]
# set new surface constraint
elif new_constraint_type == 'surface':
for vkey in vkeys:
constraints[vkey] = ['surface', surface_constraint]
# remove constraint
elif new_constraint_type == 'none':
for vkey in vkeys:
constraints[vkey] = ['none', None]
# move nodes
elif new_constraint_type == 'move':
x0, y0, z0 = rs.GetPoint('from...')
x1, y1, z1 = rs.GetPoint('...to')
for vkey in vkeys:
attr = mesh.vertex[vkey]
attr['x'] += x1 - x0
attr['y'] += y1 - y0
attr['z'] += z1 - z0
# udpdate drawn mesh
layer = 'pattern_topology'
mesh_guid = rs.ObjectsByLayer(layer)[0]
rs.DeleteObject(mesh_guid)
mesh_guid = draw_mesh(mesh)
rs.ObjectLayer(mesh_guid, layer)
rs.EnableRedraw(True)
rs.EnableRedraw(False)
rs.DeleteObjects(dots)
rs.EnableRedraw(False)
return constraints
def Main():
if not LANG: return
if not rs.IsLayer(OFFSET_LAYER):
rs.AddLayer(OFFSET_LAYER)
else:
rs.DeleteObjects(rs.ObjectsByLayer(OFFSET_LAYER))
if not rs.IsLayer(TRASH_LAYER):
rs.AddLayer(TRASH_LAYER)
else:
rs.DeleteObjects(rs.ObjectsByLayer(TRASH_LAYER))
original_layer = rs.CurrentLayer()
machining_settings = False
general_settings = False
user_data = False
# if rs.IsAlias(alias_name):
# if rs.AliasMacro(alias_name) != "-_RunPythonScript (\"%s\")" % os.path.realpath(__file__):
# if rs.MessageBox("Rhino tiene registrado esta ubicacion en el comando de %s:\n\n%s\n\nDeseas cambiarla por esta?\n\n%s\n" % (alias_name,rs.AliasMacro(alias_name),os.path.realpath(__file__)) , 4 | 32) == 6:
# rs.DeleteAlias(alias_name)
# rs.AddAlias(alias_name,"-_RunPythonScript (\"%s\")" % os.path.realpath(__file__))
# else:
# pass
# else:
# if rs.MessageBox("Vincular el comando \"%s\" a este archivo?\n\n%s\n\nPodras ejecutar directamente el plugin escribiendo \"%s\" en la consola." % (alias_name,os.path.realpath(__file__),alias_name) , 4 | 32) == 6:
# rs.AddAlias(alias_name,"-_RunPythonScript (\"%s\")" % os.path.realpath(__file__))
# else:
# pass
try:
machining_settings = eval(rs.GetDocumentData(REGISTRY_SECTION,"machining_settings"))
except:
pass
try:
general_settings = eval(rs.GetDocumentData(REGISTRY_SECTION,"general_settings"))
except:
pass
try:
f = open(SETTINGS_FILE,"r")
r = f.read()
f.close()
persistant = eval(r)
if machining_settings != False:
machining_settings.update(persistant)
else:
machining_settings = persistant
except:
pass
try:
user_data = eval(rs.GetDocumentData(REGISTRY_SECTION,"user_data"))
if not user_data["save_path"]:
user_data["save_path"] = rs.DocumentPath().replace(".3dm","_gcode.txt") if rs.DocumentPath() else False
except:
pass
if user_data and user_data["selected_preset"] not in machining_settings:
user_data["selected_preset"] = False
print TXT["init"]
ui = SettingsControl(general_settings,machining_settings,user_data)
Rhino.UI.Dialogs.ShowSemiModal(ui.form)
temporal = {}
persistant = {}
for name in ui.machining_settings:
if ui.machining_settings[name]["persistant"]:
temporal[name] = ui.machining_settings[name]
else:
persistant[name] = ui.machining_settings[name]
f = open(SETTINGS_FILE,"w")
f.write(str(persistant))
f.close()
rs.SetDocumentData(REGISTRY_SECTION,"machining_settings",str(temporal))
rs.SetDocumentData(REGISTRY_SECTION,"general_settings",str(ui.general_settings))
rs.SetDocumentData(REGISTRY_SECTION,"user_data",str(ui.user_data))
# print "to registry...."
# print "machining_settings",str(ui.machining_settings)
# print "general_settings",str(ui.general_settings)
# print "user_data",str(ui.user_data)
# print "temp",str([i for i in temporal])
# print "persistant",str([i for i in persistant])
ui.code_thread = False
rs.CurrentLayer(original_layer)
rs.DeleteObjects(rs.ObjectsByLayer(OFFSET_LAYER))
rs.DeleteObjects(rs.ObjectsByLayer(TRASH_LAYER))
rs.DeleteLayer(OFFSET_LAYER)
rs.DeleteLayer(TRASH_LAYER)
print TXT["bye"]
def editing_geometry_smoothing(coarse_pseudo_quad_mesh):
"""Edit the geometry of a pattern with smoothing.
Parameters
----------
coarse_pseudo_quad_mesh : CoarsePseudoQuadMesh
The pattern to edit.
"""
mesh_to_smooth = rs.GetString('mesh to smooth?',
strings=[
'coarse_pseudo_quad_mesh',
'pseudo_quad_mesh', 'polygonal_mesh'
])
if mesh_to_smooth == 'coarse_pseudo_quad_mesh':
mesh = coarse_pseudo_quad_mesh
elif mesh_to_smooth == 'pseudo_quad_mesh':
mesh = coarse_pseudo_quad_mesh.get_quad_mesh
elif mesh_to_smooth == 'polygonal_mesh':
mesh = coarse_pseudo_quad_mesh.get_polygonal_mesh()
else:
return 0
settings = {'iterations': 50, 'damping': .5, 'constraints': {}}
while True:
rs.EnableRedraw(False)
artist = rhino_artist.MeshArtist(mesh)
guid = artist.draw_mesh()
rs.EnableRedraw(True)
operation = rs.GetString(
'edit smoothing settings?',
strings=['smooth', 'iterations', 'damping', 'constraints', 'exit'])
if operation is None or operation == 'exit':
if type(guid) == list:
rs.DeleteObjects(guid)
else:
rs.DeleteObject(guid)
break
elif operation == 'iterations':
settings[operation] = rs.GetInteger('iterations',
number=settings[operation],
minimum=0)
elif operation == 'damping':
settings[operation] = rs.GetReal('damping',
number=settings[operation],
minimum=0.,
maximum=1.)
elif operation == 'constraints':
count = 100
while count:
count -= 1
guids = display_smoothing_constraints(mesh,
settings[operation])
constraint_type = rs.GetString('type of constraints?',
strings=[
'automated_from_surface',
'automated_from_objects',
'customised', 'reset',
'exit'
])
rs.DeleteObjects(guids)
if constraint_type == 'automated_from_surface':
settings[
operation] = automated_smoothing_surface_constraints(
mesh,
RhinoSurface(
rs.GetObject('surface constraints', filter=8)))
elif constraint_type == 'automated_from_objects':
object_constraints = rs.GetObjects('object constraints')
point_constraints = [
obj for obj in object_constraints
if rs.ObjectType(obj) == 1
]
curve_constraints = [
obj for obj in object_constraints
if rs.ObjectType(obj) == 4
]
surface_constraint = [
obj for obj in object_constraints
if rs.ObjectType(obj) == 8
]
if len(surface_constraint) > 1:
print(
'More than one surface constraint! Only the first one is taken into account.'
)
if len(surface_constraint) == 0:
surface_constraint = None
else:
surface_constraint = surface_constraint[0]
settings[operation] = automated_smoothing_constraints(
mesh, point_constraints, curve_constraints,
surface_constraint)
elif constraint_type == 'customised':
settings[operation] = customized_smoothing_constraints(
mesh, settings[operation])
elif constraint_type == 'reset':
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
artist.draw_vertices()
artist.redraw()
vkeys = rhino_helper.mesh_select_vertices(
mesh, message='vertices')
if vkeys is None:
vkeys = list(mesh.vertices())
artist.clear_layer()
artist.redraw()
rs.DeleteLayer('mesh_artist')
for vkey in vkeys:
if vkey in settings[operation]:
del settings[operation][vkey]
else:
break
elif operation == 'smooth':
constrained_smoothing(mesh,
kmax=settings['iterations'],
damping=settings['damping'],
constraints=settings['constraints'],
algorithm='area')
if type(guid) == list:
rs.DeleteObjects(guid)
else:
rs.DeleteObject(guid)
if mesh_to_smooth == 'coarse_pseudo_quad_mesh':
coarse_pseudo_quad_mesh = mesh
elif mesh_to_smooth == 'pseudo_quad_mesh':
coarse_pseudo_quad_mesh.set_quad_mesh(mesh)
coarse_pseudo_quad_mesh.set_polygonal_mesh(mesh.copy())
elif mesh_to_smooth == 'polygonal_mesh':
coarse_pseudo_quad_mesh.set_polygonal_mesh(mesh)
import Rhino.Geometry as rg
import rhinoscriptsyntax as rs
# Clear canvas
rs.DeleteObjects(rs.AllObjects(select=True))
# Add relevant layers (if they don't exist)
layers = {
'Structure': ['s_points', 's_lines', 's_areas'],
'Strip A': ['CSA', 'MSA'],
'Strip B': ['CSB', 'MSB']
}
for key in layers.keys():
if rs.IsLayer(key):
rs.DeleteLayer(key)
rs.AddLayer(key)
sublayers = layers[key]
for sublayer in sublayers:
rs.AddLayer(sublayer, parent=key)
# Change layer colors for strips (increase visibility)
rs.LayerColor('CSA', color=(255, 0, 0))
rs.LayerColor('CSB', color=(255, 0, 0))
rs.LayerColor('MSA', color=(0, 0, 255))
rs.LayerColor('MSB', color=(0, 0, 255))
# Load data
with open('data.json') as fh:
data = json.load(fh)
def exportToRenderSKP():
#try:
#Get Objects
objs = rs.GetObjects("Select objects to export", preselect = True)
if objs is None: return
#Default Name
if 'exportToRenderSKP-prevName' in sc.sticky:
prevName = sc.sticky['exportToRenderSKP-prevName']
defaultFilename = utils.UpdateString(prevName)
else:
defaultFilename = utils.GetDatePrefix() + '_OPTION_01'
#Default Folder
if 'exportToRenderSKP-path' in sc.sticky:
defaultFolder = sc.sticky['exportToRenderSKP-path']
elif utils.IsSavedInProjectFolder():
origPath = rs.DocumentPath()
path = os.path.normpath(origPath)
pathParts = path.split(os.sep)
projectFolder = os.path.join(pathParts[0],'\\' ,pathParts[1])
referenceFolder = os.path.join(projectFolder, r'03 DRAWINGS\02 RENDERING\0_copy 3d folder structure\Reference')
if os.path.isdir(referenceFolder):
print "Reference folder exists"
defaultFolder = referenceFolder
else:
print "Reference folder not found"
defaultFolder = rs.DocumentPath()
else:
defaultFolder = rs.DocumentPath()
fileName = rs.SaveFileName("Export to render", "Sketchup 2015 (*.skp)|*.skp||", folder = defaultFolder, filename = defaultFilename)
if fileName is None: return
sc.sticky['exportToRenderSKP-prevName'] = os.path.splitext(fileName)[0]
sc.sticky['exportToRenderSKP-path'] = os.path.dirname(fileName)
tempLayers = []
copiedObjs = []
seperator = ' > '
baseName = os.path.splitext(os.path.basename(fileName))[0]
#Copy all objects to export
rs.StatusBarProgressMeterShow('Exporting to SKP', 0, len(objs))
for i, obj in enumerate(objs):
tempCopy = rs.CopyObject(obj)
if rs.IsBlockInstance(tempCopy):
explodedObjs = list(rs.ExplodeBlockInstance(obj, True))
copiedObjs += explodedObjs
else:
copiedObjs.append(tempCopy)
rs.StatusBarProgressMeterUpdate(i)
#Move all copies to a different layer
for i, obj in enumerate(copiedObjs):
layerFullName = rs.ObjectLayer(obj)
shortName = layerFullName.replace('::', seperator)
layerName = baseName + seperator + shortName
if rs.IsLayer(layerName):
rs.ObjectLayer(obj, layerName)
else:
matIndex = rs.LayerMaterialIndex(rs.ObjectLayer(obj))
newLayer = rs.AddLayer(layerName, rs.LayerColor(rs.ObjectLayer(obj)))
rs.LayerMaterialIndex(newLayer, matIndex)
tempLayers.append(newLayer)
rs.ObjectLayer(obj, newLayer)
rs.StatusBarProgressMeterHide()
try:
rs.SelectObjects(copiedObjs)
rs.Command('-_Export ' + '"' + fileName + '"' + ' s SketchUp2015 Enter ', False)
#CLEANUP
rs.UnselectAllObjects()
try:
rs.DeleteObjects(copiedObjs)
except:
rs.DeleteObject(copiedObjs)
for layer in tempLayers:
rs.DeleteLayer(layer)
except:
print "export failed"
result = True
#except:
# result = False
try:
pass
#utils.SaveFunctionData('IO-Export to Render[SKP]', [fileName, baseName, os.path.getsize(fileName),len(objs), result])
except:
print "Failed to save function data"
return result
def translateLayer(layer):
"""
translates from Rhino Name to CAD Name
input: one layer
returns: new layer name
"""
rhinoLayerFilePath = "C:\\Users\\Tim\\Desktop\\temp\\RhinoLayersV2.csv"
#Read the CSV
file = open(rhinoLayerFilePath, "r")
contents = file.readlines()
file.close()
#Variables
CategoryCol = 1
RhinoLayerCol = 2
CADNameCol = 9
CADColorCol = 10
CADLineweightCol = 11
found = False
layerShort = rs.LayerName(layer, False)
newLayerName = ""
#Check the CSV
for row in contents:
rowParts = row.split(",")
if row.split(",")[RhinoLayerCol] == str(
layerShort): #if layer name exists in CSV
CADName = row.split(",")[CADNameCol]
CADColor = translateColor(layer, row.split(",")[CADColorCol])
CADLineweight = row.split(",")[CADLineweightCol]
#if Rhino name found but no CAD name associated with it
if not CADName:
CADName = "A-RHINO-" + layerShort
newLayerName = CADName
if len(CADLineweight) < 2:
CADLineweight = 0
#Check if layer already exists.
parent = rs.ParentLayer(layer)
existLayers = rs.LayerChildren(parent)
isExisting = False
for existLayer in existLayers:
#if new name already exists as a layer
if rs.LayerName(existLayer, False) == CADName:
layersObjs = rs.ObjectsByLayer(layer)
for layersObj in layersObjs:
rs.ObjectLayer(layersObj, existLayer)
rs.DeleteLayer(layer)
newLayerName = rs.LayerName(existLayer, False)
print "Layer {} merged with existing layer {}.".format(
layerShort, rs.LayerName(layer, False))
isExisting = True
break
#if layer does not already exist
if isExisting == False:
rs.LayerColor(layer, CADColor)
rs.LayerPrintWidth(layer, float(CADLineweight))
newLayerName = CADName
rs.RenameLayer(layer, CADName)
print "Layer {} changed to layer {}.".format(
layerShort, CADName)
found = True
break
if not found:
layerShort = rs.LayerName(layer, False)
CADName = "A-RHINO-" + layerShort
newLayerName = CADName
rs.RenameLayer(layer, CADName)
print "Layer {} has no matching CAD layer.".format(layerShort)
return newLayerName
return newLayerName
def importCAD(filePath, scaleDWG = False):
explodeBlockBoo = True
#setup the layers
importLayerNumber = 6000
importLayerObj = layers.AddLayerByNumber(importLayerNumber, False)
importLayerName = layers.GetLayerNameByNumber(importLayerNumber)
#Shorten cad file name
fileNameExt = os.path.basename(filePath)
fileName = os.path.splitext(fileNameExt)[0]
#create layer name
time = utils.GetDatePrefix()
iter = "01"
layerName = time+"_"+fileName+"_"+iter
#Check if this layer already exists
while rs.IsLayer(importLayerName + "::" + time + "_" + fileName + "_" + iter):
iterInt = int(iter)+1
if len(str(iterInt))<2:
iter = "0" + str(iterInt)
else:
iter = str(iterInt)
elementLayerName = importLayerName + "::" + time + "_" + fileName + "_" + iter
elementLayer = rs.AddLayer(elementLayerName)
rs.CurrentLayer(elementLayer)
#get intial list of all layers in the file
currentLayers = rs.LayerNames()
rs.Command('_-Import "' + filePath + '" _IgnoreThickness=Yes _ModelUnits=Inches _Enter', False)
#get new layers added
endLayersNames = rs.LayerNames()
newLayers = diff(endLayersNames, currentLayers)
for layer in newLayers:
rs.ParentLayer(layer, elementLayer)
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())
blockNames = []
for finalLayer in finalLayers:
layerObjects = rs.ObjectsByLayer(finalLayer)
for layerObject in layerObjects:
if rs.IsBlockInstance(layerObject):
blockNames.append(rs.BlockInstanceName(layerObject))
allObjects.append(rs.ExplodeBlockInstance(layerObject, True))
else:
allObjects.append(layerObject)
finalAllObjects = list(flatten(allObjects))
for eachBlock in blockNames:
try:
rs.DeleteBlock(eachBlock)
except:
pass
#Scale objects
if scaleDWG:
rs.ScaleObjects(finalAllObjects, [0,0,0], [.001, .001, .001])
#Collapse layers
try:
rootLay = sc.doc.Layers.FindId(rs.coerceguid(rs.LayerId(elementLayerName)))
rootLay.IsExpanded = False
except:
pass
print "Import Successful"
return finalAllObjects
""" SHL Architects 30-01-2019 Sean Lamb (Developer) [email protected] -better handling of different brep types """ import rhinoscriptsyntax as rs layers = rs.LayerNames() num_layers = 0 for layer in layers: if rs.IsLayerEmpty(layer): if rs.IsLayerCurrent(layer): print "Current layer is empty but will not be removed." else: rs.DeleteLayer(layer) num_layers += 1 print "%d empty layers removed." % num_layers
