def innerPanel():
objs = rs.GetObjects("Select objects to add frame to", filter = 24, group = True,preselect = True)
if objs is None:
return
dist = rs.GetReal("Offset Distance")
if dist is None:
return
rs.EnableRedraw(False)
srfs = []
for obj in objs:
if rs.IsPolysurface(obj):
srfs = srfs + rs.ExplodePolysurfaces(obj)
else:
srfs.append(rs.CopyObject(obj))
for srf in srfs:
if rs.IsSurfacePlanar(srf):
edgeCrvs = rs.DuplicateEdgeCurves(srf)
border = rs.JoinCurves(edgeCrvs, True)
innerEdge = rs.OffsetCurveOnSurface(border, srf, dist)
#rs.SplitBrep(srf, innerEdge)
rs.AddPlanarSrf(innerEdge)
rs.DeleteObject(innerEdge)
rs.DeleteObject(border)
else:
print "A surface was not planar"
rs.DeleteObjects(srfs)
rs.EnableRedraw(True)
def curvature(self, points=None):
""""""
if not points:
points = self.heightfield()
curvature = []
if rs.IsPolysurface(self.guid):
rs.EnableRedraw(False)
faces = {}
for point in points:
bcp = rs.BrepClosestPoint(self.guid, point)
uv = bcp[1]
index = bcp[2][1]
try:
face = faces[index]
except (TypeError, IndexError):
face = rs.ExtractSurface(self.guid, index, True)
faces[index] = face
props = rs.SurfaceCurvature(face, uv)
curvature.append((point, (props[1], props[3], props[5])))
rs.DeleteObjects(faces.values())
rs.EnableRedraw(False)
elif rs.IsSurface(self.guid):
for point in points:
bcp = rs.BrepClosestPoint(self.guid, point)
uv = bcp[1]
props = rs.SurfaceCurvature(self.guid, uv)
curvature.append((point, (props[1], props[3], props[5])))
else:
raise RhinoSurfaceError('object is not a surface')
return curvature
def setObjAreaValue(obj):
if rs.IsSurface(obj):
setSrfAreaValue(obj)
elif rs.IsPolysurface(obj) and rs.IsPolysurfaceClosed(obj):
setBrepFA(obj)
else:
pass
def setObjAreaValue(obj):
if rs.IsSurface(obj):
setSrfAreaValue(obj)
elif rs.IsPolysurface(obj) and rs.IsPolysurfaceClosed(obj):
setBrepFA(obj)
else:
rs.SetUserText(obj, "area", 'na')
def shape_from_ref(r):
with parameter(immediate_mode, False):
obj = _geometry_from_id(r)
ref = native_ref(r)
if isinstance(obj, geo.Point):
return point.new_ref(ref, fromPt(obj.Location))
elif isinstance(obj, geo.Curve):
if rh.IsLine(r) or rh.IsPolyline(r):
if rh.IsCurveClosed(r):
return polygon.new_ref(
ref, [fromPt(p) for p in rh.CurvePoints(r)[:-1]])
else:
return line.new_ref(ref,
[fromPt(p) for p in rh.CurvePoints(r)])
elif obj.IsCircle(Rhino.RhinoMath.ZeroTolerance):
return circle.new_ref(ref, fromPt(rh.CircleCenterPoint(r)),
rh.CircleRadius(r))
elif rh.IsCurveClosed(r):
return closed_spline.new_ref(
ref, [fromPt(p) for p in rh.CurvePoints(r)])
else:
return spline.new_ref(ref,
[fromPt(p) for p in rh.CurvePoints(r)])
elif rh.IsObject(r) and rh.IsObjectSolid(r):
return solid(native_ref(r))
elif rh.IsSurface(r) or rh.IsPolysurface(r):
return surface(native_ref(r))
else:
raise RuntimeError("{0}: Unknown Rhino object {1}".format(
'shape_from_ref', r))
def Cut(self, polysurface, holes):
for hole in holes:
new = rs.SplitBrep(polysurface, hole, True)
polysurface = next(x for x in new if rs.IsPolysurface(x))
for n in new:
if n is not polysurface:
rs.DeleteObject(n)
return rs.JoinSurfaces([polysurface] + holes, True)
def ColorBySize():
try:
objs = rs.GetObjects("Select objects to color",
1073815613,
preselect=True)
if objs is None: return
print "Select First Color"
firstColor = rs.GetColor()
if firstColor is None: return
print "Select Second Color"
secondColor = rs.GetColor(firstColor)
if secondColor is None: return
rs.EnableRedraw(False)
colorLine = rs.AddLine(firstColor, secondColor)
areas = []
for obj in objs:
if rs.IsCurve(obj):
if rs.IsCurveClosed(obj):
areas.append(rs.CurveArea(obj)[0])
else:
areas.append(rs.CurveLength(obj))
elif rs.IsSurface(obj):
areas.append(rs.SurfaceArea(obj)[0])
elif rs.IsPolysurface(obj):
if rs.IsPolysurfaceClosed(obj):
areas.append(rs.SurfaceVolume(obj)[0])
elif rs.IsHatch(obj):
areas.append(rs.Area(obj))
else:
print "Only curves, hatches, and surfaces supported"
return
newAreas = list(areas)
objAreas = zip(newAreas, objs)
objAreas.sort()
objSorted = [objs for newAreas, objs in objAreas]
areas.sort()
normalParams = utils.RemapList(areas, 0, 1)
colors = []
for t in normalParams:
param = rs.CurveParameter(colorLine, t)
colors.append(rs.EvaluateCurve(colorLine, param))
for i, obj in enumerate(objSorted):
rs.ObjectColor(obj, (colors[i].X, colors[i].Y, colors[i].Z))
rs.DeleteObject(colorLine)
rs.EnableRedraw(True)
return True
except:
return False
def revol(r):
if rh.IsCurve(r):
return native_ref(rh.AddRevSrf(r, axis, start, end))
elif rh.IsSurface(r) or rh.IsPolysurface(r):
out_refs = revolve_borders(r, axis, start, end, True)
in_refs = revolve_borders(r, axis, start, end, False)
return subtract_refs(single_ref_or_union(out_refs),
[native_ref(r) for r in in_refs], shape)
else:
raise RuntimeError("Can't revolve the shape")
def heightfield(self, density=10, over_space=True):
""""""
try:
du, dv = density
except TypeError:
du = density
dv = density
du = int(du)
dv = int(dv)
xyz = []
rs.EnableRedraw(False)
if rs.IsPolysurface(self.guid):
faces = rs.ExplodePolysurfaces(self.guid)
elif rs.IsSurface(self.guid):
faces = [self.guid]
else:
raise RhinoSurfaceError('object is not a surface')
if over_space:
for guid in faces:
face = RhinoSurface(guid)
uv = face.space(density)
for u, v in uv:
xyz.append(list(rs.EvaluateSurface(face.guid, u, v)))
else:
for guid in faces:
bbox = rs.BoundingBox(guid)
xmin = bbox[0][0]
xmax = bbox[1][0]
ymin = bbox[0][1]
ymax = bbox[3][1]
xstep = 1.0 * (xmax - xmin) / (du - 1)
ystep = 1.0 * (ymax - ymin) / (dv - 1)
seeds = []
for i in xrange(du):
for j in xrange(dv):
seed = xmin + i * xstep, ymin + j * ystep, 0
seeds.append(seed)
points = map(list,
rs.ProjectPointToSurface(seeds, guid, [0, 0, 1]))
xyz += points
if len(faces) > 1:
rs.DeleteObjects(faces)
rs.EnableRedraw(True)
return xyz
def wallBaseSrf(crv, width):
rs.SimplifyCurve(crv)
if rs.IsCurveClosed(crv):
domain = rs.CurveDomain(crv)
parameter = (domain[0] + domain[1]) / 2.0
rs.CurveSeam(crv, parameter)
offsets = map(lambda x: rs.OffsetCurve(crv, [0, 0, 0], x),
[width / 2, -width / 2])
section = rs.AddLoftSrf(offsets, loft_type=2)
if offsets: rs.DeleteObjects(offsets)
if rs.IsPolysurface(section):
return rs.ExplodePolysurfaces(section, delete_input=True)
return section
def setAdditiveObj(self):
#set object to be additived
#if selected obj isnt closed, return False
tmp = rs.GetObject("Select object which you want additive")
#adapt to unclosed polysurface
if rs.IsMesh(tmp):
self.addtiveObj = rs.MeshToNurb(tmp)
elif rs.IsPolysurface(tmp):
self.addtiveObj = tmp
else:
print("please select \"mesh\" or \"polysurface\"")
return True
def descent(self, points=None):
""""""
if not points:
points = self.heightfield()
tol = rs.UnitAbsoluteTolerance()
descent = []
if rs.IsPolysurface(self.guid):
rs.EnableRedraw(False)
faces = {}
for p0 in points:
p = p0[:]
p[2] -= 2 * tol
bcp = rs.BrepClosestPoint(self.guid, p)
uv = bcp[1]
index = bcp[2][1]
try:
face = faces[index]
except (TypeError, IndexError):
face = rs.ExtractSurface(self.guid, index, True)
faces[index] = face
p1 = rs.EvaluateSurface(face, uv[0], uv[1])
vector = [p1[_] - p0[_] for _ in range(3)]
descent.append((p0, vector))
rs.DeleteObjects(faces.values())
rs.EnableRedraw(True)
elif rs.IsSurface(self.guid):
for p0 in points:
p = p0[:]
p[2] -= 2 * tol
bcp = rs.BrepClosestPoint(self.guid, p)
uv = bcp[1]
p1 = rs.EvaluateSurface(self.guid, uv[0], uv[1])
vector = [p1[_] - p0[_] for _ in range(3)]
descent.append((p0, vector))
else:
raise RhinoSurfaceError('object is not a surface')
return descent
def setAdditiveObj(self):
'''
set object that is added
when pick object, it must be mesh or polysurface
if picked object is mesh, it will be converted to polysurface
'''
tmp = rs.GetObject("Pick a additive obj",
rs.filter.polysurface | rs.filter.mesh)
if rs.IsMesh(tmp):
self.additiveObj = rs.MeshToNurb(tmp)
elif rs.IsPolysurface(tmp):
self.additiveObj = tmp
else:
print("Please select \"mesh\" or \"polysurface\"")
return False
return True
def space(self, density=10):
""""""
try:
du, dv = density
except TypeError:
du = density
dv = density
density_u = int(du)
density_v = int(dv)
uv = []
rs.EnableRedraw(False)
if rs.IsPolysurface(self.guid):
faces = rs.ExplodePolysurfaces(self.guid)
elif rs.IsSurface(self.guid):
faces = [self.guid]
else:
raise Exception('Object is not a surface.')
for face in faces:
domain_u = rs.SurfaceDomain(face, 0)
domain_v = rs.SurfaceDomain(face, 1)
du = (domain_u[1] - domain_u[0]) / (density_u - 1)
dv = (domain_v[1] - domain_v[0]) / (density_v - 1)
for i in range(density_u):
for j in range(density_v):
uv.append((domain_u[0] + i * du, domain_v[0] + j * dv))
if len(faces) > 1:
rs.DeleteObjects(faces)
rs.EnableRedraw(True)
return uv
def makeWall(crvs, width):
rs.EnableRedraw(False)
breps = []
shapes = []
for crv in crvs:
rs.SimplifyCurve(crv)
shape = offsetBothCrvs(crv, width)
if rs.IsPolysurface(shape):
surfs = rs.ExplodePolysurfaces(shape)
for surf in surfs:
shapes.append(surf)
if shape: rs.DeleteObjects(shape)
else:
shapes.append(shape)
for shape in shapes:
railCurve = addRail(shape)
breps.append(rs.ExtrudeSurface(shape, railCurve))
if railCurve: rs.DeleteObjects(railCurve)
if shapes: rs.DeleteObjects(shapes)
rs.EnableRedraw(False)
return breps
def setBrepHeight(obj):
if rs.IsPolysurface(obj) and rs.IsPolysurfaceClosed(obj):
height = brepGetZ(obj)
height = height[2]
rs.SetUserText(obj, "height", str(height))
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
# !-RunPythonScript "objectBottomFaceArea.py"
# rs.EnableRedraw(False)
faces = []
bndry = []
obj = rs.GetObject("Select polysurface to explode",
rs.filter.polysurface,
preselect=True)
if rs.IsPolysurface(obj):
faces = rs.ExplodePolysurfaces(obj)
for face in faces:
if rs.IsSurface(face):
domainU = rs.SurfaceDomain(face, 0)
domainV = rs.SurfaceDomain(face, 1)
u = domainU[1] / 2.0
v = domainV[1] / 2.0
point = rs.EvaluateSurface(face, u, v)
param = rs.SurfaceClosestPoint(face, point)
normal = rs.SurfaceNormal(face, param)
# print normal
if normal.Z == -1:
bndry.append(face)
for bnd in bndry:
area = rs.SurfaceArea(bnd)[0]
areapy = area / 3.3058
print area, areapy
txt = rs.ClipboardText(area)
