def organize_annotations():
"""
- puts all dimensions found in all pages on layer 'dim' and annotations on 'annotation'
- creates layer called 'dim' + 'annotation' if it doesn't exist and changes its color to black
version 1.0
www.studiogijs.nl
"""
#check if layer 'dim' exist, else create it
if not rs.IsLayer("dim"): rs.AddLayer("dim")
rs.LayerColor("dim", Col.Black)
#check if layer 'annotation' exist, else create it
if not rs.IsLayer("annotation"): rs.AddLayer("annotation")
rs.LayerColor("annotation", Col.Black)
objects = Rhino.RhinoDoc.ActiveDoc.Objects.FindByObjectType(
Rhino.DocObjects.ObjectType.Annotation)
for obj in objects:
if type(obj) == Rhino.DocObjects.LeaderObject or type(
obj) == Rhino.DocObjects.TextObject:
rs.ObjectLayer(obj, "annotation")
else:
rs.ObjectLayer(obj, "dim")
def changeColors(childLayers):
print(childLayers)
for childLayer in childLayers:
for name, color in colorDict.items():
color = rs.coercecolor(color)
if re.search('HATCH-' + name + '$', childLayer):
print(childLayer)
rs.LayerPrintColor(childLayer, color)
rs.LayerColor(childLayer, color)
layer_c = rs.LayerColor(childLayer)
layer_m = rs.LayerMaterialIndex(childLayer)
if layer_m == -1:
layer_m = rs.AddMaterialToLayer(childLayer)
rs.MaterialColor(layer_m, layer_c)
def unifyColor(layer):
layer_c = rs.LayerColor(layer)
layer_m = rs.LayerMaterialIndex(layer)
if layer_m == -1:
layer_m = rs.AddMaterialToLayer(layer)
rs.MaterialColor(layer_m, layer_c)
rs.LayerPrintColor(layer, layer_c)
def cutAtPlan(level):
planPlane = rs.AddPlaneSurface([-1000,-1000,level], 3000, 3000)
baseLayer = rs.AddLayer("60_PLANS")
newParent = rs.AddLayer("PLAN_"+str(level), parent = baseLayer)
origLayer = rs.CurrentLayer()
shortName = rs.LayerName(origLayer, fullpath = False)
#newChildsParent = rs.AddLayer( , parent = newParent)
newChild = rs.AddLayer(shortName, parent = newParent, color = rs.LayerColor(origLayer))
rs.CurrentLayer(newChild)
objs = rs.ObjectsByLayer(origLayer)
#if len(objs)<1:
# skip = True
intersectCrvs = []
tempCrv = None
for obj in objs:
if rs.IsBrep(obj):
tempCrv = rs.IntersectBreps(obj, planPlane)
if tempCrv != None:
intersectCrvs.append(tempCrv)
for crv in intersectCrvs:
if not None:
rs.ObjectLayer(crv, newChild)
rs.DeleteObject(planPlane)
rs.CurrentLayer(origLayer)
def iterate():
colDelta = 20
origLayer = rs.GetLayer("Select Layer to Iterate")
if origLayer is None:
return
shortName = origLayer.split("::")[-1]
parentLay = rs.ParentLayer(origLayer)
nameParts = shortName.split("_")
if len(nameParts) > 1:
num = int(nameParts[1]) + 1
else:
num = 1
if len(str(num)) == 1:
newNum = "0" + str(num)
else:
newNum = str(num)
newName = nameParts[0] + "_" + newNum
lay1 = rs.CurrentLayer(origLayer)
#MAterials
matIndex = rs.LayerMaterialIndex(lay1)
#New Color
oldCol = rs.LayerColor(lay1)
oldRed = rs.ColorRedValue(oldCol)
oldGreen = rs.ColorGreenValue(oldCol)
oldBlue = rs.ColorBlueValue(oldCol)
newRed = oldRed + randCol(colDelta)
if newRed > 255:
newRed = 255 - (newRed - 255)
if newRed < 0:
newRed = abs(newRed)
newGreen = oldGreen + randCol(colDelta)
if newGreen > 255:
newGreen = 255 - (newGreen - 255)
if newGreen < 0:
newGreen = abs(newGreen)
newBlue = oldBlue + randCol(colDelta)
if newBlue > 255:
newBlue = 255 - (newBlue - 255)
if newBlue < 0:
newBlue = abs(newBlue)
newCol = (newBlue, newGreen, newBlue)
newLay = rs.AddLayer(newName, color=newCol, parent=parentLay)
#print nameParts
#print newName
finalLayer = rs.CurrentLayer(newLay)
#sc.doc.Layers.CurrentLayer.RenderMaterialIndex = 3
#c = sc.doc.Layers.CurrentLayer.RenderMaterialIndex
#sc.doc.Layers.Modify(
#Rhino.DocObjects.Tables.LayerTable.CurrentLayer.r
#sc.doc.Views.Redraw()
#b = sc.doc.Layers.CurrentLayer
#print ""
return
def translateColor(layer, colorString):
if len(colorString) > 1:
newColor = (int(colorString.split("-")[0]),
int(colorString.split("-")[1]),
int(colorString.split("-")[2]))
else:
newColor = rs.LayerColor(layer)
return newColor
def duplicateLayer(name, source, destination):
newLayer = rs.AddLayer(name,
color=rs.LayerColor(source),
parent=destination)
rs.ParentLayer(newLayer, destination)
# print(name, source, destination)
matchLayer(newLayer, source)
return (newLayer)
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 set_layer_properties(layer, properties):
"""Set Rhino layer properties."""
rs.LayerVisible(layer, properties.get("LayerVisible"))
rs.LayerLocked(layer, properties.get("LayerLocked"))
rs.LayerColor(layer, hex_to_rbg(properties.get("LayerColor")))
rs.LayerMaterialIndex(layer, properties.get("LayerMaterialIndex"))
rs.LayerLinetype(layer, properties.get("LayerLinetype"))
rs.LayerPrintColor(layer, hex_to_rbg(properties.get("LayerPrintColor")))
rs.LayerPrintWidth(layer, properties.get("LayerPrintWidth"))
def DupAllSubLayers(layer, layerCopy):
subs = rs.LayerChildren(layer)
if subs:
for sub in subs:
color = rs.LayerColor(sub)
objs = rs.ObjectsByLayer(sub)
name = UniqueLayerCopyName(sub, False)
addLayer = rs.AddLayer(name, color, parent=layerCopy)
CopyObjectsToLayer(objs, addLayer)
rs.ExpandLayer(addLayer, rs.IsLayerExpanded(sub))
DupAllSubLayers(sub, addLayer)
def set_color(self, c):
"""Sets layer color.
Parameters:
c = color as an RGB value array
Returns:
self
"""
rs.LayerColor(self.name, c)
return self
def get_layer_properties(layer):
"""Get Rhino layer properties."""
return {
"LayerVisible": rs.LayerVisible(layer),
"LayerLocked": rs.LayerLocked(layer),
"LayerColor": rgb_to_hex(rs.LayerColor(layer)),
"LayerMaterialIndex": rs.LayerMaterialIndex(layer),
"LayerLinetype": rs.LayerLinetype(layer),
"LayerPrintColor": rgb_to_hex(rs.LayerPrintColor(layer)),
"LayerPrintWidth": rs.LayerPrintWidth(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 DupLayersSublayersAndObjs():
layer = rs.GetLayer()
if layer == None: return
#do initial run with selected layer
color = rs.LayerColor(layer)
objs = rs.ObjectsByLayer(layer)
parentLayer = rs.ParentLayer(layer)
copyName = UniqueLayerCopyName(layer, True)
layerCopy = rs.AddLayer(copyName, color, parent=parentLayer)
CopyObjectsToLayer(objs, layerCopy)
rs.ExpandLayer(layerCopy, rs.IsLayerExpanded(layer))
DupAllSubLayers(layer, layerCopy)
rs.CurrentLayer(layerCopy)
def ColorizeLayers(aObj):
rs.EnableRedraw(False) # turn off redraw for faster script exectution.
# the start value of r g b
r = 1
g = 0
b = 0
for i in range(0, len(aObj)): #iterate through all selected objects
r, g, b = GetColor(
r, g, b) #I made a function from your script to modify aColor.
RGBColor = [int(r * 255), int(g * 255), int(b * 255)]
rs.LayerColor(aObj[i], RGBColor)
rs.EnableRedraw(True) #turn screen redraw back on
def organize_details():
"""
- puts all details on layer 'details'
- creates layer called 'details' if it doesn't exist and changes its color to green
version 1.0
www.studiogijs.nl
"""
#check if layer 'details' exist, else create it
if not rs.IsLayer("details"): rs.AddLayer("details")
rs.LayerColor("details",Col.Aquamarine)
pageviews = sc.doc.Views.GetPageViews()
for pageview in pageviews:
#get all details
details = pageview.GetDetailViews()
for detail in details:
rs.ObjectLayer(details, "details")
def AddCNCLayers():
LayerNames = [
"Work layer", "CNC drill", "CNC pocket", "CNC engrave", "CNC cut",
"CNC 3D", "CNC tabs"
]
LayerColors = [(221, 221, 221), (255, 191, 0), (253, 0, 255),
(255, 125, 218), (0, 163, 184), (100, 113, 113),
(191, 191, 255)]
Count = 0
for x in LayerNames:
layer.Name = x
sc.doc.Layers.Add(layer)
sc.doc.Layers.Add
rs.LayerColor(x, LayerColors[Count])
Count += 1
def Iterate():
block = rs.GetObject("Select Design Option Block to iterate",
rs.filter.instance, True)
if block is None: return
try:
prevBlockName = rs.BlockInstanceName(block)
prevBlockLayer = rs.ObjectLayer(block)
prevBlockLayerColor = rs.LayerColor(prevBlockLayer)
newBlock = ReplicateBlock(block)
newBlockName = rs.BlockInstanceName(newBlock)
#Ensure 3_DESIGN OPTIONS already exists
parentLayer = layers.AddLayerByNumber(3000, False)[0]
rs.LayerVisible(parentLayer, True)
#Create new design option layer
#newBlockLayer = rs.AddLayer(parentLayer + "::" + newBlockName, color = utils.StepColor(prevBlockLayerColor))
newBlockLayer = rs.AddLayer(parentLayer + "::" + newBlockName,
color=utils.GetRandomColor())
rs.LayerPrintColor(newBlockLayer, (0, 0, 0))
rs.ObjectLayer(newBlock, newBlockLayer)
#Save user text
try:
parentsUserTest = rs.GetUserText(block,
'Design Option History') + "<--"
except:
parentsUserTest = ''
rs.SetUserText(newBlock, 'Design Option History',
parentsUserTest + newBlockName)
#Turn off prev blocks layer
if rs.CurrentLayer() != prevBlockLayer:
rs.LayerVisible(prevBlockLayer, False)
result = True
except:
result = False
newBlockName = ''
utils.SaveFunctionData(
'Blocks-Iterate',
[__version__,
rs.BlockInstanceName(block), newBlockName, result])
return result
def setup_layer(name, options):
parent = options.get('parent', None)
locked = options.get('locked', False)
if not rs.IsLayer(name):
layer = rs.AddLayer(name=name, parent=parent, locked=locked)
else:
rs.ParentLayer(name, parent)
layer = rs.LayerName(name)
color = options.get('color', (0, 0, 0))
print_width = options.get('lineWeight', 0)
linetype = options.get('lineType', 'Continuous')
rs.LayerColor(name, color)
rs.LayerPrintWidth(name, print_width)
rs.LayerLinetype(name, linetype)
return layer
def ImportLighthouseSensorsFromJSON(filename):
print "Reading", filename
contents = file(filename).read()
if "{" not in contents:
raise Exception("Malformed JSON")
header = contents[0:contents.find('{')]
print header
try:
layername = os.path.splitext(os.path.basename(filename))[0].lower()
except:
layername = "sensors"
jsonstr = contents[contents.find('{'):]
data = json.loads(jsonstr)
originalLayer = rs.CurrentLayer()
layername = rs.AddLayer(layername)
rs.CurrentLayer(layername)
rs.LayerColor(layername, RandomSaturatedColor())
groupName = rs.AddGroup(layername)
SENSOR_RADIUS_MM = 3.0
SENSOR_NORMAL_LENGTH_MM = 8.0
for point, normal in zip(data['modelPoints'], data['modelNormals']):
position = rs.coerce3dvector([x * 1000.0 for x in point])
normal = rs.VectorUnitize(normal)
normalOrthoA = Orthogonal(normal)
normalOrthoB = rs.VectorCrossProduct(normalOrthoA, normal)
objID = rs.AddCircle3Pt(position + SENSOR_RADIUS_MM * normalOrthoA,
position - SENSOR_RADIUS_MM * normalOrthoA,
position + SENSOR_RADIUS_MM * normalOrthoB)
rs.AddObjectToGroup(objID, groupName)
objID = rs.AddLine(position,
position + SENSOR_NORMAL_LENGTH_MM * normal)
rs.AddObjectToGroup(objID, groupName)
rs.CurrentLayer(originalLayer)
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 setTemplateLayerColors():
""" Set Rhino layer colors to the AHD style """
# Set context to Rhino document and disable redraw
sc.doc = rc.RhinoDoc.ActiveDoc
rs.EnableRedraw(False)
# Set layer colors
for i, l in enumerate(rs.LayerNames()):
if i == 0:
rs.LayerColor(l, Color.FromArgb(255, 105, 105, 105))
elif i == 1:
rs.LayerColor(l, Color.FromArgb(255, 255, 0, 90))
elif i == 2:
rs.LayerColor(l, Color.FromArgb(255, 70, 190, 190))
elif i == 3:
rs.LayerColor(l, Color.FromArgb(255, 0, 85, 255))
elif i == 4:
rs.LayerColor(l, Color.FromArgb(255, 130, 255, 0))
elif i == 5:
rs.LayerColor(l, Color.FromArgb(255, 190, 190, 190))
def text_background_color():
lay_curr = rs.CurrentLayer()
col_lay = rs.LayerColor(lay_curr)
rs.AppearanceColor(12,col_lay)
'show.vertices': True,
'show.edges': True,
'show.forces': True,
'show.forces_as_vectors': True,
'show.interfaces': True,
'mode.interface': 0,
'mode.force': 0,
'scale.force': 10.0
})
rs.CurrentLayer('Assembly')
rs.LayerVisible('Blocks', False)
rs.LayerVisible('Supports', False)
rs.AddLayer('forces')
rs.LayerColor('forces', (255, 0, 0))
rs.DeleteObjects(rs.ObjectsByLayer('forces'))
rs.CurrentLayer('forces')
g = 9.81 #m/s^2
d = 1000 #Kg/m^3
for a, b, attr in assembly.edges(True):
if attr['interface_forces'] is None:
continue
s = attr['interface_size']
sp = attr['interface_points']
fff = []
for i in range(len(attr['interface_points'])):
t = attr['interface_forces'][i]['c_nn']
cp = centroid_points(sp)
if t >= 0.0001:
import rhinoscriptsyntax as rs
layer = rs.CurrentLayer()
layer_c = rs.LayerColor(layer)
layer_m = rs.LayerMaterialIndex(layer)
if layer_m == -1:
layer_m = rs.AddMaterialToLayer(layer)
rs.MaterialColor(layer_m, layer_c)
rs.LayerPrintColor(layer, layer_c)
Y_Step = 10000
#Define the prefix of each file
Sail_Name = rs.GetString("Input Sail Number")
x = rs.GetInteger("Number of Drawings in X direction")
y = rs.GetInteger("Number of Drawings in Y direction")
direct = rs.BrowseForFolder(None, "Choose a folder", None)
#Define color to exort geometry to DWG cause cannot see black in DWG
Black = Color.Black
White = Color.White
#Change black color to white
layers = rs.LayerIds()
for layer in layers:
print rs.LayerColor(layer)
if rs.LayerColor(layer) == Black:
rs.LayerColor(layer, White)
#Select the drawings which are in grid and export.
for j in range(y):
for i in range(x):
x_cnt = X_ST + i * X_Step
y_cnt = Y_ST + j * Y_Step
x1 = x_cnt - X_Step / 2
x2 = x_cnt + X_Step / 2
y1 = y_cnt - 2300
y2 = y_cnt + 4900
k = str(int(i + 1)).zfill(2)
l = str(int(j + 1)).zfill(2)
#Define path
"""
For use with the Feasibility Study Workflow.
See "F:\Resource\Strategic Initiatives\0702013.20 Research Initiative\Rhino Workflow"
For use with Feasibility Study Assistant Grasshopper Script.
See "F:\Resource\Strategic Initiatives\0702013.20 Research Initiative\Grasshopper\Grasshopper Toolset\Feasibility Drafting and modeling Assistant"
This script is to create a subfolder to a hatch layer that specifies it as an
open area, as you might label as "OPEN TO BELOW" in floor plans.
Make sure the layer you want to add an OPEN layer to is the currently selected layer
before running.
"""
import rhinoscriptsyntax as rs
currentLayer = rs.CurrentLayer()
layerName = rs.LayerName(currentLayer, fullpath=False)
newLayer = rs.AddLayer(name=layerName+"_OPEN")
rs.ParentLayer(newLayer, currentLayer)
layer_c = rs.LayerColor(currentLayer)
layer_m = rs.LayerMaterialIndex(currentLayer)
if layer_m == -1:
layer_m = rs.AddMaterialToLayer(newLayer)
rs.MaterialColor(layer_m, layer_c)
rs.LayerPrintColor(newLayer, layer_c)
rs.LayerColor(newLayer, layer_c)
def __set_render_color(self):
r = self.emotion_properties["color"]["r"]
g = self.emotion_properties["color"]["g"]
b = self.emotion_properties["color"]["b"]
rs.LayerColor("Default", (r, g, b))
import rhinoscriptsyntax as rs
from System.Drawing import Color
import random
#assign different materials to layers and change layer colors to correspond with it for export to lumion
def randomcolor():
red = int(255*random.random())
green = int(255*random.random())
blue = int(255*random.random())
return Color.FromArgb(red,green,blue)
count = rs.LayerCount()
layerNames = rs.LayerNames()
print(layerNames)
print "There are", count, "layers."
for i in range(count):
rc = randomcolor()
rs.LayerColor(layerNames[i], rc)
rs.MaterialColor(i,rc)
rs.MaterialName( i, str(i))
rs.AddMaterialToLayer(layerNames[i])
import rhinoscriptsyntax as rs
import random
from System.Drawing import Color
layers = rs.LayerNames()
def randomcolor():
red = int(255 * random.random())
green = int(255 * random.random())
blue = int(255 * random.random())
return Color.FromArgb(red, green, blue)
for layer in layers:
rs.LayerColor(layer, randomcolor())
