def move_point_down(self, point, cross_section_index, point_index):
offset_vectors = self.offset_vector(point, cross_section_index,
point_index)
normal = rs.VectorReverse(offset_vectors[0])
scaled_offset = rs.VectorScale(rs.VectorUnitize(offset_vectors[1]),
self.FLAT_LENGTH / 2)
new_point = rs.PointAdd(point, normal)
return [
rs.PointAdd(new_point, scaled_offset),
rs.PointAdd(new_point, rs.VectorReverse(scaled_offset))
]
def get_edge_vectors(s_brep,length): """gets the direction vectors for extending the edges of the one-surface brep""" edges = s_brep.Edges normal = s_brep.Faces[0].NormalAt(0.5,0.5) midpoints = [] for edge in edges: mp = edge.Domain.Mid midpoints.append(edge.PointAt(mp)) edge_vectors = [] for i, edge in enumerate(edges): #get directions to test moving midpoint start = edge.StartVertex.Location end = edge.EndVertex.Location v = rs.VectorCreate(end,start) xprod1 = Rhino.Geometry.Vector3d.CrossProduct(normal,v) xprod1 = rs.VectorUnitize(xprod1) xprod2 = rs.VectorReverse(xprod1) p1 = edge.PointAt(edge.Domain.Mid) + xprod1 p2 = edge.PointAt(edge.Domain.Mid) + xprod2 print "p1", p1 print "p2", p2 dist1 = distance_to_brep(s_brep,p1) dist2 = distance_to_brep(s_brep,p2) print "dist1", dist1 print "dist2", dist2 if dist1 > dist2: edge_vectors.append(rs.VectorScale(xprod1,length)) else: edge_vectors.append(rs.VectorScale(xprod2,length)) return edge_vectors
def depressCrvs(crvs, paths, startPt, radius, sd):
newCrvs = []
for i in range(len(crvs)):
divPts = rs.DivideCurve(crvs[i], 100)
if i < len(crvs) - 1:
cntPt01 = centerCrv(crvs[i])
cntPt02 = centerCrv(crvs[i + 1])
horVec = rs.VectorCreate(cntPt01, cntPt02)
for j in range(len(divPts)):
path = rs.PointClosestObject(divPts[j], paths)[0]
param = rs.CurveClosestPoint(path, divPts[j])
close = rs.EvaluateCurve(path, param)
dist = rs.Distance(close, divPts[j])
tan = rs.CurveTangent(crvs[i], param)
vec = [0, 0, -1] #rs.VectorCrossProduct(horVec,tan)
testVec = rs.VectorCreate(cntPt01, divPts[j])
if rs.VectorDotProduct(vec, testVec) < 0:
rs.VectorReverse(vec)
vec = rs.VectorUnitize(vec)
border = 1
entry = 1
if j > len(divPts) / 2:
border = rs.Distance(rs.CurveEndPoint(crvs[i]), divPts[j])
else:
border = rs.Distance(rs.CurveStartPoint(crvs[i]), divPts[j])
if border < sd * 3:
border = border / (sd * 3)
entryDist = rs.Distance(startPt, divPts[j])
if entryDist < sd * 10:
entry = entryDist / (sd * 10)
if dist < sd * 2:
val = radius * (bellCrv(dist, sd))
divPts[j] = rs.PointAdd(divPts[j], vec * val * border * entry)
newCrvs.append(rs.AddCurve(divPts))
return divPts
def CheckRunLengths(runs):
lengthComment = ''
for i, run in enumerate(runs):
dist = rs.Distance(rs.CurveStartPoint(run[0]),
rs.CurveStartPoint(run[1]))
if dist > 360:
lengthComment += 'Run {} requires a landing\n'.format(i + 1)
templine = rs.AddLine(rs.CurveStartPoint(run[0]),
rs.CurveStartPoint(run[1]))
mdPt = rs.CurveMidPoint(templine)
vec = rs.VectorCreate(mdPt, rs.CurveStartPoint(run[0]))
landingCenter = rs.CopyObject(run[0], vec)
vec = rs.VectorScale(rs.VectorUnitize(vec), 30)
upperLine = rs.CopyObject(landingCenter, vec)
vec = rs.VectorReverse(vec)
lowerLine = rs.MoveObject(landingCenter, vec)
rs.DeleteObject(templine)
run.insert(1, lowerLine)
run.insert(2, upperLine)
flatList = []
for item in runs:
for each in item:
flatList.append(each)
pairs = []
for i in range(0, len(flatList), 2):
pairs.append([flatList[i], flatList[i + 1]])
return pairs, lengthComment
def getTwoParallelLineSelectionRegion(p0, p1, pi, width):
lineDirect = rs.VectorUnitize(rs.VectorCreate(p1, p0))
lineCross = rs.VectorRotate(lineDirect, 90, (0, 0, 1))
piUp = rs.VectorAdd(pi, rs.VectorScale(lineCross, width))
piDown = rs.VectorAdd(pi, rs.VectorScale(rs.VectorReverse(lineCross),
width))
piDownRight = rs.VectorAdd(piDown, lineDirect * width)
return (geo.Point3d(piUp), geo.Point3d(piDown), geo.Point3d(piDownRight))
def get_motion_vectors(mesh_id, step):
"""Returns a list of motion vectors in the same order as the vertices in the
Rhino representation of the input mesh. Uses adjacency list instead of adjacency
matrix, thus improving the running time from O(|V|^2) to O(|V|+|E|).
"""
adj_list = adjacency_list(mesh_id)
vertex_face_ind = vertex_face_index(mesh_id)
v = rs.MeshVertices(mesh_id)
n = len(v)
harmonic_vectors = []
for i in xrange(n):
p = v[i]
# Initialize the harmonic vector as a zero vector
harmonic_vector = rs.VectorCreate([0, 0, 0], [0, 0, 0])
# Sum up all the vectors pointing to adjacent vertices
adj = get_adjacent_vertices_in_order(mesh_id, adj_list,
vertex_face_ind, i)
for j in xrange(len(adj)):
# q_j vertices
q_prev = v[adj[(j - 1) % len(adj)]]
q_curr = v[adj[j]]
q_next = v[adj[(j + 1) % len(adj)]]
# pq vectors
pq_prev = rs.VectorCreate(q_prev, p)
pq = rs.VectorCreate(q_curr, p)
pq_next = rs.VectorCreate(q_next, p)
# vectors between q vertices
q_prev_q_curr = rs.VectorCreate(q_curr, q_prev)
q_next_q_curr = rs.VectorCreate(q_curr, q_next)
# Angles needed for MCF
alpha = vu.VectorAngleRadians(rs.VectorReverse(pq), q_prev_q_curr)
beta = vu.VectorAngleRadians(rs.VectorReverse(pq), q_next_q_curr)
# Continue computing the sum for the harmonic vector
# TODO(mikhaildubov): The formula with cotangents fails on sphere134.3dm.
# Check it and also ensure that the input mesh is triangulated.
harmonic_coeff = 1 #(cotan(alpha) + cotan(beta)) / 2
harmonic_vector = rs.VectorScale(rs.VectorAdd(harmonic_vector, pq),
harmonic_coeff)
# Rescale
# TODO(mikhaildubov): use this for true MCF:
#harmonic_vector = rs.VectorScale(harmonic_vector, step)
harmonic_vector = vu.VectorResize(harmonic_vector, step)
harmonic_vectors.append(harmonic_vector)
return harmonic_vectors
def moveSrftoZ(srf):
domainU = rs.SurfaceDomain(srf, 0)
domainV = rs.SurfaceDomain(srf, 1)
u = domainU[1] / 2.0
v = domainV[1] / 2.0
point = rs.EvaluateSurface(srf, u, v)
# vec = [0, 0, point.Z]
# vec = rs.VectorReverse(vec)
# vec = [0,0,vec.Z]
rs.MoveObjects(srf, rs.VectorReverse([0, 0, point.Z]))
def copyToOrigin(objs):
#get left bottom
selection_base = rs.GetPoint("Pick export base point")
#box = rs.BoundingBox(objs)
if selection_base:
#selection_base = [box[0].X, box[0].Y, box[0].Z]
vector = rs.VectorSubtract(selection_base, [0, 0, 0])
return rs.CopyObjects(objs, rs.VectorReverse(vector))
def move_point_down(self, point, cross_section_index, point_index):
if (cross_section_index > 0):
offset_vectors = self.offset_vector(point, cross_section_index,
point_index)
normal = rs.VectorReverse(offset_vectors[0])
scaled_offset = rs.VectorScale(rs.VectorUnitize(offset_vectors[1]),
3)
new_point = rs.PointAdd(point, normal)
return [
rs.PointAdd(new_point, scaled_offset),
rs.PointAdd(new_point, rs.VectorReverse(scaled_offset))
]
else:
curve = self.cross_sections[cross_section_index]
parameter = rs.CurveClosestPoint(curve, point)
tangent = rs.CurveTangent(curve, parameter)
unit_vector = rs.VectorUnitize(tangent)
scale_vector = rs.VectorReverse(rs.VectorScale(unit_vector, 2))
return [rs.PointAdd(point, scale_vector)]
def moveToOrigin(objs, origin):
#box = rs.BoundingBox(objs)
if origin:
#selection_base = [box[0].X, box[0].Y, box[0].Z]
vector = rs.VectorSubtract(origin, [0, 0, 0])
objs = rs.MoveObjects(objs, rs.VectorReverse(vector))
return True
else:
return False
def Start(refpt,dir,data):
xform = Transform(rs.VectorReverse(dir),rs.VectorReverse(rs.VectorRotate(dir,90,[0,0,1])),refpt)
both = []
for point in data[2]:
trans = rs.VectorTransform(point,xform)
trans = rs.VectorAdd(trans,refpt)
both.append(trans)
L = [both[1],both[2]]
R = [both[1],both[0]]
trans = rs.VectorTransform(data[1],xform)
#'Special case here:
return [rs.VectorReverse(trans),L,R]
def offset_vector(self, point, cross_section_index, point_index):
modulo = len(self.point_lists[cross_section_index])
closest_point = rs.CurveClosestPoint(
self.cross_sections[cross_section_index], point)
crv = rs.CurveCurvature(self.cross_sections[cross_section_index],
closest_point)
crvTangent = crv[1]
crvPerp = rs.VectorUnitize(crv[4])
unit_vector = rs.VectorUnitize(crvTangent)
return [
rs.VectorScale(unit_vector, 0.205),
rs.VectorReverse(rs.VectorCrossProduct(crvTangent, crvPerp))
]
def join_jigs(self, jigs):
start_end = self.create_end_caps(jigs[0].start_corners,
rs.VectorReverse(jigs[0].across))
end_end = self.create_end_caps(jigs[len(jigs) - 1].end_corners,
jigs[len(jigs) - 1].across)
surfaces = [start_end]
for i in range(0, len(jigs), 1):
surfaces.append(jigs[i].srf)
if (i < len(jigs) - 1):
surfaces.append(jigs[i].connector)
surfaces.append(end_end)
surface = rs.JoinSurfaces(surfaces, True)
rs.CapPlanarHoles(surface)
print rs.IsObjectSolid(surface)
def create_square(self, start_point, end_point, start_vector):
across = rs.VectorUnitize(end_point - start_point)
up = rs.VectorScale(start_vector, 0.5)
over_unit = rs.VectorUnitize(rs.VectorCrossProduct(up, across))
over = rs.VectorScale((over_unit), 0.5)
points_inner = []
points_inner.append(rs.PointAdd(start_point, rs.VectorAdd(up, over)))
points_inner.append(
rs.PointAdd(points_inner[0], rs.VectorReverse(over_unit)))
points_inner.append(
rs.PointAdd(points_inner[1], rs.VectorReverse(start_vector)))
points_inner.append(rs.PointAdd(points_inner[2], over_unit))
points_outer = []
points_outer.append(
rs.PointAdd(start_point, rs.VectorAdd(start_vector, over_unit)))
points_outer.append(
rs.PointAdd(points_outer[0],
rs.VectorScale(rs.VectorReverse(over_unit), 2)))
points_outer.append(
rs.PointAdd(points_outer[1],
rs.VectorScale(rs.VectorReverse(start_vector), 2)))
points_outer.append(
rs.PointAdd(points_outer[2], rs.VectorScale(over_unit, 2)))
return [points_outer, points_inner, across]
def moveToOrigin(objs):
#get left bottom
rs.EnableRedraw(True)
selection_base = rs.GetPoint("Pick export base point")
rs.EnableRedraw(False)
#box = rs.BoundingBox(objs)
if selection_base:
#selection_base = [box[0].X, box[0].Y, box[0].Z]
vector = rs.VectorSubtract(selection_base, [0, 0, 0])
objs = rs.MoveObjects(objs, rs.VectorReverse(vector))
return True
else:
return False
def MapCurvatureStep(srf_id, uvPt, max, reverse, accuracy):
data_curvature = rs.SurfaceCurvature(srf_id, uvPt)
if not data_curvature: return
vec = data_curvature[5]
if max: vec = data_curvature[3]
if reverse: vec = rs.VectorReverse(vec)
vec = rs.VectorUnitize(vec)
vec = rs.VectorScale(vec, accuracy)
dPoint = rs.VectorAdd(data_curvature[0], vec)
nPoint = rs.SurfaceClosestPoint(srf_id, dPoint)
mPoint = rs.EvaluateSurface(srf_id, nPoint)
if rs.Distance(mPoint, data_curvature[0])< (0.5*accuracy): return
return nPoint
def MakeHandrailFromRuns(run, HDRLoffset):
pt1 = rs.CurveStartPoint(run[0])
pt2 = rs.CurveStartPoint(run[1])
pt3 = rs.CurveEndPoint(run[0])
pt4 = rs.CurveEndPoint(run[1])
crossVec = rs.VectorCreate(pt3, pt1)
crossVec = rs.VectorUnitize(crossVec)
crossVec = rs.VectorScale(crossVec, HDRLoffset)
edge1 = rs.AddLine(pt1, pt2)
edge2 = rs.AddLine(pt3, pt4)
edge1 = rs.MoveObject(edge1, crossVec)
edge2 = rs.MoveObject(edge2, rs.VectorReverse(crossVec))
return [edge1, edge2]
def get_face_category(f,v): """pick category: 0: side srfs that get extended 1: side srfs that get shortened 2: top surfaces""" normal = f.NormalAt(0.5,0.5) epsilon = 0.5 up = rs.coerce3dvector([0,0,1]) down = rs.coerce3dvector([0,0,-1]) compare_angle = min(rs.VectorAngle(normal,v),rs.VectorAngle(normal,rs.VectorReverse(v))) if normal.EpsilonEquals(up,epsilon) or normal.EpsilonEquals(down,epsilon): return 2 elif 88 < compare_angle < 92: return 1 else: return 0
def congregate(objs, threshold, loops):
scaleFactOrig = .1
for j in range(loops):
scaleF = ((loops-j)/loops) * scaleFactOrig
print scaleF
for i, pt1 in enumerate(objs):
tempList = list(objs)
del tempList[i]
pt2 = rs.PointClosestObject(pt1, tempList)[1]
vec = rs.VectorCreate(pt2, pt1)
dist = rs.Distance(pt2, pt1)
if dist < threshold:
vec = rs.VectorReverse(vec)
vec2 = rs.VectorScale(vec, scaleF)
rs.MoveObject(pt1, vec2)
line = rs.AddLine(pt1, pt2)
rs.DeleteObject(line)
return objs
def GetPointDynamicDrawFunc(sender, args):
point_b = args.CurrentPoint
point_C = Rhino.Geometry.Point3d((point_a.X + point_b.X) / 2,
(point_a.Y + point_b.Y) / 2,
(point_a.Z + point_b.Z) / 2)
#Rhino.Geometry.Transform.Translation(
vec = rs.VectorCreate(point_b, point_a)
rs.VectorUnitize(vec)
vec2 = rs.VectorScale(vec, 500)
vec3 = rs.coerce3dpoint(rs.VectorAdd(point_b, vec2))
rs.VectorReverse(vec2)
vec4 = rs.coerce3dpoint(rs.VectorSubtract(point_b, vec2))
args.Display.DrawLine(point_a, vec3, line_color_1, 1)
args.Display.DrawLine(point_a, vec4, line_color_1, 1)
args.Display.DrawPoint(point_a, Rhino.Display.PointStyle.ControlPoint,
3, line_color_1)
args.Display.DrawPoint(point_b, Rhino.Display.PointStyle.ControlPoint,
3, line_color_2)
def make_join(edge, n_joins, dx, dy, inner, truncate):
pts = rs.DivideCurve(edge, n_joins)
outer_pts, inner_pts, pairs_ordered = [], [], []
extrapt = None
outer_pts = rs.AddPoints(pts)
inner_pts = rs.CopyObjects(outer_pts, [dx, dy, 0])
if inner == True:
extrapt = outer_pts[0]
outer_pts = outer_pts[1:]
else:
extrapt = inner_pts[0]
inner_pts = inner_pts[1:]
pairs_o = zip(outer_pts[0::2], outer_pts[1::2])
pairs_i = zip(inner_pts[0::2], inner_pts[1::2])
if inner is True:
pairs_ordered = flatten(zip(pairs_i, pairs_o))
endpts = [inner_pts[-2], inner_pts[-1]]
else:
pairs_ordered = flatten(zip(pairs_o, pairs_i))
endpts = [outer_pts[-2], outer_pts[-1]]
pairs_ordered = pairs_ordered + endpts
if truncate is True:
v = rs.VectorUnitize(
rs.VectorCreate(pairs_ordered[0], pairs_ordered[1]))
v = rs.VectorScale(v, T_OBOX)
rs.MoveObject(pairs_ordered[-1], v)
rs.MoveObject(pairs_ordered[0], rs.VectorReverse(v))
pl = rs.AddPolyline(pairs_ordered)
rs.DeleteObject(extrapt)
rs.DeleteObjects(outer_pts)
rs.DeleteObjects(inner_pts)
return pl
def get_arc_cap(pntI, pntJ, offset, radius):
'''
finds three points, A,B,C making up a half-circle arc. returns in order [A,C,B]
oriented on the vector. Assumes vector lies in XY plane
C
/
I--- B ------------------->J
\
A
'''
normal = [0, 0, 1]
vec = rs.VectorSubtract(pntJ, pntI)
vecB_unit = rs.VectorUnitize(vec)
vecB_sized = rs.VectorScale(vecB_unit, offset)
pointB = rs.VectorAdd(pntI, vecB_sized)
vec_base = rs.VectorScale(vecB_unit, offset + radius)
vec_perp_c = get_sized_perpendicular_vector(pntI, pntJ, radius, True)
vec_C = rs.VectorAdd(vec_base, vec_perp_c)
pointC = rs.VectorAdd(pntI, vec_C)
vec_perp_a = rs.VectorReverse(vec_perp_c)
vec_A = rs.VectorAdd(vec_base, vec_perp_a)
pointA = rs.VectorAdd(pntI, vec_A)
return pointA, pointB, pointC
def Congregate(pts, spacing, loops):
scaleFactOrig = .1
for j in range(loops):
scaleF = ((loops - j) / loops) * scaleFactOrig
for i, pt in enumerate(pts):
#PTS TO COMPARE AGAINST
closest = None
for comparePt in pts:
distance = pt.DistanceTo(comparePt)
if distance == 0: continue
if distance > spacing * 4: continue
if closest is None or distance < closest[0]:
closest = distance, comparePt
if closest is None: continue
vec = rs.VectorCreate(closest[1], pt)
if closest[0] < spacing:
vec = rs.VectorReverse(vec)
vec = rs.VectorScale(vec, scaleF)
pts[i] = pt.Add(pt, vec)
return pts
def optimization(used_centerP, used_surfaceP, used_surface, unused_surface,
unused_line, unused_poly, unused_mark_line, tolerance):
start_time = time.time()
vector = rs.VectorCreate(used_surfaceP, used_centerP)
normal = rs.VectorUnitize(vector)
vec_length = rs.VectorScale(normal, 0.01)
vec_reverse = rs.VectorReverse(normal)
vec_reverse = rs.VectorScale(vec_reverse, 0.1)
# 描画
# AddVector(used_centerP, vector)
# AddVector(used_centerP, vec_reverse)
# 接触判定
for i in range(200):
curve = rs.IntersectBreps(used_surface, unused_surface)
if i == 199:
# print("Can not Optimization tan1")
if curve:
for k in range(len(curve)):
rs.DeleteObject(curve[k])
# run time console
end_time = time.time()
optimization_run_time = end_time - start_time
# print("-------------------------------------------------------")
# print("optimization Run time: %s" % optimization_run_time)
return False
# timberが接触していない場合
if curve is None:
rs.MoveObject(unused_surface, vec_reverse)
rs.MoveObject(unused_line, vec_reverse)
rs.MoveObject(unused_poly, vec_reverse)
rs.MoveObject(unused_mark_line[0], vec_reverse)
rs.MoveObject(unused_mark_line[1], vec_reverse)
# timberが接触している場合
else:
length = 0
for j in range(0, len(curve)):
if rs.IsCurve(curve[j]):
length = length + rs.CurveLength(curve[j])
else:
rs.MoveObject(unused_surface, vec_length)
rs.MoveObject(unused_line, vec_length)
rs.MoveObject(unused_poly, vec_length)
rs.MoveObject(unused_mark_line[0], vec_length)
rs.MoveObject(unused_mark_line[1], vec_length)
continue
# console
# print("curve length[%s]: %s | vec length: %s" % (i, length, vec_length))
# 接合条件を満たした場合
if length < tolerance:
# print("-------------------------------------------------------")
# print("tan1 <count: %s | curve length: %s>" % (i, length))
# run time console
end_time = time.time()
optimization_run_time = end_time - start_time
# print("optimization Run time: %s" % optimization_run_time)
return curve
# 接合条件を満たさない場合
else:
rs.MoveObject(unused_surface, vec_length)
rs.MoveObject(unused_line, vec_length)
rs.MoveObject(unused_poly, vec_length)
rs.MoveObject(unused_mark_line[0], vec_length)
rs.MoveObject(unused_mark_line[1], vec_length)
# オフセットする大きさを更新
if length < 45:
vec_length = rs.VectorScale(normal, 0.05)
elif length < 60:
vec_length = rs.VectorScale(normal, 0.55)
elif length < 80:
vec_length = rs.VectorScale(normal, 0.75)
elif length < 120:
vec_length = rs.VectorScale(normal, 2.5)
elif length < 200:
vec_length = rs.VectorScale(normal, 3.5)
else:
vec_length = rs.VectorScale(normal, 8.0)
# objectを削除
for k in range(0, len(curve)):
rs.DeleteObject(curve[k])
if i == 199:
# print("Can not Optimization tan1")
if curve:
for k in range(0, len(curve)):
rs.DeleteObject(curve[k])
# run time console
end_time = time.time()
optimization_run_time = end_time - start_time
# print("-------------------------------------------------------")
# print("optimization Run time: %s" % optimization_run_time)
return False
def optimization_bridge(_unused_srf, _unused_line, _unused_poly,
_unused_mark_line, _used_srf1, _used_srf2,
_rotate_point1, _rotate_point2, _rotate_axis1,
_rotate_axis2, _move_vec1, _move_vec2, tolerance):
start_time = time.time()
unused_surface = _unused_srf
unused_line = _unused_line
unused_polyline = _unused_poly
unused_mark_line = _unused_mark_line
used_surface1 = _used_srf1
used_surface2 = _used_srf2
rotate_point1 = _rotate_point1
rotate_point2 = _rotate_point2
rotate_axis1 = _rotate_axis1
rotate_axis2 = _rotate_axis2
angle1 = -0.01
angle2 = -0.01
move_vec1 = _move_vec1
move_vec2 = _move_vec2
normal1 = rs.VectorUnitize(move_vec1)
normal2 = rs.VectorUnitize(move_vec2)
vec_length1 = rs.VectorScale(normal1, 0.1)
vec_length2 = rs.VectorScale(normal2, 0.1)
vec_reverse1 = rs.VectorReverse(vec_length1)
vec_reverse2 = rs.VectorReverse(vec_length2)
curve_length1 = []
curve_length2 = []
count1 = 0
count2 = 0
# 衝突判定
for i in range(200):
curve1 = rs.IntersectBreps(used_surface1, unused_surface)
curve2 = rs.IntersectBreps(used_surface2, unused_surface)
# 最適化できなかった場合
if i == 199:
# print("-------------------------------------------------------")
# print("Can not Optimization bridge")
# run time console
end_time = time.time()
optimization_bridge_run_time = end_time - start_time
# print("---------------------------------------------------")
# print("optimization_bridge Run time: %s" % optimization_bridge_run_time)
return False
# 接点1でも接点2でも接していない時
if curve1 is None and curve2 is None:
rs.MoveObject(unused_surface, vec_length1)
rs.MoveObject(unused_line, vec_length1)
rs.MoveObject(unused_polyline, vec_length1)
rs.MoveObject(unused_mark_line[0], vec_length1)
rs.MoveObject(unused_mark_line[1], vec_length1)
continue
# 接点2では接しているが接点1では接していない時
if curve1 is None:
# rs.MoveObject(unused_surface, vec_reverse)
# rs.MoveObject(unused_line, vec_reverse)
# rs.MoveObject(unused_poly, vec_reverse)
rs.RotateObject(unused_surface, rotate_point2, angle1,
rotate_axis2)
rs.RotateObject(unused_line, rotate_point2, angle1, rotate_axis2)
rs.RotateObject(unused_polyline, rotate_point2, angle1,
rotate_axis2)
rs.RotateObject(unused_mark_line[0], rotate_point2, angle1,
rotate_axis2)
rs.RotateObject(unused_mark_line[1], rotate_point2, angle1,
rotate_axis2)
if curve2:
for k in range(0, len(curve2)):
rs.DeleteObject(curve2[k])
count1 = count1 + 1
# もし5回連続で接触しない場合、回転方向を逆転する
if count1 == 5:
angle1 = angle1 * -1.0
angle = 5.0 * angle1
rs.RotateObject(unused_surface, rotate_point2, angle,
rotate_axis2)
rs.RotateObject(unused_line, rotate_point2, angle,
rotate_axis2)
rs.RotateObject(unused_polyline, rotate_point2, angle,
rotate_axis2)
rs.RotateObject(unused_mark_line[0], rotate_point2, angle,
rotate_axis2)
rs.RotateObject(unused_mark_line[1], rotate_point2, angle,
rotate_axis2)
continue
# 接点1では接しているが接点2では接していない時
if curve2 is None:
# rs.MoveObject(unused_surface, vec_length)
# rs.MoveObject(unused_line, vec_length)
# rs.MoveObject(unused_poly, vec_length)
rs.RotateObject(unused_surface, rotate_point1, angle2,
rotate_axis1)
rs.RotateObject(unused_line, rotate_point1, angle2, rotate_axis1)
rs.RotateObject(unused_polyline, rotate_point1, angle2,
rotate_axis1)
rs.RotateObject(unused_mark_line[0], rotate_point1, angle2,
rotate_axis1)
rs.RotateObject(unused_mark_line[1], rotate_point1, angle2,
rotate_axis1)
if curve1:
for k in range(0, len(curve1)):
rs.DeleteObject(curve1[k])
count2 = count2 + 1
# もし5回連続で接触しない場合、回転方向を逆転する
if count2 == 5:
angle2 = angle2 * -1.0
angle = 5.0 * angle2
rs.RotateObject(unused_surface, rotate_point1, angle,
rotate_axis1)
rs.RotateObject(unused_line, rotate_point1, angle,
rotate_axis1)
rs.RotateObject(unused_polyline, rotate_point1, angle,
rotate_axis1)
rs.RotateObject(unused_mark_line[0], rotate_point1, angle,
rotate_axis1)
rs.RotateObject(unused_mark_line[1], rotate_point1, angle,
rotate_axis1)
continue
# どちらも接触している場合
length1 = 0
length2 = 0
for j in range(0, len(curve1)):
if rs.IsCurve(curve1[j]):
length1 = length1 + rs.CurveLength(curve1[j])
else:
rs.RotateObject(unused_surface, rotate_point1, angle2,
rotate_axis1)
rs.RotateObject(unused_line, rotate_point1, angle2,
rotate_axis1)
rs.RotateObject(unused_polyline, rotate_point1, angle2,
rotate_axis1)
rs.RotateObject(unused_mark_line[0], rotate_point1, angle2,
rotate_axis1)
rs.RotateObject(unused_mark_line[1], rotate_point1, angle2,
rotate_axis1)
continue
for j in range(0, len(curve2)):
if rs.IsCurve(curve2[j]):
length2 = length2 + rs.CurveLength(curve2[j])
else:
rs.RotateObject(unused_surface, rotate_point1, angle2,
rotate_axis1)
rs.RotateObject(unused_line, rotate_point1, angle2,
rotate_axis1)
rs.RotateObject(unused_polyline, rotate_point1, angle2,
rotate_axis1)
rs.RotateObject(unused_mark_line[0], rotate_point1, angle2,
rotate_axis1)
rs.RotateObject(unused_mark_line[1], rotate_point1, angle2,
rotate_axis1)
continue
# 接点1でも接点2でも許容値の制約を満たすとき
if length1 < tolerance and length2 < tolerance:
# print("-------------------------------------------------------")
# print("Final tan1 <count: %s | curve length1: %s>" % (i, length1))
# print("Final tan2 <count: %s | curve_length2: %s>" % (i, length2))
# run time console
end_time = time.time()
optimization_bridge_run_time = end_time - start_time
# print("optimization_bridge Run time: %s" % optimization_bridge_run_time)
return curve1, curve2
# 接点1で許容値の制約を満たすとき(接点2では満たさない)
elif length1 < tolerance:
# angleを更新
if length2 < 50:
if angle2 > 0:
angle2 = 0.01
else:
angle2 = -0.01
elif length2 < 60:
if angle2 > 0:
angle2 = 0.04
else:
angle2 = -0.04
elif length2 < 90:
if angle2 > 0:
angle2 = 0.07
else:
angle2 = -0.07
elif length2 < 120:
if angle2 > 0:
angle2 = 0.15
else:
angle2 = -0.15
elif length2 < 150:
if angle2 > 0:
angle2 = 0.35
else:
angle2 = -0.35
else:
if angle2 > 0:
angle2 = 4.3
else:
angle2 = -4.3
rs.RotateObject(unused_surface, rotate_point1, angle2,
rotate_axis1)
rs.RotateObject(unused_line, rotate_point1, angle2, rotate_axis1)
rs.RotateObject(unused_polyline, rotate_point1, angle2,
rotate_axis1)
rs.RotateObject(unused_mark_line[0], rotate_point1, angle2,
rotate_axis1)
rs.RotateObject(unused_mark_line[1], rotate_point1, angle2,
rotate_axis1)
# print("length1[%s]: %s | angle2: %s" % (i, length1, angle2))
# print("length2[%s]: %s | angle2: %s" % (i, length2, angle2))
# 接点2の接触部の長さを格納する
curve_length2.append(length2)
# もし衝突交線の値が大きくなる場合、回転の方向を逆転する
if len(curve_length2) == 3:
if curve_length2[0] < curve_length2[1] < curve_length2[2]:
angle2 = angle2 * -1.0
# print("update angle2")
# print("angle2: %s" % angle2)
angle = 3.0 * angle2
rs.RotateObject(unused_surface, rotate_point1, angle,
rotate_axis1)
rs.RotateObject(unused_line, rotate_point1, angle,
rotate_axis1)
rs.RotateObject(unused_polyline, rotate_point1, angle,
rotate_axis1)
rs.RotateObject(unused_mark_line[0], rotate_point1, angle,
rotate_axis1)
rs.RotateObject(unused_mark_line[1], rotate_point1, angle,
rotate_axis1)
curve_length2 = []
if curve1:
for k in range(0, len(curve1)):
rs.DeleteObject(curve1[k])
if curve2:
for k in range(0, len(curve2)):
rs.DeleteObject(curve2[k])
if i == 199:
# print("-------------------------------------------------------")
# print("Can not Optimization bridge")
# run time console
end_time = time.time()
optimization_bridge_run_time = end_time - start_time
# print("optimization_bridge Run time: %s" % optimization_bridge_run_time)
return False
# 接点2で許容値の制約を満たすとき(接点1では満たさない)
elif length2 < tolerance:
# angleを更新
if length1 < 45:
if angle1 > 0:
angle1 = 0.01
else:
angle1 = -0.01
elif length1 < 60:
if angle1 > 0:
angle1 = 0.04
else:
angle1 = -0.04
elif length1 < 90:
if angle1 > 0:
angle1 = 0.07
else:
angle1 = -0.07
elif length1 < 120:
if angle1 > 0:
angle1 = 0.15
else:
angle1 = -0.15
elif length1 < 150:
if angle1 > 0:
angle1 = 0.35
else:
angle1 = -0.35
else:
if angle1 > 0:
angle1 = 4.3
else:
angle1 = -4.3
rs.RotateObject(unused_surface, rotate_point2, angle1,
rotate_axis2)
rs.RotateObject(unused_line, rotate_point2, angle1, rotate_axis2)
rs.RotateObject(unused_polyline, rotate_point2, angle1,
rotate_axis2)
rs.RotateObject(unused_mark_line[0], rotate_point2, angle1,
rotate_axis2)
rs.RotateObject(unused_mark_line[1], rotate_point2, angle1,
rotate_axis2)
# console
# print("length1[%s]: %s | angle1: %s" % (i, length1, angle1))
# print("length2[%s]: %s | angle1: %s" % (i, length2, angle1))
# checkしているよ TODO
# if length2 < 10:
# rs.MoveObject(unused_surface, vec_reverse)
# rs.MoveObject(unused_line, vec_reverse)
# rs.MoveObject(unused_poly, vec_reverse)
# 接点1の接触部の長さを格納する
curve_length1.append(length1)
# もし衝突交線の値が大きくなる場合、回転の方向を逆転する
if len(curve_length1) == 3:
if curve_length1[0] < curve_length1[1] < curve_length1[2]:
angle1 = angle1 * -1.0
# print("update angle1")
# print("angle1: %s" % angle1)
angle = 3.0 * angle1
rs.RotateObject(unused_surface, rotate_point2, angle,
rotate_axis2)
rs.RotateObject(unused_line, rotate_point2, angle,
rotate_axis2)
rs.RotateObject(unused_polyline, rotate_point2, angle,
rotate_axis2)
rs.RotateObject(unused_mark_line[0], rotate_point2, angle,
rotate_axis2)
rs.RotateObject(unused_mark_line[1], rotate_point2, angle,
rotate_axis2)
curve_length1 = []
if curve1:
for k in range(0, len(curve1)):
rs.DeleteObject(curve1[k])
if curve2:
for k in range(0, len(curve2)):
rs.DeleteObject(curve2[k])
if i == 199:
# print("-------------------------------------------------------")
# print("Can not Optimization bridge")
# run time console
end_time = time.time()
optimization_bridge_run_time = end_time - start_time
# print("optimization_bridge Run time: %s" % optimization_bridge_run_time)
return False
else:
rs.MoveObject(unused_surface, vec_reverse1)
rs.MoveObject(unused_line, vec_reverse1)
rs.MoveObject(unused_polyline, vec_reverse1)
rs.MoveObject(unused_mark_line[0], vec_reverse1)
rs.MoveObject(unused_mark_line[1], vec_reverse1)
if curve1:
for k in range(0, len(curve1)):
rs.DeleteObject(curve1[k])
if curve2:
for k in range(0, len(curve2)):
rs.DeleteObject(curve2[k])
if i == 199:
# print("-------------------------------------------------------")
# print("Can not Optimization bridge")
# run time console
end_time = time.time()
optimization_bridge_run_time = end_time - start_time
# print("optimization_bridge Run time: %s" % optimization_bridge_run_time)
return False
def reverse_if_needed(self, current, previous):
dot_product = rs.VectorDotProduct(current, previous)
if (dot_product < 0):
return rs.VectorReverse(current)
else:
return current
def makeFireStair(rect, landingLevels):
#HARD VARIABLES
minGapSize = .2
minTread = .260
maxRiser = .180
thickness = .15
#(1)Determine Run Direction
rs.SimplifyCurve(rect)
rectSegments = rs.ExplodeCurves(rect)
edge1 = rectSegments[0]
edge3 = rectSegments[1]
rs.DeleteObject(rectSegments[2])
rs.DeleteObject(rectSegments[3])
if rs.CurveLength(edge1) > rs.CurveLength(edge3):
longEdge = edge1
shortEdge = edge3
else:
longEdge = edge3
shortEdge = edge1
longVec = rs.VectorCreate(rs.CurveStartPoint(longEdge),
rs.CurveEndPoint(longEdge))
longVecRev = rs.VectorReverse(longVec)
shortVec = rs.VectorCreate(rs.CurveStartPoint(shortEdge),
rs.CurveEndPoint(shortEdge))
shortVecRev = rs.VectorReverse(shortVec)
rs.CurveArrows(longEdge, 2)
rs.CurveArrows(shortEdge, 2)
#(2)Stair Width
stairWidth = (rs.CurveLength(shortEdge) - minGapSize) / 2
#LandingRect
landing1Plane = rs.PlaneFromFrame(rs.CurveStartPoint(shortEdge),
shortVecRev, longVecRev)
landing1 = rs.AddRectangle(landing1Plane,
rs.CurveLength(shortEdge), stairWidth)
landing2Plane = rs.PlaneFromFrame(rs.CurveEndPoint(longEdge),
shortVec, longVec)
landing2 = rs.AddRectangle(landing2Plane,
rs.CurveLength(shortEdge), stairWidth)
#(3)Run Length
runLength = rs.CurveLength(longEdge) - (stairWidth * 2)
#RunRects
run1Plane = rs.PlaneFromFrame(
rs.CurveEditPoints(landing1)[3], shortVecRev, longVecRev)
run1Rect = rs.AddRectangle(run1Plane, stairWidth, runLength)
run2Plane = rs.PlaneFromFrame(
rs.CurveEditPoints(landing2)[3], shortVec, longVec)
run2Rect = rs.AddRectangle(run2Plane, stairWidth, runLength)
#(4)Num Flights between Landings
numLevels = len(landingLevels)
deltaLevels = []
runsPerLevel = []
maxRisersPerRun = math.floor(runLength / minTread)
numRuns = 0
for i in range(0, numLevels - 1):
deltaLevels.append(landingLevels[i + 1] - landingLevels[i])
minNumRisers = math.ceil(deltaLevels[i] / maxRiser)
runsPerLevel.append(math.ceil(minNumRisers / maxRisersPerRun))
numRuns = numRuns + int(runsPerLevel[i])
#(5) Which flights
listOfRuns = []
for i in range(0, numRuns):
if i % 2: #if even
listOfRuns.append(rs.CopyObject(run1Rect))
else:
listOfRuns.append(rs.CopyObject(run2Rect))
#(6) Num Treads per run
runsDeltaHeight = []
for i in range(0, numLevels - 1):
for j in range(0, int(runsPerLevel[i])):
runsDeltaHeight.append(deltaLevels[i] / runsPerLevel[i])
numRisersPerRun = []
for i in range(0, numRuns):
numRisersPerRun.append(math.ceil(runsDeltaHeight[i] /
maxRiser))
#(7) Move Runs
elevation = 0
landings = []
for i in range(0, numRuns):
elevation = elevation + runsDeltaHeight[i]
translation = rs.VectorCreate([0, 0, elevation], [0, 0, 0])
rs.MoveObject(listOfRuns[i], translation)
if i % 2:
landings.append(
rs.MoveObject(rs.CopyObject(landing2), translation))
else:
landings.append(
rs.MoveObject(rs.CopyObject(landing1), translation))
#(8) Make Landings
stairGeo = []
for i in range(0, numRuns):
dir = rs.VectorCreate([0, 0, 0], [0, 0, runsDeltaHeight[i]])
#rs.MoveObject(landings[i], dir)
path = rs.AddLine([0, 0, 0], [0, 0, -thickness])
geo = rs.ExtrudeCurve(landings[i], path)
rs.CapPlanarHoles(geo)
stairGeo.append(geo)
rs.DeleteObject(path)
rs.DeleteObjects(landings)
#(9) Draw Stairs
runs = []
for i in range(0, numRuns):
runs.append(
Run(listOfRuns[i], runsDeltaHeight[i], numRisersPerRun[i]))
stairGeo.append(runs[i].make())
finalGeo = rs.BooleanUnion(stairGeo, delete_input=True)
#Cleanup
rs.DeleteObjects(listOfRuns)
rs.DeleteObjects(rectSegments)
rs.DeleteObject(landing1)
rs.DeleteObject(landing2)
rs.DeleteObject(run1Rect)
rs.DeleteObject(run2Rect)
print "done"
return finalGeo
def lvlxform(obj):
lvlkey = rs.GetUserText(obj, 'level')
vec = vecs[lvlkey]
if isreverse:
vec = rs.VectorReverse(vec)
rs.MoveObject(obj, vec)
def makeFireStair(rect, landingLevels):
#HARD VARIABLES
minStairWidth = 1.118
minHeadroom = 2.032
maxRunRise = 3.658
minNumRisers = 3
minGapSize = .2
minTread = .280
maxTread = .400
minRiser = .100
maxRiser = .180
thickness = .25
maxRisersInRun = 16
maxWidth = 2.4
scissorStair = False
hdrlHeight = .900
#hdrlTopExtension = .305
#hdrlBtmExtension = 1*treadDepth
#hdrlMaxProjection = .114
#(1)Determine Run Direction
rs.SimplifyCurve(rect)
rectSegments = rs.ExplodeCurves(rect)
edge1 = rectSegments[0]
edge3 = rectSegments[1]
if rs.CurveLength(edge1) > rs.CurveLength(edge3):
longEdge = edge1
shortEdge = edge3
else:
longEdge = edge3
shortEdge = edge1
longVec = rs.VectorCreate(rs.CurveStartPoint(longEdge),
rs.CurveEndPoint(longEdge))
longVecRev = rs.VectorReverse(longVec)
shortVec = rs.VectorCreate(rs.CurveStartPoint(shortEdge),
rs.CurveEndPoint(shortEdge))
shortVecRev = rs.VectorReverse(shortVec)
#(2)Stair Width
stairWidth = (rs.CurveLength(shortEdge) - minGapSize) / 2
if stairWidth < .6:
print "ERROR: Stair is ridiculously too narrow."
return
#(3)Run Length
runLength = rs.CurveLength(longEdge) - (stairWidth * 2)
if runLength < 1:
print "ERROR: Stair is ridiculously too short."
return
#LandingRect
landing1Plane = rs.PlaneFromFrame(rs.CurveStartPoint(shortEdge),
shortVecRev, longVecRev)
landing1 = rs.AddRectangle(landing1Plane, rs.CurveLength(shortEdge),
stairWidth)
landing2Plane = rs.PlaneFromFrame(rs.CurveEndPoint(longEdge), shortVec,
longVec)
landing2 = rs.AddRectangle(landing2Plane, rs.CurveLength(shortEdge),
stairWidth)
#RunRects
run1Plane = rs.PlaneFromFrame(
rs.CurveEditPoints(landing1)[3], shortVecRev, longVecRev)
run1Rect = rs.AddRectangle(run1Plane, stairWidth, runLength)
run2Plane = rs.PlaneFromFrame(
rs.CurveEditPoints(landing2)[3], shortVec, longVec)
run2Rect = rs.AddRectangle(run2Plane, stairWidth, runLength)
#(4)Num Flights between Landings
numLevels = len(landingLevels)
deltaLevels = []
runsPerLevel = []
mostRisersInRun = math.floor(runLength / minTread)
if mostRisersInRun > maxRisersInRun:
mostRisersInRun = maxRisersInRun
numRuns = 0
for i in range(0, numLevels - 1):
deltaLevels.append(landingLevels[i + 1] - landingLevels[i])
minNumRisers = math.ceil(deltaLevels[i] / maxRiser)
runsPerLevel.append(math.ceil(minNumRisers / mostRisersInRun))
numRuns = numRuns + int(runsPerLevel[i])
#(5) Which flights
listOfRuns = []
for i in range(0, numRuns):
if i % 2: #if even
listOfRuns.append(rs.CopyObject(run1Rect))
else:
listOfRuns.append(rs.CopyObject(run2Rect))
#(6) Num Treads per run
runsDeltaHeight = []
for i in range(0, numLevels - 1):
for j in range(0, int(runsPerLevel[i])):
runsDeltaHeight.append(deltaLevels[i] / runsPerLevel[i])
numRisersPerRun = []
for i in range(0, numRuns):
numRisersPerRun.append(math.ceil(runsDeltaHeight[i] / maxRiser))
#(7) Move Runs
elevation = 0
landings = []
for i in range(0, numRuns):
elevation = elevation + runsDeltaHeight[i]
translation = rs.VectorCreate([0, 0, elevation], [0, 0, 0])
rs.MoveObject(listOfRuns[i], translation)
if i % 2:
landings.append(rs.MoveObject(rs.CopyObject(landing2),
translation))
else:
landings.append(rs.MoveObject(rs.CopyObject(landing1),
translation))
#(8) Make Landings
stairGeo = []
for i in range(0, numRuns):
dir = rs.VectorCreate([0, 0, 0], [0, 0, runsDeltaHeight[i]])
#rs.MoveObject(landings[i], dir)
path = rs.AddLine([0, 0, 0], [0, 0, -thickness])
geo = rs.ExtrudeCurve(landings[i], path)
rs.CapPlanarHoles(geo)
stairGeo.append(geo)
rs.DeleteObject(path)
rs.DeleteObjects(landings)
#(9) Draw Stairs
runs = []
for i in range(0, numRuns):
runs.append(
Run(listOfRuns[i], runsDeltaHeight[i], numRisersPerRun[i],
thickness, i, maxTread))
stairGeo.append(runs[i].make())
runs[i].makeHandrail(hdrlHeight, minGapSize)
runs[i].printStats()
runs[i].cleanup()
finalGeo = rs.BooleanUnion(stairGeo, delete_input=True)
#(10) Scissor Stairs
if scissorStair:
pt0 = rs.CurveMidPoint(rectSegments[0])
pt1 = rs.CurveMidPoint(rectSegments[1])
pt2 = rs.CurveMidPoint(rectSegments[2])
pt3 = rs.CurveMidPoint(rectSegments[3])
mir1 = rs.MirrorObject(finalGeo, pt0, pt2, copy=True)
mirroredStair = rs.MirrorObject(mir1, pt1, pt3, copy=False)
#(11)Label
rs.SetUserText(finalGeo, "Brew", "Hot Coffee")
if scissorStair:
rs.SetUserText(mirroredStair, "Brew", "Hot Coffee")
#Cleanup
rs.DeleteObjects(listOfRuns)
rs.DeleteObjects(rectSegments)
rs.DeleteObject(landing1)
rs.DeleteObject(landing2)
rs.DeleteObject(run1Rect)
rs.DeleteObject(run2Rect)
print "done"
return None
rs.MessageBox("The domain of the curve is: " + str(crvDom))
#place the text label at the curve length midpoint using the curvature vector as a guide
vect1 = rs.CurveCurvature(crv, rs.CurveClosestPoint(crv,
rs.CurveMidPoint(crv)))[4]
vect1 = rs.VectorUnitize(vect1) * 2
#create the label
dotPt = rs.CopyObject(rs.CurveMidPoint(crv), vect1)
rs.AddTextDot("Midpoint", dotPt)
rs.ObjectColor(rs.AddLine(rs.CurveMidPoint(crv), dotPt), (255, 0, 0))
rs.ObjectColor(rs.AddPoint(rs.CurveMidPoint(crv)), (255, 0, 0))
#Prompt user for curve parameter default at mid (curve domains do not always start at 0)
param = rs.GetReal("Enter Curve Parameter, default is mid",
(crvDom[1] - crvDom[0]) / 2, crvDom[0], crvDom[1])
#evaluate the curve at the middle parameter and place a dot
crvPt = rs.EvaluateCurve(crv, param)
rs.ObjectColor(rs.AddPoint(crvPt), (0, 0, 255))
#place the text label at the curve parameter using the curvature vector as a guide
vect1 = rs.CurveCurvature(crv, param)[4]
#reversing this vector places it at the opposite side of the curve for readbility
vect1 = rs.VectorReverse(rs.VectorUnitize(vect1) * 2)
#draw the label
dotPt = rs.CopyObject(crvPt, vect1)
rs.AddTextDot("Parameter", dotPt)
rs.ObjectColor(rs.AddLine(crvPt, dotPt), (0, 0, 255))
