def exportAllPlansToCAD():
if rs.IsLayer("6_DRAWINGS"):
children = rs.LayerChildren("6_DRAWINGS")
items = []
for child in children:
items.append(rs.LayerName(child, False))
#level = rs.ComboListBox(items)
print rs.DocumentPath()
pathParts = rs.DocumentPath().split("\\")
if pathParts[0] == "P:":
defaultPath = pathParts[0] + "\\" + pathParts[
1] + "\\" + pathParts[2] + "\\" + pathParts[3]
folder = rs.BrowseForFolder(
folder=defaultPath,
message="Select Folder to export plans.",
title="Export Plans")
else:
folder = rs.BrowseForFolder()
RhinoFile = rs.DocumentName()
rhinoName = RhinoFile.split(".")[0] + "_P_"
for item in items:
levelNum = item.split("_")[-1]
fileName = "\\" + rhinoName + levelNum + ".dwg"
savePath = folder + fileName
#savePath = rs.SaveFileName("Save", "Autocad (*.dwg)|*.dwg||")
if savePath is not None:
exportPlanToCAD(item, savePath)
else:
print "No plans currently cut. Use CutPlans."
return
def IsSavedInProjectFolder():
"""Checks if Rhino file is saved in a project folder
"""
fileLocations = config.GetDict()
x = rs.DocumentPath()
if x is None: return False
print
if rs.DocumentPath()[:2] == fileLocations['Project Folders'][:2]: return True
else: return False
def read_info_file(self,file_name):
file_path = os.path.join("\\".join(rs.DocumentPath().split("\\")[:-1]),file_name)
if not os.path.isfile(file_path): file_path = os.path.join("\\".join(rs.DocumentPath().split("\\")[:-1]),file_name + ".txt")
if os.path.isfile(file_path):
f = open(file_path)
info_file_path = json.loads(f.read())
f.close()
return info_file_path
else: return False
def unIsolateLayers():
"""Unisolate layers by unhiding layers."""
file_name = rs.DocumentName()
file_path = rs.DocumentPath()
if file_name is None:
temp_file_name = "IsolateLayers_temp.json"
else:
temp_file_name = file_path + 'IsolateLayers_temp_' + file_name.strip(
'.3dm') + '.json'
if not os.path.isfile(temp_file_name):
print("Temp File does not exist!")
return
with open(temp_file_name, "r") as f:
layers_data = json.load(f)
layers_data = {rs.LayerName(k): v for k, v in layers_data.items()}
sorted_layers_data = sorted(layers_data.iteritems())
for layer_name, layer_visibility in sorted_layers_data:
rs.LayerVisible(layer_name, layer_visibility)
# remove TEMP FILE
os.remove(temp_file_name)
def RunCommand(is_interactive):
config = get_sisufile()
if not config:
print('Sisufile not configured')
return Rhino.Commands.Result.Failure
items = config['data']
out = []
failed_objects = []
result = {}
for item in items:
if not 'code' in item:
print('failed to process item: code not found')
continue
# calc existing layer only
layer_name = item['layer'][0]
if not rs.IsLayer(layer_name):
continue
c = item.get('code')
units = c.get('units')
if not units:
print('failed to process dc item: units not specified')
if units == UNIT_PIECE:
upd, failed = calc_piece(c)
failed_objects = failed_objects + failed
result.update(upd)
if units == UNIT_M2:
upd, failed = calc_m2(c)
failed_objects = failed_objects + failed
result.update(upd)
if units == UNIT_M:
upd, failed = calc_m(c)
failed_objects = failed_objects + failed
result.update(upd)
if len(failed_objects) > 0:
print('failed to calc')
rs.SelectObjects([x.Id for x in failed_objects])
else:
now = datetime.date.today()
prefix = now.strftime('%Y%m%d')
doc = rs.DocumentPath()
filename = '%s-SISU_CALC.csv' % prefix
filepath = os.path.join(doc, filename)
print('saving to file... %s' % filepath)
save_sisu_calc_report(result, filepath)
# try:
# conf = get_layer_config(code)
# conf.update(item)
# out.append(conf)
# except Exception as e:
# print('DC failed. Fill defaults', code, e)
## conf.update(default_config)
return Rhino.Commands.Result.Success
def __init__(self, objects_to_render):
self.objects_to_render = objects_to_render
dirname = os.path.dirname
self.script_path = dirname(os.path.realpath(__file__)) + "\\"
filepath = rs.DocumentPath()
if not filepath: self.filepath = self.script_path
else: self.filepath = str(os.path.splitext(str(filepath))[0])
doc_name = rs.DocumentName()
if not doc_name: doc_name = "Render_"
else: doc_name = os.path.splitext(doc_name)[0]
self.render_name = doc_name + "_" + date.today().strftime(
"%y%m%d") + "_" + time.strftime("%Hh%Mm%Ss")
#print "Filepath: " + self.filepath
#print "Rendername: " + self.render_name
self.camera_data = None
#Default Material
self.materials = []
default_material_index = sc.doc.Materials.Add()
default_material = sc.doc.Materials[default_material_index]
default_material.Name = "Default"
default_material.Shine = 0
default_material.CommitChanges()
self.materials.append(default_material_index)
def CreateShortcut():
"""
Create a shortcut to the current document
NOTE!! This function only runs on Windows
"""
if (not rs.IsRunningOnWindows()):
rs.MessageBox("CreateShortcut.py only runs on Windows", 48,
"Script Error")
return
# Get the document name and path
name = rs.DocumentName()
path = rs.DocumentPath()
# Get the Windows Scripting Host's Shell object
objShell = System.Activator.CreateInstance(
System.Type.GetTypeFromProgID("WScript.Shell"))
# Get the desktop folder
desktop = objShell.SpecialFolders("Desktop")
# Make a new shortcut
ShellLink = objShell.CreateShortcut(desktop + "\\" + name + ".lnk")
ShellLink.TargetPath = Path.Combine(path, name)
ShellLink.WindowStyle = 1
ShellLink.IconLocation = rs.ExeFolder() + "Rhino4.exe, 0"
ShellLink.Description = "Shortcut to " + name
ShellLink.WorkingDirectory = path
ShellLink.Save()
def write_file(file_name, content):
path = rs.DocumentPath()
name = rs.DocumentName()
# save to public
path = path + "/../../../../public/data/geo/" + file_name
f = open(path, "w")
f.write(content)
f.close()
def get_sisufile_path():
f = rs.GetDocumentUserText(SISUFILE_KEY)
if f:
return f
doc_path = rs.DocumentPath()
if not doc_path:
return None
return os.path.join(doc_path, 'sisufile.json')
def GetFracture ():
dx = rs.GetReal("Enter x-axis direction:")
if not dx:
dx = 0.0
print "x-axis direction: ", dx
objs = rs.ObjectsByType(8,False)
cir_objs = rs.ObjectsByType(4)
#delete all circles
for cur_obj in cir_objs:
if rs.IsCircle(cur_obj):
rs.DeleteObject(cur_obj)
occor = []
radius = []
center = []
#for all surface
for obj in objs:
rs.UnselectAllObjects()
rs.SelectObject(obj)
rs.Command ("_Silhouette")
created_objs = rs.LastCreatedObjects()
#not a circle
if len(created_objs) !=1:
rs.DeleteObjects(created_objs)
print "unvailded surface"
continue
created_objs = created_objs[0]
#not a circle
if not rs.IsCircle(created_objs):
rs.DeleteObject(created_objs)
print "unvailded surface, not circle"
continue
point = rs.CircleCenterPoint(created_objs)
center.append(point)
r = rs.CircleRadius(created_objs)
radius.append(r)
normal = rs.SurfaceNormal(obj,[0,0])
occor.append(GetDirDip(normal,dx))
rs.DeleteObject(created_objs)
print center
print occor
print radius
path = rs.DocumentPath()
path_l = path.split("\\")
path_l[len(path_l)-1] = "fracture.dat"
file = open("\\".join(path_l),"w")
file.write(str(len(occor)))
file.write('\n')
for i in range (len(occor)):
file.write("%.15f " % center[i][0])
file.write("%.15f " % center[i][1])
file.write("%.15f " % center[i][2])
file.write ("%.15f " % occor[i][0])
file.write ("%.15f " % occor[i][1])
file.write ("%.15f " % radius[i])
file.write ("0.0001 0.1 30\n")
file.close ()
def get_document_filepath():
"""Get the full path to the Rhino document.
Returns
-------
str or None
The path to the document or None if the document is still "Untitled".
"""
return rs.DocumentPath()
def CurrentModelInfo():
"Get the current document name and path"
name = rs.DocumentName()
path = rs.DocumentPath()
fileexists = False
if (path and name):
filespec = Path.Combine(path, name)
fileexists = File.Exists(filespec)
if fileexists:
__PrintFileInformation(filespec)
else:
print "Current model not found. Make sure the model has been saved to disk."
def SaveCopy():
"""Save a copy of the current Rhino file."""
date_time = datetime.now().strftime("%Y%m%d_%H%M%S")
while rs.DocumentPath() is None:
rs.Command("'_Save")
file_name = rs.DocumentName()
file_dir = rs.DocumentPath()
file_path = file_dir + file_name
copy_name = "_".join([date_time, file_name])
copy_path = rs.DocumentPath() + copy_name
try:
os.mkdir(copy_dir)
rs.Command("'-Save " + file_path)
copyfile(file_path, copy_path)
except:
rs.Command("'-Save " + file_path)
copyfile(file_path, copy_path)
def BatchPrintLayouts():
print "BatchPrintLayout is WIP. Use with caution."
try:
pages = sc.doc.Views.GetPageViews()
if pages is None or len(pages) < 1:
print "No layouts in file"
return
defaultPath = rs.DocumentPath()
defaultName = utils.GetDatePrefix() + "_Rhino"
filename = rs.SaveFileName("Save",
"PDF (*.pdf)|*.pdf||",
folder=defaultPath,
filename=defaultName)
if filename is None: return
names = []
for page in pages:
names.append([page.PageName, False])
selectedLayouts = rs.CheckListBox(names, "Select Layouts to print",
"Batch Print")
if selectedLayouts is None: return
stop = False
for layout in selectedLayouts:
if layout[1] == True:
stop = True
break
if stop == False:
print "No layouts selected"
return
try:
pdf = Rhino.FileIO.FilePdf.Create()
except:
print "Failed to load Rhino.FileIO.FilePdf.Create()"
return
dpi = 300
for i, page in enumerate(pages):
if selectedLayouts[i][1]:
capture = Rhino.Display.ViewCaptureSettings(page, dpi)
pdf.AddPage(capture)
pdf.Write(filename)
print "PDF saved to {}".format(filename)
except IOError, e:
print str(e)
return
def get_output_path():
"""Returns output path as 'system.dat' in the directory of the Rhino model (Windows + Mac OS)."""
path = rs.DocumentPath()
name = rs.DocumentName()
if gc.operating_system == "mac":
path = path[:-len(name)] + "_system.dat"
elif gc.operating_system == "win":
i = path.rfind("\\")
path = path[:i] + "/_system.dat"
return path
def IsolateLayers():
"""Isolate layers by hiding layers."""
file_name = rs.DocumentName()
file_path = rs.DocumentPath()
# Select objects
input_obj = rs.SelectedObjects()
if not input_obj:
input_obj = rs.GetObjects("Select objects on layers to isolate")
if not input_obj: return
# Get all layers names
proj_layers = rs.LayerNames()
layers_history = {rs.LayerId(l): rs.LayerVisible(l) for l in proj_layers}
# Save temp
if file_name is None:
temp_file_name = "IsolateLayers_temp.json"
else:
temp_file_name = file_path + 'IsolateLayers_temp_' + file_name.strip(
'.3dm') + '.json'
with open(temp_file_name, "w+") as f:
f.write(json.dumps(layers_history, sort_keys=True, indent=4))
# Get objects layers
obj_layers = [rs.ObjectLayer(o) for o in input_obj]
layers = []
for l in obj_layers:
s = l.split('::')
a = 0
while len(s) > a:
layers.append("::".join(s[:a + 1]))
a += 1
# Set current layer
rs.CurrentLayer(layers[0])
# Hide layers
layers_to_hide = list(set(proj_layers) - set(layers))
for l in layers_to_hide:
rs.LayerVisible(l, False)
def make_file(self):
path = rs.DocumentPath()
i = path.rfind("\\")
path = path[:i]
f = open(path + "\system.dat", "w")
f.write(self.export())
f.close()
f = open(path + "\glass_load.dat", "w")
f.write(self.output_glass_load)
f.close()
def ExportSTLWithSettings(objs):
rs.SelectObjects(objs)
strCurrDP = rs.DocumentPath()
strCurrDN = rs.DocumentName()
filt = "STL Files (*.stl)|*stl||"
if strCurrDN:
strSaveDN = strCurrDN[:-3] + "stl"
strFileName = rs.SaveFileName("Export STL", filt, strCurrDP, strSaveDN)
else:
strFileName = rs.SaveFileName("Export STL", filt)
strSett = STLSettings()
if not strSett:
print("Unable to get export settings")
print("exporting" + strFileName)
rs.Command("-_Export" + " \"" + strFileName + "\"" + " " + strSett, True)
def ExportNamedViews():
'''
Extract view coordinates and write to JSON
Example:
* Open original .3dm file
* RunPythonScript `ExportNamedViews()`
* Create a New .3dm file
* RunPythonScript `ImportNamedViews()`
'''
log = open('./views.json', 'a')
fname = rs.DocumentPath() + rs.DocumentName()
data = {}
data[fname] = {}
for view in rs.NamedViews():
rs.RestoreNamedView(view)
data[fname][view] = (list(rs.ViewCamera()), list(rs.ViewTarget()))
log.write(json.dumps(data, indent=2) + '\n')
log.close()
return data
def dimensionPline_Button():
objects = rs.GetObjects("Select Curves to Dimension", filter = 4, preselect = True)
if objects is None:return
if 'dimPline-dist' in sc.sticky:
distDefault = sc.sticky['dimPline-dist']
else:
distDefault = 60
offsetDist = rs.GetInteger('Dimension offset distance (in.)', distDefault)
if offsetDist is None: return
sc.sticky['dimPline-dist'] = offsetDist
#Load Anno style if it doesnt exist already
if sc.doc.DimStyles.FindName('PCPA_12') is None:
standards.LoadStyles()
try:
layers.AddLayerByNumber(8101)
layerName = layers.GetLayerNameByNumber(8101)
rs.CurrentLayer(layerName)
except:
pass
rs.EnableRedraw(False)
for obj in objects:
if rs.IsCurve(obj):
try:
group, rc = dimensionPline(obj, offsetDist)
utils.SaveFunctionData('Drawing-Dim Pline', [rs.DocumentPath(), rs.DocumentName(), rs.ObjectLayer(obj), rs.CurrentDimStyle(), offsetDist, rc])
except:
print "Unknown Error"
else:
print "Not a polyline"
rs.EnableRedraw(True)
def upload_code_button(self,sender,e):
if self.code_thread:
rs.MessageBox(TXT["error_wait"],0)
return
if not self.spkmodel_objects:
rs.MessageBox(TXT["error_generate"],0)
return
if not self.user_data["name_url"]:
rs.MessageBox(TXT["error_input"],0)
return
self.add_line(TXT["uploading"])
save_file = self.user_data["save_file"]
if save_file:
save_path = rs.SaveFileName(TXT["save_file"],None, rs.DocumentPath() if not self.user_data["save_path"] else self.user_data["save_path"] ,"%s_gcode" % self.user_data["name_url"] if "www" not in self.user_data["name_url"] else "", ".txt")
if not save_path:
return
else:
save_path = TEMP_GCODE_FILE
self.user_data["save_path"] = save_path
thread.start_new_thread(self.upload_thread,(False,False,self.save_image()))
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"]
__author__ = 'Tim Williams'
__version__ = "2.1.0"
def OpenFolder(path):
try:
subprocess.call("explorer " + path, shell=True)
return True
except:
return False
if __name__ == "__main__":
func = rs.GetInteger("Func number")
fileLocations = config.GetDict()
if func == 0:
OpenFolder(fileLocations['PCPA GH Components'])
if func == 1:
OpenFolder(fileLocations['GH Dependencies'])
if func == 2:
OpenFolder(fileLocations['Template Folder'])
if func == 3:
OpenFolder(fileLocations['Display Mode Folder'])
if func == 4:
OpenFolder(fileLocations['ACAD Scheme Folder'])
if func == 5:
OpenFolder(rs.DocumentPath())
if func == 6:
OpenFolder(fileLocations['3d Blocks'])
eStr+= "_MaxEdgeLength=0 "
eStr+= "_MinEdgeLength=0.0001 "
eStr+= "_Enter _Enter"
return eStr
settingsList = {
'GetDAESettings': GetDAESettings,
'GetOBJSettings': GetOBJSettings,
'GetSTLSettings': GetSTLSettings
}
fileName = rs.DocumentName()
filePath = rs.DocumentPath().rstrip(fileName)
arrLayers = layerNames(False)
def initExportByLayer(fileType="obj", visibleonly=False, byObject=False):
for layerName in arrLayers:
layer = scriptcontext.doc.Layers.FindByFullPath(layerName, True)
if layer >= 0:
layer = scriptcontext.doc.Layers[layer]
save = True;
if visibleonly:
if not layer.IsVisible:
save = False
if rs.IsLayerEmpty(layerName):
def get_document_path():
return rs.DocumentPath()
def __init__(self,generalSettings,machiningSettings,userData):
# Make a new form (dialog)
self.rhino_objects = None
self.sorted_objects = None
self.time = 0
self.code_thread = False
self.login_thread = False
self.terminal_lines = ["","",""]
self.spkmodel_objects = None
self.general_settings = {"sec_plane":6,"feed_rapid":3000,"cut_diam":6} if not generalSettings else generalSettings
self.machining_settings = {} if not machiningSettings else machiningSettings
self.user_data = {"technical_name":False,"save_file":False,"spkcam_session_token":False,"material_info":False,"sort_closest":False,"user_data":False,"sorting":True,"name_url":False,"autocluster":True,"index_pause":False,"user_mail":False,"save_path":rs.DocumentPath().replace(".3dm","_gcode.txt") if rs.DocumentPath() else False,"selected_preset":False} if not userData else userData
if not self.user_data["technical_name"]: self.user_data["technical_name"]= rs.DocumentName().replace(".3dm","_gcode")
if not self.user_data["name_url"]:self.user_data["name_url"] = rs.DocumentName().replace(".3dm","")
try:
token = um.get_login_token()
self.user_data["spkcam_session_token"] = token
self.user_data["user_mail"] = um.get_user()
except:
self.user_data["spkcam_session_token"] = False
self.user_data["user_mail"] = False
self.form = Meier_UI_Utility.UIForm("SPKCAM:.")
self.addControls()
self.form.layoutControls()
self.print_initial_state()
Exercise 01
Importing GeoData.
"""
import rhinoscriptsyntax as rs
import math
from os import listdir
from os.path import basename
import json
path = rs.DocumentPath()
name = rs.DocumentName()
root_path = path[:-len(name)]
geo_path = root_path + "geo/"
def draw_point(pt):
"""Draws point."""
rs.AddPoint([pt[0], pt[1], 0])
def draw_linestring(ls):
n = len(ls)
def file_name_button(self,sender,e):
save_path = rs.SaveFileName(TXT["save_file"],None, rs.DocumentPath() if not self.user_data["save_path"] else self.user_data["save_path"] ,"%s_gcode" % rs.DocumentName().replace(".3dm",""), ".txt")
if save_path:
self.add_line(save_path)
else:
pass
def exportToRenderDWG():
try:
fileLocations = config.GetDict()
print "Exporting to 3ds max"
objs = rs.GetObjects("Select objects to export", preselect=True)
if objs is None: return
#SAVE FILE NAME
defaultFolder = rs.DocumentPath()
defaultFilename = utils.GetDatePrefix() + '_OPTION_01'
fileName = rs.SaveFileName("Export to render", "Autocad (*.dwg)|*.dwg||", defaultFolder, defaultFilename)
if fileName is None: return
base=os.path.basename(fileName)
cadName = os.path.splitext(base)[0]
#SUPER EXPLODE
#EXPLODE SELECTED BLOCKS (CHECKLIST)
#blockNames = rs.BlockNames(True)
#print blockNames
#results = rs.CheckListBox(blockNames, "Select blocks to explode", "Explode for render")
#CHECK BACKFACES
#CHECK GEOMETRY
#EXPORT EACH LAYER AS SAT FILE.
#CHECK ORIGIN
#INSERT ORIGIN
#CHECK SCALE (Units)
if rs.UnitSystem() == 8:
print "Units checked"
else:
print "This model is in {}, it should be in Inches".format(rs.UnitSystemName(singular=False))
#UNIFY MESH NORMALS
#MERGE ALL EDGES
#MERGE ALL FACES
#DELETE DUPS
#rs.UnselectAllObjects()
#rs.Command('-_Seldup ', echo=False)
#dupObjs = rs.SelectedObjects()
#if len(dupObjs) > 0:
# rs.DeleteObjects(dupObjs)
# print "{} duplicate objects deleted".format(len(dupObjs))
#JOIN BY LAYER
#PLACE UNDER A PARENT LAYER W/ DATESTAMP
AddMasterRootLayer(cadName)
#CHANGE LAYER NAMES?
#IMPORT ACAD SCHEME
standards.LoadAcadSchemes(fileLocations['ACAD Scheme Folder'])
#SET DEFAULT FOLDER TO REFERENCE FOLDER UNDER RENDERING
#EXPORT TO DWG
rs.SelectObjects(objs)
exportScheme = 'PCPA_MaxSolids'
rs.Command('-_Export ' + '"' + fileName + '" S ' + '"' + exportScheme + '"' + ' Enter P 100 Enter', False)
#REMOVE MASTER ROOT LAYER
RemoveMasterRootLayer(cadName)
return True
except:
return False
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
