def setObjZPair(obj):
if rs.IsBlockInstance(obj):
# pt = rs.CreatePoint(obj)
return [obj, round(objBBPts(obj)[0].Z, 3)]
elif rs.IsCurve(obj):
return crvPtZpair(obj)
elif rs.IsPolysurfaceClosed(obj):
return brepPtZPair(obj)
elif rs.IsSurface(obj):
return srfPtZPair(obj)
elif rs.IsPoint(obj):
pt = rs.CreatePoint(obj)
return [obj, round(pt.Z, 3)]
# elif rs.IsBlockInstance(obj):
# # pt = rs.CreatePoint(obj)
# return [obj, round(objBBPts(obj)[0].Z, 3)]
else:
pass
def main():
print 'test'
objs = rs.GetObjects()
vec_x = [10,0,0]
# restore viewport Cplane
p1 = rs.WorldXYPlane()
rs.ViewCPlane(None, p1)
for obj in objs:
if rs.IsBlockInstance(obj) and rs.BlockInstanceName(strObject):
xform1 = rs.BlockInstanceXform(obj)
crv = rs.AddCurve([ [0,0,0], [0,300,0] ])
xfrom1_inv = rs.TransformObject( crv, (xform1) )
rs.SelectObject(crv)
vec1 = rs.CurveEndPoint(crv) - rs.CurveStartPoint(crv)
print vec1, math.degrees(calcAngle(vec1, vec_x))
if __name__ == "__main__":
main();
def explode(objs, li):
for obj in objs:
if rs.IsBlockInstance(obj):
temp_objs = rs.ExplodeBlockInstance(obj)
explode(temp_objs, li)
else:
li.append(obj)
return li
def splitModel(objs, cutLevel):
point = Rhino.Geometry.Point3d(0,0,cutLevel)
belowDir = rs.AddLine(point, [0,0,-9999])
aboveDir = rs.AddLine(point, [0,0,9999])
circle = rs.AddCircle(point, 9999)
circleSrf = rs.AddPlanarSrf(circle)
aboveGroup = rs.AddGroup("Above")
belowGroup = rs.AddGroup("Below")
for obj in objs:
ptBtm = rs.BoundingBox(obj)[0]
ptTop = rs.BoundingBox(obj)[6]
if ptBtm[2]>cutLevel:
intersecting = False
rs.AddObjectToGroup(obj, "Above")
#print "Object Above"
elif ptTop[2]<cutLevel:
intersecting = False
rs.AddObjectToGroup(obj, "Below")
#print "Object Below"
else:
intersecting = True
if intersecting:
if rs.IsBrep(obj):
closed = False
if rs.IsPolysurfaceClosed(obj):
closed = True
try:
copy = rs.CopyObject(obj)
splitSrfs = rs.SplitBrep(obj, circleSrf, True)
for splitSrf in splitSrfs:
#print "looping"
if closed:
rs.CapPlanarHoles(splitSrf)
rs.MatchObjectAttributes(splitSrf, copy)
ptBtm = rs.BoundingBox(splitSrf)[0]
ptTop = rs.BoundingBox(splitSrf)[6]
mdPtZ = (ptBtm[2] + ptTop[2]) / 2
if mdPtZ>cutLevel:
rs.AddObjectToGroup(splitSrf, "Above")
else:
rs.AddObjectToGroup(splitSrf, "Below")
rs.DeleteObject(copy)
rs.DeleteObject(obj)
except:
None
if rs.IsBlockInstance(obj):
contents = rs.ExplodeBlockInstance(obj)
for content in contents:
objs.append(content)
rs.DeleteObject(belowDir)
rs.DeleteObject(aboveDir)
rs.DeleteObject(circle)
rs.DeleteObject(circleSrf)
def IntersectGeo(obj, level):
tolerance = rs.UnitAbsoluteTolerance()
plane = rc.Geometry.Plane(rs.coerce3dpoint((0, 0, level)),
rs.coerce3dvector((0, 0, 1)))
finalCurves = []
#BLOCKS
if rs.IsBlockInstance(obj):
matrix = rs.BlockInstanceXform(obj)
blockObjs = rs.BlockObjects(rs.BlockInstanceName(obj))
for eachBlockObj in blockObjs:
newCopy = rs.CopyObject(eachBlockObj)
xformedObj = rs.TransformObject(newCopy, matrix)
#EXTRUSIONS
if isinstance(xformedObj, rc.Geometry.Extrusion):
temp = sc.doc.Objects.AddBrep(xformedObj.ToBrep(False))
xformedObj = rs.coercebrep(temp)
rs.DeleteObject(temp)
#BREPS IN BLOCK
result = IntersectBrepPlane(xformedObj, plane)
if result is None: continue
for each in result:
if each is not None:
finalCurves.append(each)
rs.DeleteObject(xformedObj)
#MESHES IN BLOCK <---This code might not be necessary
result = IntersectMeshPlane(xformedObj, plane)
if result is None: continue
for each in result:
if each is not None:
finalCurves.append(each)
rs.DeleteObject(xformedObj)
#BREPS
elif rs.IsBrep(obj):
result = IntersectBrepPlane(obj, plane)
if result is None: return None
for each in result:
if each is not None:
finalCurves.append(each)
#MESHES
elif rs.IsMesh(obj):
result = IntersectMeshPlane(obj, plane)
if result is None: return None
for each in result:
if each is not None:
finalCurves.append(each)
return finalCurves
def _get_guids_from_shape_name(self, shape_name): ## 05-10 06:47
"""Receives:
shape_name the name of a shape in a rule; type and value
guaranteed by the calling function
Returns:
[guid, ...] a list of the guids (lines and text objects) in
the shape, i.e., excluding the frame
"""
guids = rs.ObjectsByLayer(shape_name)
shape_guids = []
for guid in guids:
if not rs.IsBlockInstance(guid):
shape_guids.append(guid)
return shape_guids
def explode(objs, li):
for obj in objs:
if rs.IsBlockInstance(obj):
# DIRTY FIX FOR RHINO 5-SR14 522.8390 (5-22-2017)
# temp_objs = rs.ExplodeBlockInstance(obj)
rs.UnselectAllObjects()
rs.SelectObject(obj)
rs.Command("Explode" , False)
temp_objs = rs.LastCreatedObjects()
explode(temp_objs, li)
else:
li.append(obj)
return li
def bbsolid(obj):
if rs.IsBlockInstance(obj):
arrMatrix = rs.BlockInstanceXform(obj)
if arrMatrix is not None:
# pointId = rs.AddPoint([0,0,0])
plane = rs.PlaneTransform(rs.WorldXYPlane(), arrMatrix)
box = rs.BoundingBox(obj, plane)
bb = rs.AddBox(box)
# if box:
# for i, point in enumerate(box):
# rs.AddTextDot( i, point )
xformscale = rs.XformScale((1.0, 20.0, 1.0))
cob = rs.XformChangeBasis(rs.WorldXYPlane(), plane)
cob_inverse = rs.XformChangeBasis(plane, rs.WorldXYPlane())
temp = rs.XformMultiply(xformscale, cob)
xform = rs.XformMultiply(cob_inverse, temp)
rs.TransformObjects(bb, xform)
return bb
def GetAllBlockObjectsInPosition(obj):
"""Recursively get all objects from a block (and blocks in blocks)
inputs:
obj (block instance)
returns:
objs (list guids): Geometry is a copy of the instance geometry
"""
blockObjs = rs.BlockObjects(rs.BlockInstanceName(obj))
xform = rs.BlockInstanceXform(obj)
objList = []
for eachblockObj in blockObjs:
if rs.IsBlockInstance(eachblockObj):
thisBlockObjects = GetAllBlockObjectsInPosition(eachblockObj)
for eachObject in thisBlockObjects:
transformedObj = rs.TransformObject(eachObject, xform, False)
objList.append(transformedObj)
else:
transformedObj = rs.TransformObject(eachblockObj, xform, True)
objList.append(transformedObj)
return objList
def IntersectGeoAtPt():
try:
objs = rs.GetObjects("Select objects to contour",
1073745980,
preselect=True)
if objs is None: return
geos = []
while True:
pt = rs.GetPoint("Select point to contour at")
if pt is None: break
rs.EnableRedraw(False)
for obj in objs:
if rs.IsBlockInstance(obj):
blocksObjects = utils.GetAllBlockObjectsInPosition(obj)
for eachBlocksObject in blocksObjects:
result = IntersectGeo(eachBlocksObject, pt.Z)
if result is None:
rs.DeleteObject(eachBlocksObject)
continue
for each in result:
if each is not None:
geos.append(each)
rs.DeleteObject(eachBlocksObject)
else:
result = IntersectGeo(obj, pt.Z)
if result is None: continue
for each in result:
if each is not None:
geos.append(each)
rs.EnableRedraw(True)
rs.SelectObjects(geos)
result = True
except:
result = False
utils.SaveFunctionData('Geometry-Contour At Pt',
[__version__, len(objs), result])
return result
def blkFace(obj):
cameraPos = rs.ViewCamera()
cameraPos.Z = 0
plane = rs.WorldXYPlane()
if rs.IsBlockInstance(obj):
plane = blkPlane(obj)
elif rs.IsSurface(obj):
plane = srfPlane(obj)
targetpos = plane.Origin
targetpos.Z = 0
viewdir = rs.VectorUnitize(cameraPos - targetpos)
angle = rs.VectorAngle(viewdir, plane.YAxis)
newXform = rs.XformRotation3(plane.YAxis, viewdir, plane.Origin)
rs.TransformObject(obj, newXform)
def main():
# get objects to export
objs = rs.GetObjects("select objects to Make3d", 0, True, True)
if not objs: print "make3d aborted"; return
# default_thickness = rs.GetDocumentData('TNM_make3d', 'material_thickness')
# if default_thickness:
# default_thickness = float( default_thickness )
# else:
# default_thickness = 18
material_thickness = rs.GetReal("Material Thickness", number=18.3)
# rs.SetDocumentData('TNM_make3d', 'material_thickness', str( material_thickness ) )
rs.EnableRedraw(False)
checkPos(objs)
set_volumes = []
set_subtracts = []
for obj in objs:
if rs.IsBlockInstance(obj):
# get content
copy = rs.CopyObject(obj)
content = ce.explodeBlock( [copy] )
# filter objects to only curves and points
copies = filterObjects(content)
simplify(copies)
result, subtracts = convertLayers(copies, material_thickness)
set_volumes.append(result)
set_subtracts.append(subtracts)
rs.DeleteObjects(copies)
# addResultToBlock(obj, result)
else:
# add warning message collision check
print obj
rs.UnselectAllObjects()
intersect = None
for i, volume in enumerate(set_volumes):
for j, subtracts in enumerate(set_subtracts):
if(i != j):
print rs.ObjectLayer(volume)
intersect = rs.BooleanIntersection(rs.CopyObject(volume), subtracts, False)
if intersect:
rs.SelectObjects(intersect)
rs.DeleteObjects(subtracts)
if intersect:
rs.MessageBox("ERROR")
redraw()
def CutModel(objs, srf):
try:
if rs.ObjectType(srf) == 1073741824:
extrusionSurface = rs.coercesurface(srf)
rhSrf = extrusionSurface.ToBrep().Faces[0]
else:
rhSrf = rs.coercesurface(srf)
plane = rhSrf.TryGetPlane()[1]
if rhSrf.OrientationIsReversed:
plane.Flip()
groupMain = rs.AddGroup('MainObjects')
groupCut = rs.AddGroup('SectionSurfaces')
groupVisible = rs.AddGroup('VisibleObjects')
rs.HideObject(objs)
for obj in objs:
#BLOCKS
if rs.IsBlockInstance(obj):
blockObjs = utils.GetAllBlockObjectsInPosition(obj)
for eachBlockObj in blockObjs:
rhobj = rs.coercegeometry(eachBlockObj)
splitResults = CutObjectWithPlane(rhobj, plane)
if splitResults[0] is not None:
for eachObj in splitResults[0]:
utils.SafeMatchObjectAttributes(
eachObj, eachBlockObj)
#rs.MatchObjectAttributes(eachObj, eachBlockObj)
rs.ShowObject(eachObj)
rs.AddObjectToGroup(eachObj, groupMain)
for eachObj in splitResults[1]:
utils.SafeMatchObjectAttributes(
eachObj, eachBlockObj)
#rs.MatchObjectAttributes(eachObj, eachBlockObj)
rs.ShowObject(eachObj)
rs.AddObjectToGroup(eachObj, groupMain)
for eachObj in splitResults[3]:
rs.ObjectColor(eachObj, (255, 0, 0))
rs.ObjectName(eachObj, 'Section Cut Surface')
rs.AddObjectToGroup(eachObj, groupCut)
rs.DeleteObject(eachBlockObj)
#GEOMETRY
else:
rhobj = rs.coercegeometry(obj)
splitResults = CutObjectWithPlane(rhobj, plane)
if splitResults[0] is not None:
for eachObj in splitResults[0]:
utils.SafeMatchObjectAttributes(eachObj, eachBlockObj)
#rs.MatchObjectAttributes(eachObj, obj)
rs.ShowObject(eachObj)
rs.AddObjectToGroup(eachObj, groupMain)
for eachObj in splitResults[1]:
utils.SafeMatchObjectAttributes(eachObj, eachBlockObj)
#rs.MatchObjectAttributes(eachObj, obj)
rs.ShowObject(eachObj)
rs.AddObjectToGroup(eachObj, groupMain)
for eachObj in splitResults[3]:
rs.ObjectColor(eachObj, (255, 0, 0))
rs.ObjectName(eachObj, 'Section Cut Surface')
rs.AddObjectToGroup(eachObj, groupCut)
return True
except:
print "Cut Model failed"
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
def main():
# get objects to export
objs = rs.GetObjects("select objects to Make3d", 0, True, True)
if not objs: print "make3d aborted"; return
defaults = {
'material_thickness':18
}
defaults = getDefaultValues(defaults, 'TNM_make3d')
material_thickness = rs.GetReal("Material Thickness", number=defaults['material_thickness'])
storeDefaultValues('TNM_make3d', {'material_thickness':material_thickness} )
rs.EnableRedraw(False)
checkPos(objs)
set_volumes = []
set_subtracts = []
fail_objects =[]
for obj in objs:
if rs.IsBlockInstance(obj):
# get content
copy = rs.CopyObject(obj)
content = ce.explodeBlock( [copy] )
# filter objects to only curves and points
copies = ce.filterObjects(content)
copies = ce.joinCurves(copies)
# copies = ce.joinCurves(copies)
ce.simplify(copies)
volumes, subtracts = convertToVolumes(copies, material_thickness)
parts = volumes
for subtract in subtracts:
if rs.IsPolysurface(parts[0]) and rs.IsPolysurface(subtract) and rs.IsPolysurfaceClosed(parts[0]) and rs.IsPolysurfaceClosed(subtract):
# print parts
# print subtract
temp_parts = rs.BooleanDifference(parts, [subtract], False)
if temp_parts:
print 'subtract success'
rs.DeleteObjects(parts)
rs.DeleteObject(subtract)
parts = temp_parts
else:
print 'boolean differce failed on: %s' % subtract
fail_objects.append(subtract)
else:
print 'boolean differce failed on: %s' % subtract
fail_objects.append(subtract)
# addResultToBlock(obj, result)
else:
# add warning message collision check
print obj
rs.UnselectAllObjects()
rs.SelectObjects(fail_objects)
intersect = None
# for i, volume in enumerate(set_volumes):
# for j, subtracts in enumerate(set_subtracts):
# if(i != j):
# print rs.ObjectLayer(volume)
# intersect = rs.BooleanIntersection(rs.CopyObject(volume), subtracts, False)
# if intersect:
# rs.SelectObjects(intersect)
# rs.DeleteObjects(subtracts)
if intersect:
rs.MessageBox("ERROR")
rs.DeleteObjects(copies)
ce.redraw()
import rhinoscriptsyntax as rs
crvIds = rs.GetObjects("Pick curves", rs.filter.curve)
ptIds = rs.GetObjects("Pick points", rs.filter.point)
blockId = rs.GetObject("Pick Block", rs.filter.instance)
if rs.IsBlockInstance(blockId):
block_name = rs.BlockInstanceName(blockId)
for crv in crvIds:
for pt in ptIds:
if rs.IsPointOnCurve(crv, pt):
param = rs.CurveClosestPoint(crv, pt)
tangent = rs.CurveTangent(crv, param)
tangent = rs.VectorUnitize(tangent)
normal = rs.WorldXYPlane().ZAxis
# normal = rs.VectorUnitize(normal)
plane = rs.PlaneFromNormal(pt, normal, tangent)
# plane = rs.CurvePerpFrame(crv, param)
xform = rs.XformChangeBasis(plane, rs.WorldXYPlane())
rs.InsertBlock2(block_name, xform)
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