def main():
# first, select objects in three orthogonal planes
xs = rs.GetObjects("select X objects", filter=16)
# polysurface
ys = rs.GetObjects("select Y objects", filter=16)
zs = rs.GetObjects("select Z objects", filter=16)
subdivisions = rs.GetInteger(message="enter subdivisions (odd)",
number=5,
minimum=2,
maximum=None)
for positive, negative, hidden in ((xs, ys, zs), (xs, zs, ys), (ys, zs,
xs)):
rs.HideObjects(hidden)
make_fingers(positive, negative, subdivisions)
rs.ShowObjects(hidden)
# each time make_fingers is run, it fills guid_to_difference
# with more fingers to subtract.
# after all the fingers are subtracted at once
for guid, objs in guid_to_difference.items():
if objs:
rs.BooleanDifference(guid, objs)
def draw_line_select(self):
# Create an instance of a GetPoint class and add a delegate for the DynamicDraw event
gp = Rhino.Input.Custom.GetPoint()
# gp = Rhino.Input.Custom.PickContext()
gp.DynamicDraw += GetPointDynamicDrawFuncSelect
gp.Get()
obj_all = rs.HiddenObjects()
rs.ShowObjects(obj_all)
def main():
# first, select objects in three orthogonal planes
xs = rs.GetObjects("select X objects", filter=16); # polysurface
ys = rs.GetObjects("select Y objects", filter=16);
zs = rs.GetObjects("select Z objects", filter=16);
subdivisions = rs.GetInteger(message="enter subdivisions (o)", number=5, minimum=2, maximum=None)
for positive, negative, hidden in ((xs, ys, zs), (xs, zs, ys), (ys, zs, xs)):
rs.HideObjects(hidden)
finger.make_fingers(positive, negative, subdivisions)
rs.ShowObjects(hidden)
finger.perform_subtraction()
def UnisolateObjLayer():
try:
rs.EnableRedraw(False)
obj = rs.HiddenObjects()
if obj:
rs.ShowObjects(obj)
rs.EnableRedraw(True)
except:
print("Failed to execute")
rs.EnableRedraw(True)
return
def MakePlan(elevation, viewDepthZ, geos):
objs = rs.CopyObjects(geos)
rs.HideObjects(geos)
############################################################################
print "Cutting Plan"
allCrvs = []
#Make plane
plane = Rhino.Geometry.Plane(rs.coerce3dpoint((0, 0, elevation)),
rs.coerce3dvector((0, 0, 1)))
planeNeg = Rhino.Geometry.Plane(rs.coerce3dpoint((0, 0, viewDepthZ)),
rs.coerce3dvector((0, 0, 1)))
############################################################################
#Partition the geometry
partitionedObjs = PartitionGeometry(objs, elevation, viewDepthZ)
############################################################################
#Intersection Curves
#interCrvs = IntersectGeos(partitionedObjs[1], plane)
############################################################################
#Split Geometry
#Get the bottom half of intersecting objs
belowObjs = SplitGeometry(partitionedObjs[1], plane)
print "A"
#Get the top half of that previous geometry
visibleObjs = SplitGeometry(partitionedObjs[0] + belowObjs, planeNeg, -1)
rs.SelectObjects(visibleObjs)
objs2del = rs.InvertSelectedObjects()
rs.DeleteObjects(objs2del)
print "A"
############################################################################
#Make 2D
allCrvs += ProjectPlan(visibleObjs, plane)
rs.DeleteObjects(visibleObjs)
print "Plan Cut"
rs.ShowObjects(geos)
rs.HideObjects(allCrvs)
return allCrvs
def findFitness(point):
def testArrangement(sortedCurves, factor):
totalBox = rs.BoundingBox(sortedCurves)
sqrtSource = rs.Distance(totalBox[0], totalBox[1])
minLength = sqrtSource**0.5
minLength = minLength**factor
def meetsLength(len, startCrv, endCrv):
objects = [startCrv, endCrv]
boundingBox = rs.BoundingBox(objects, in_world_coords=True)
curLen = rs.Distance(boundingBox[0], boundingBox[1])
if curLen >= len:
return True
else:
return False
#Then, defining a list of the resulting lists.
listOfLists = []
s = 0 #"Start"
e = 0 #"End"
#Loop that splits the list into smaller lists.
while True:
if (s + e) == len(sortedCurves) or s == len(sortedCurves):
listOfLists.append(sortedCurves[s:s + e])
break
elif meetsLength(minLength, sortedCurves[s],
sortedCurves[s + e]) == True:
listOfLists.append(sortedCurves[s:s + e])
s = s + e
e = 1
continue
else:
e += 1
continue
#Now to move them vertically. First, like with the horizontal movement, we need to create a function that finds the vertical offset between each line.
def findVOffset(curCrv):
currentBox = rs.BoundingBox(curCrv, in_world_coords=True)
vHeight = rs.Distance(currentBox[0], currentBox[3])
offset = vHeight * 1.125
offset = 0 - offset
return offset
#And to move them.
for i in range(len(listOfLists)):
if i == len(listOfLists) - 1:
break
else:
rs.MoveObject(
listOfLists[i + 1],
rs.VectorCreate(findAnchorPoint(listOfLists[i]),
findAnchorPoint(listOfLists[i + 1])))
rs.MoveObject(listOfLists[i + 1],
(0, findVOffset(listOfLists[i + 1]), 0))
sList = rs.CopyObjects(oList)
rs.ShowObjects(sList)
testArrangement(sList, point[0])
shapeBox = rs.BoundingBox(sList)
width = rs.Distance(shapeBox[0], shapeBox[1])
height = rs.Distance(shapeBox[0], shapeBox[3])
numerator = abs(width - height)
denominator = width + height
denominator = denominator / 2
fitness = numerator / denominator
fitness = fitness * 100
rs.DeleteObjects(sList)
return fitness
"How many GENERATIONS would you like to iterate?", 1, 1, 100)
print " "
print "CONTINUING iterating for [", count, "] GENERATIONS."
rs.EnableRedraw(False)
continue
print " "
print "The iterations have ENDED. [", totalAttempts, "] solutions were tested."
print "Your final best fit had a FACTOR of [", bestPoint[
0], "] and a FITNESS of [", bestPoint[1], "]."
fFactor = bestPoint[0]
return fFactor
rs.HideObjects(sortedCurves)
minLenFactor = devLenFactor(sortedCurves)
rs.ShowObjects(sortedCurves)
minLength = minLength**minLenFactor
#Now, split the list into smaller lists, first with defining a function that tests whether the length meets the criteria. Returns either True or False.
def meetsLength(len, startCrv, endCrv):
objects = [startCrv, endCrv]
boundingBox = rs.BoundingBox(objects, in_world_coords=True)
curLen = rs.Distance(boundingBox[0], boundingBox[1])
if curLen >= len:
return True
else:
return False
#Then, defining a list of the resulting lists.
if __name__ == '__main__':
crvs = rs.GetObjects("Select mesh edges", 4)
lines = get_line_coordinates(crvs)
mesh = Mesh.from_lines(lines, delete_boundary_face=True)
artist = MeshArtist(mesh, layer='new_lines')
artist.draw_edges()
artist.redraw()
# select edge
rs.HideObjects(crvs)
edge = mesh_select_edge(mesh, "select a mesh edge")
rs.ShowObjects(crvs)
# select edge
artist.clear_edges()
# find "every second" edge (joint lines)
new_lines = []
para_edges = get_parallel_edges(mesh, edge)
for u, v in para_edges[2::2]:
new_lines.append((u, v))
# draw new lines
artist.draw_edges(keys=new_lines, color=(255, 0, 0))
artist.redraw()
def show_hidden_objects_on_layer(name):
rs.ShowObjects(
[guid for guid in rs.HiddenObjects() if rs.ObjectLayer(guid) == name])
if __name__ == '__main__':
edge_crvs = rs.GetObjects("Select edges", 4)
lines = get_line_coordinates(edge_crvs)
mesh = Mesh.from_lines(lines, delete_boundary_face=True)
# draw edges for selection
artist = MeshArtist(mesh, layer='joint_lines')
artist.draw_edges()
artist.redraw()
# select edge
rs.HideObjects(edge_crvs)
edges = mesh_select_edges(mesh)
rs.ShowObjects(edge_crvs)
# clear edges
artist.clear_edges()
# find "every second" edge (joint lines)
joint_lines = []
for i, uv in enumerate(edges):
para_edges = get_parallel_edges(mesh,uv)
for u, v in para_edges[i%2::2]:
joint_lines.append((u,v))
# draw joint lines
artist.draw_edges(keys=joint_lines, color=(255,0,0))
artist.redraw()
def relax_mesh_on_surface():
polylines = rs.ObjectsByLayer("re_02_polys")
pts_objs = rs.ObjectsByLayer("re_03_points")
vis = 5
kmax = 2000
dis = 0.3
dev_threshold = 0.003
angle_max = 30
pts = get_points_coordinates(pts_objs)
mesh = Mesh()
for i, pt in enumerate(pts):
mesh.add_vertex(str(i), {'x': pt[0], 'y': pt[1], 'z': pt[2]})
polys = get_polyline_points(polylines)
tris = get_faces_from_polylines(polys, pts)
for tri in tris:
mesh.add_face(tri)
rs.EnableRedraw(False)
pts = []
for key, a in mesh.vertices_iter(True):
pt1 = (a['x'], a['y'], a['z'])
pts.append(pt1)
vec = mesh.vertex_normal(key)
vec = scale(normalize(vec), dis)
pt2 = add_vectors(pt1, vec)
pt2 = add_vectors(pt1, vec)
a['x2'] = pt2[0]
a['y2'] = pt2[1]
a['z2'] = pt2[2]
a['normal'] = vec
#rs.AddLine(pt1,pt2)
faces_1 = draw(mesh, dev_threshold)
rs.HideObjects(faces_1)
for k in range(kmax):
nodes_top_dict = {key: [] for key in mesh.vertices()}
polys = []
max_distances = []
for u, v in mesh.edges():
pt1 = mesh.vertex_coordinates(u)
pt2 = mesh.vertex_coordinates(v)
pt3 = mesh.vertex[u]['x2'], mesh.vertex[u]['y2'], mesh.vertex[u][
'z2']
pt4 = mesh.vertex[v]['x2'], mesh.vertex[v]['y2'], mesh.vertex[v][
'z2']
points = [pt1, pt2, pt3, pt4]
points = rs.coerce3dpointlist(points, True)
rc, plane = Rhino.Geometry.Plane.FitPlaneToPoints(points)
pt3, pt4 = [plane.ClosestPoint(pt) for pt in points[2:]]
vec = scale(normalize(subtract_vectors(pt3, pt1)), dis)
pt3 = add_vectors(pt1, vec)
vec = scale(normalize(subtract_vectors(pt4, pt2)), dis)
pt4 = add_vectors(pt2, vec)
nodes_top_dict[u].append(pt3)
nodes_top_dict[v].append(pt4)
distances = [
distance(pt1, pt2) for pt1, pt2 in zip(points[2:], [pt3, pt4])
]
max_distances.append(max(distances))
for key, a in mesh.vertices_iter(True):
cent = centroid(nodes_top_dict[key])
pt = mesh.vertex_coordinates(key)
vec = subtract_vectors(cent, pt)
norm = a['normal']
if angle_smallest(vec, norm) < angle_max:
a['x2'] = cent[0]
a['y2'] = cent[1]
a['z2'] = cent[2]
if k % vis == 0:
rs.Prompt(
"Iteration {0} of {1} with with deviation sum {2}".format(
k, kmax, round(sum(max_distances), 4)))
draw_light(mesh, temp=True)
if max(max_distances) < dev_threshold or k == kmax:
print "Iteration {0} of {1} with deviation sum {2}".format(
k, kmax, round(sum(max_distances), 4))
break
dfaces_2 = draw(mesh, dev_threshold)
rs.ShowObjects(faces_1)
rs.EnableRedraw(True)
print max(max_distances)
#Prepare the shot
rs.CurrentView('Back')
rs.CurrentView('Front')
rs.HideObjects(obj_all)
rs.UnselectAllObjects()
#Take the shot
img_des = dir_tar + dir_mai + dir_sec + pfx_sec + str(i) + '.png'
rs.Command('-_ViewCaptureToFile ' + img_des + ' _DrawGrid=No' +
' _Width=' + str(img_wid) + ' _Height=' + str(img_hei) +
' _Scale=' + str(img_sca) + ' _TransparentBackground=No' +
' _Enter' + ' _Enter')
#Prepare the environment for the next iteration
pla_pos[1] = pla_pos[1] - vis_ste
rs.ShowObjects(obj_all)
rs.DeleteObjects(pla_obj)
sec_cur = rs.ObjectsByType(4)
rs.DeleteObjects(sec_cur)
if 'Default' in lay_lis:
rs.CurrentLayer(layer='Default')
else:
rs.AddLayer(name='Default')
rs.CurrentLayer(layer='Default')
#Leave the rest of the layers as they were at start
rs.CurrentLayer(lay_act)
for i in lay_vis:
rs.LayerVisible(i, visible=True)
import rhinoscriptsyntax as rs
#delete all existing objects
rs.ShowObjects(rs.HiddenObjects())
rs.DeleteObjects(rs.AllObjects('select'))
#variables
flowerRadius = 10 #radius of the flower
centerRadius = 2 #radius of the center of the flower
petalCount = 15
flowerCenter = (0, 0, 0)
petalWidth = 10 #width of the petals
petals = [] #store petal curves here
#print out the variables
textToPrint = 'flowerRadius = %d\ncenterRadius = %d\npetalCount = %d\npetalWidth = %d' % (
flowerRadius, centerRadius, petalCount, petalWidth)
rs.AddText(textToPrint, ((flowerRadius + 1), 2, 0), height=1.0)
#draw outer circle
outerCircle = rs.AddCircle(flowerCenter, flowerRadius)
#divide to get the point of each petal
points = rs.AddPoints(rs.DivideCurve(outerCircle, petalCount))
#draw each petal
for i in range(len(points)):
#draw line from center to point of the petal
centerLine = rs.AddLine(points[i], flowerCenter)
#find the midpoint
from objects_to_mesh import nurbs_to_mesh
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 = rs.GetReal("Target Edges Length", 0.75)
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(srf, trg_len, vis=5))
if srfs_explo:
rs.DeleteObject(srf)
rs.ShowObjects(srfs)
rs.JoinMeshes(rhino_meshes, True)