def DelOffScreen():
try:
obj = rs.GetObjects('Select objects to test', preselect=True)
bool = rs.GetBoolean('Delete or Hide', ('Option', 'Delete', 'Hide'),
(False))
if obj:
rs.EnableRedraw(False)
for i in obj:
isVisible = rs.IsVisibleInView(i)
if isVisible == False:
if bool[0] == True:
rs.HideObject(i)
if bool[0] == False:
rs.DeleteObject(i)
rs.EnableRedraw(True)
except:
print("Failed to execute")
rs.EnableRedraw(True)
return
def mesh_to_mesh(rhino_mesh,trg_len,vis):
print rhino_mesh
crvs = rs.DuplicateMeshBorder(rhino_mesh)
vertices = [map(float, vertex) for vertex in rs.MeshVertices(rhino_mesh)]
faces = map(list, rs.MeshFaceVertices(rhino_mesh))
mesh = Mesh.from_vertices_and_faces(vertices, faces)
pts_objs = rs.GetObjects("Fixed Points",1)
rs.EnableRedraw(False)
if pts_objs:
pts_fixed = [rs.PointCoordinates(obj) for obj in pts_objs]
pts = []
index_key = {}
count = 0
for k, a in mesh.vertices_iter(True):
pts.append((a['x'], a['y'], a['z']))
index_key[count] = k
count += 1
fixed = []
for pt_fix in pts_fixed:
index = rs.PointArrayClosestPoint(pts,pt_fix)
fixed.append(index_key[index])
edge_lengths = []
for u, v in mesh.edges():
edge_lengths.append(mesh.edge_length(u, v))
target_start = max(edge_lengths)/2
id = rs.coerceguid(rhino_mesh, True)
mesh_rhino_obj = rs.coercemesh(id, False)
boundary = set(mesh.vertices_on_boundary())
user_func = wrapper_2(crvs,mesh_rhino_obj,fixed,boundary,vis)
rs.HideObject(rhino_mesh)
remesh(mesh,trg_len,
tol=0.1, divergence=0.01, kmax=400,
target_start=target_start, kmax_approach=200,
verbose=False, allow_boundary=True,
ufunc=user_func)
rs.DeleteObject(rhino_mesh)
return draw_light(mesh,temp = False)
def generate_part_images(structure):
global view_aspect
w_l = conf['part_img_width']
h_l = int(w_l / view_aspect)
for iSub in xrange(len(structure)):
subsystem = structure.keys()[iSub]
v = structure[subsystem]
utils.show_only(subsystem)
utils.hide_children(subsystem)
for iStep in xrange(len(v)):
step = v.keys()[iStep]
vv = v[step]
stepnumeral = str(iSub + 1) + '.' + str(iStep + 1)
rs.LayerVisible(step, True)
for partkind, vvv in vv.items():
rs.HideObjects(vvv)
for partkind, vvv in vv.items():
if len(vvv) >= 1:
part = vvv[0]
rs.ShowObject(part)
# create images
rs.RestoreNamedView(conf['persp_view'])
rs.ZoomExtents()
create_view_image(
conf['part_img_persp'] % (stepnumeral, partkind), w_l,
h_l)
rs.RestoreNamedView(conf['top_view'])
rs.ZoomExtents()
create_view_image(
conf['part_img_top'] % (stepnumeral, partkind), w_l,
h_l)
rs.RestoreNamedView(conf['front_view'])
rs.ZoomExtents()
create_view_image(
conf['part_img_front'] % (stepnumeral, partkind), w_l,
h_l)
rs.RestoreNamedView(conf['right_view'])
rs.ZoomExtents()
create_view_image(
conf['part_img_right'] % (stepnumeral, partkind), w_l,
h_l)
#
rs.HideObject(part)
for partkind, vvv in vv.items():
rs.ShowObject(vvv)
rs.LayerVisible(step, False)
# utils.show_children(subsystem)
utils.show_step_children(subsystem)
utils.show_blocks()
utils.show_subsystems()
rs.ZoomExtents()
def main():
to_delete = []
rs.ProjectOsnaps(False)
positive_object = rs.GetObject("select positive object", 16)
negative_object = rs.GetObject("select negative object", 16)
rs.HideObject(negative_object)
polysurface, face = GetSubSurface("select tenon surface")
to_delete.append(face)
normal = rs.VectorUnitize(rs.SurfaceNormal(face, (0.5, 0.5)))
plane = rs.PlaneFromNormal(rs.EvaluateSurface(face, 0.5, 0.5), normal)
rs.ViewCPlane(plane=plane)
rs.ProjectOsnaps(True)
tenon_rects = rs.GetObjects(message="select tenon curves", filter=4)
tenon_faces = []
for rect in tenon_rects:
tenon_faces.append(rs.AddPlanarSrf(rect)[0])
rs.ShowObject(negative_object)
rs.ProjectOsnaps(False)
height_pt = rs.GetPoint("enter height point")
# compule a vector normal to plane of the desired height
extrude_vec_a = rs.EvaluateSurface(face, 0.5, 0.5)
dist = rs.DistanceToPlane(plane, height_pt)
extrude_vec_b = [dist * el for el in normal]
extrude_vec_b = rs.VectorAdd(extrude_vec_a, extrude_vec_b)
extrude_curve = rs.AddCurve((extrude_vec_a, extrude_vec_b))
to_delete.append(extrude_curve)
tenons = []
for tenon_face in tenon_faces:
tenon = rs.ExtrudeSurface(tenon_face, extrude_curve)
tenons.append(tenon)
rs.BooleanUnion([positive_object] + tenons, delete_input=False)
rs.BooleanDifference([negative_object], tenons, delete_input=False)
to_delete.append(positive_object)
to_delete.append(negative_object)
rs.DeleteObjects(to_delete)
rs.DeleteObjects(tenon_faces)
rs.DeleteObjects(tenons)
def getSurfaces():
surface = rs.ObjectsByType(8)
hidobj = rs.HiddenObjects()
if hidobj:
for obj in hidobj:
rs.ShowObject(obj)
outDic = {'mod': None, 'ref': None}
for srf in surface:
print rs.ObjectName(srf)
if rs.ObjectName(srf) == "ref":
#rs.HideObject(srf)
outDic['ref'] = srf
elif rs.ObjectName(srf) == "mod":
outDic['mod'] = srf
else:
rs.DeleteObject(srf)
for obj in hidobj:
rs.HideObject(obj)
return outDic
def init():
dicSur = getSurfaces()
print dicSur
if dicSur['mod']:
rs.DeleteObject(dicSur['mod'])
if dicSur['ref']:
surface = dicSur['ref']
else:
raise RuntimeError, "No surface"
vec = readTrfFyl()
points = rs.SurfacePoints(surface)
seldic = {k: points[k] for k in vec.keys()}
trTic = moveDic(seldic, vec)
srf = transformSrf(surface, trTic)
msrf = trimSurface(srf)
rs.HideObject(surface)
genOffFile()
rs.DeleteObject(msrf)
rs.ShowObject(surface)
def ScanCompair():
mesh = rs.GetObject("Select Scan Data:", 32)
if not mesh: return
block = rs.GetObject("Select Closed Polysurface to Compair:", 16)
if not block: return
if not rs.IsPolysurfaceClosed(block):
print "Polysurface is not closed"
return
ColorMesh(mesh, block)
rs.HideObject(block)
cmd = "-_SetDisplayMode "
cmd += "Viewport=Active "
cmd += "Mode=Shaded "
cmd += "_Enter "
rs.Command(cmd)
def main():
rs.AddLayer("laydown")
while True:
panel, face = getsubsurface.GetSubSurface("select down face")
if panel is None or face is None:
break
# compute the plane
normal = rs.VectorUnitize(rs.SurfaceNormal(face, (0.5,0.5)))
plane = rs.PlaneFromNormal(rs.EvaluateSurface(face, 0.5, 0.5), normal)
rs.ViewCPlane(plane=plane)
box = rs.BoundingBox(face, rs.ViewCPlane(), in_world_coords=True)
proj_coords = [rs.SurfaceClosestPoint(face, coord) + (0,) for coord in box]
laydown = rs.OrientObject(panel, box[0:3], proj_coords[0:3], flags=1)
rs.ObjectLayer(laydown, "laydown")
rs.DeleteObject(face)
rs.HideObject(panel)
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
import rhinoscriptsyntax as rs
import Rhino
import Rhino.Geometry as rg
doc = Rhino.RhinoDoc.ActiveDoc
#select and hide all line-like curves
curves = rs.GetObjects("select curves")
for curve in curves:
guid = curve
obj = doc.Objects.Find(guid)
geo = obj.Geometry
if geo.IsLinear():
rs.HideObject(curve)
#automate bringing tolerance down to .005 recursively through list
"""
#rs.RebuildCurve()
rebuilds = []
for curve in curves:
copy = rs.CopyObject(curve)
for i in range(4,30,1):
rs.RebuildCurve(curve, point_count=i)
rebuild_copy = rs.CopyObject(curve)
dev = rs.CurveDeviation(copy, curve)
print dev[1]
"""
from objects_to_mesh import mesh_to_mesh
import rhinoscriptsyntax as rs
if __name__ == '__main__':
rhino_mesh = rs.GetObject("Select Object",32)
rhino_mesh_dup = rs.CopyObject(rhino_mesh)
rs.HideObject(rhino_mesh_dup)
trg_len = rs.GetReal("Target Edges Length",0.3)
rs.MeshQuadsToTriangles(rhino_mesh)
rhino_mesh = mesh_to_mesh(rhino_mesh,trg_len,vis=5)
rs.SelectObject(rhino_mesh)
for i in range(3):
rs.Command("-Smooth Factor=1 CoordinateSystem=World X=Yes Y=Yes Z=Yes FixBoundaries=Yes ",False)
rs.ShowObject(rhino_mesh_dup)
#mesh_to_mesh(mesh,trg_len,vis=10)
#basic setup of variables
petalRadius = 10 #defines outer edge of flower
petalCount = 10 #number of petals
flowerCenter = (0,0,0) #define center point
petalPoints = [] #start list for point storage
petalCurveWidth = 1 #defines the amount of curve of the petal
petalCurveDistance = 1
outerCircle = rs.AddCircle(flowerCenter,petalRadius)
petalPoints = rs.DivideCurve(outerCircle,petalCount)
rs.AddPoints(petalPoints)
for i in range(0,petalCount):
#create petal center line
petalCenterLine = rs.AddLine(petalPoints[i], flowerCenter)
rs.HideObject(petalCenterLine)
#find midPoint of petal center line
petalCenterLineMidPoint = rs.CurveMidPoint(petalCenterLine)
rs.AddPoint(petalCenterLineMidPoint)
#draw vector
newVector = rs.RotateObject(rs.VectorScale(rs.VectorUnitize(rs.VectorCreate(petalPoints[i],petalCenterLineMidPoint)),petalCurveWidth),petalCenterLineMidPoint,90)
newPoint = rs.CopyObject(petalCenterLineMidPoint
#draw a line perpendicular to center line at the midpoint
#newLine = rs.AddLine(petalPoints[i],petalCenterLineMidPoint)
#rs.RotateObject(newLine,petalCenterLineMidPoint, 90)
#rs.HideObject(newLine)
#draw arc from center to edge through petal line point
#petalLinePoint = rs.CurveStartPoint(newLine)
#rs.AddArc3Pt(flowerCenter,petalPoints[i],petalLinePoint)
#rotate 180 and mirror on other side
#rs.RotateObject(newLine,petalCenterLineMidPoint, 180)
def hide(self):
"""Hide the Rhino object."""
return rs.HideObject(self.guid)
def hide(self):
return rs.HideObject(self.guid)
#variables
flowerRadius = 10
centerRadius = 2
petalCount = 15
flowerCenter = (0, 0, 0)
petalWidth = 4
petalCurves = []
outerCircle = rs.AddCircle(flowerCenter, flowerRadius)
points = rs.AddPoints(rs.DivideCurve(outerCircle, petalCount))
rs.HideObjects(points)
for i in range(len(points)):
centerLine = rs.AddLine(points[i], flowerCenter)
rs.HideObject(centerLine)
petalMidpoint = rs.AddPoint(rs.CurveMidPoint(centerLine))
rs.HideObjects(petalMidpoint)
vector = rs.VectorCreate(points[i], petalMidpoint)
vector = rs.VectorUnitize(vector)
vector = rs.VectorScale(vector, (petalWidth / 2))
vector = rs.VectorRotate(vector, 90, [0, 0, 1])
petalEdgePoint = rs.CopyObject(petalMidpoint)
petalEdgePoint = rs.MoveObject(petalEdgePoint, vector)
curve = rs.AddArc3Pt(flowerCenter, points[i], petalEdgePoint)
vector2 = rs.VectorRotate(vector, 180, [0, 0, 1])
petalEdgePoint2 = rs.CopyObject(petalMidpoint)
petalEdgePoint2 = rs.MoveObject(petalEdgePoint2, vector2)
curve2 = rs.AddArc3Pt(flowerCenter, points[i], petalEdgePoint2)
petalCurves.append(rs.JoinCurves([curve, curve2]))
from objects_to_mesh import nurbs_to_mesh_ani
import rhinoscriptsyntax as rs
if __name__ == '__main__':
poly_srf = rs.GetObjects("Select Objects", 8 + 16)
if poly_srf:
srfs_explo = rs.ExplodePolysurfaces(poly_srf)
if srfs_explo:
srfs = srfs_explo
else:
srfs = poly_srf
trg_len_min = 1
trg_len_max = 2.8
dummy = rs.GetReal("Maximum distance to surface", 0.05)
rhino_meshes = []
for i, srf in enumerate(srfs):
print("Computing Surface {0} of {1}".format(i + 1, len(srfs) + 1))
rs.EnableRedraw(False)
rs.HideObject(srf)
rhino_meshes.append(
nurbs_to_mesh_ani(srf, trg_len_min, trg_len_max, vis=1))
if srfs_explo:
rs.DeleteObject(srf)
#rs.ShowObjects(srfs)
rs.JoinMeshes(rhino_meshes, True)
rInputPoints = []
sInputPoints = []
masterList = []
rMasterList = []
sMasterList = []
resultingSurfaces = []
rResultingSurfaces = []
sResultingSurfaces = []
sublist = []
inputCrv = rs.GetObject("Select the input curve.", 4)
rs.EnableRedraw(False)
inputPoints = divideCurve(inputCrv)
rInputPoints = listShuffle(inputPoints)
sInputPoints = listShuffle(rInputPoints)
rs.HideObject(inputCrv)
operation(inputPoints, masterList)
operation(rInputPoints, rMasterList)
operation(sInputPoints, sMasterList)
for i in range(len(masterList)):
x = i + 1
if x >= len(masterList):
print "Done One"
break
else:
pointsToSurface(masterList[i], masterList[x], resultingSurfaces)
for i in range(len(rMasterList)):
x = i + 1
if x >= len(rMasterList):
if hatch:
# Store original hatch settings
hatch_pattern = rs.HatchPattern(hatch)
hatch_rotation = rs.HatchRotation(hatch)
hatch_scale = rs.HatchScale(hatch)
# Make hatch solid so we able to explode it and get surface instead
if hatch_pattern != "Solid":
rs.HatchPattern(hatch, "Solid")
dup_border_surface = []
dup_border_surface.append(rs.ExplodeHatch(hatch)[0])
rs.SurfaceIsocurveDensity(dup_border_surface, 100)
selected_objects.append(dup_border_surface)
reduced_selected_objects = reduce(operator.add, selected_objects)
rs.SelectObjects(reduced_selected_objects)
rs.HideObject(hatch)
rs.Command("_Trim")
trimmed_surface = rs.LastCreatedObjects()
new_borders = []
if trimmed_surface:
for surface in trimmed_surface:
new_borders.append(rs.DuplicateSurfaceBorder(surface))
selected_objects.append(new_borders)
# Keep trimming lines but everything else will be deleted further
selected_objects.remove(trim_lines)
new_hatches = rs.AddHatches(new_borders, hatch_pattern, hatch_scale, hatch_rotation)
rs.MatchObjectAttributes(new_hatches, hatch)
rs.ShowObject(new_hatches)
rs.DeleteObjects(trimmed_surface)
else:
for miterFacePoint in miterFacePoints:
if miterFacePoint == outerFacePoint:
intersectPoints.append(miterFacePoint)
param = rs.SurfaceClosestPoint(outerFace, intersectPoints[0])
normal = rs.SurfaceNormal(outerFace, param)
outerEndPoint = intersectPoints[0] + normal
outerVector = normal
param = rs.SurfaceClosestPoint(miterFace, intersectPoints[0])
normal = rs.SurfaceNormal(miterFace, param)
miterEndPoint = intersectPoints[0] + normal
miterVector = normal
line = rs.AddLine(outerEndPoint, miterEndPoint)
rs.HideObject(line)
midPoint = rs.CurveMidPoint(line)
normalVector = rs.VectorCrossProduct(outerVector, miterVector)
cutPlane = rs.AddCutPlane(solid, intersectPoints[0], midPoint, normal = normalVector)
rs.HideObject(cutPlane)
splitSolids = rs.SplitBrep(solid, cutPlane, True)
rs.CapPlanarHoles(splitSolids[0])
rs.CapPlanarHoles(splitSolids[1])
if rs.SurfaceArea(splitSolids[0]) > rs.SurfaceArea(splitSolids[1]):
rs.DeleteObject(splitSolids[1])
else:
s1 = rs.AddPoint(0, 0, 20)
e1 = rs.AddPoint(20, 0, 0)
s2 = rs.AddPoint(0, 40, 10)
e2 = rs.AddPoint(30, 40, 0)
#lineFrom = rs.GetPoint("Plane From:")
#lineTo = rs.GetPoint("Plane To:")
#distance = rs.Distance(lineFrom, lineTo)
#plane = rs.LinePlane([lineFrom, lineTo])
#rs.AddPlaneSurface( plane, distance, distance )
distance = rs.Distance(s1, e1)
plane = rs.LinePlane([s1, e1])
p1 = rs.AddPlaneSurface(plane, distance, distance)
rs.HideObject(p1)
distance = rs.Distance(s2, e2)
plane = rs.LinePlane([s2, e2])
p2 = rs.AddPlaneSurface(plane, distance, distance)
rs.HideObject(p2)
l1 = rs.AddLine(s1, e1)
l2 = rs.AddLine(s2, e2)
if l1:
points1 = rs.DivideCurve(l1, 20)
for point in points1:
rs.AddPoint(point)
rs.MoveObjects(points1, y)
import rhinoscriptsyntax as rs
import random
a = 20
x = random.randint(0,a)
y = random.randint(0,a)
z = random.randint(0,a)
p = (x,y,z)
p1 = (0,0,0)
p2 = (a,a,0)
p3 = (0,0,a)
for i in range(a):
for j in range(a):
point = (0,i,j)
A = rs.AddPoint(point)
rs.HideObject(A)
B = rs.AddLine(point,p)
rs.TrimCurve(B,(1,3),True)
