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))