def RunCommand(is_interactive): global params center = rs.GetPoint(message="Select center point") n = rs.GetInteger(message="Number of teeth", number=params["n"], minimum=4) r = rs.GetReal(message="Outside Diameter", number=params["r"]) m = rs.GetReal(message="Gear module", number=params["m"]) pa = rs.GetReal(message="Pressure angle", number=params["pa"], minimum=0, maximum=45) bool_opts = rs.GetBoolean(message="Output options", items=(("PitchCircle", "No", "Yes"), ), defaults=(params["pc"], )) if None in [center, n, m, pa, bool_opts]: return 1 # Cancel pc = bool_opts[0] params["n"] = n params["m"] = m params["r"] = r params["pa"] = pa params["pc"] = pc cplane = rs.ViewCPlane() # Get current CPlane cplane = rs.MovePlane(cplane, center) xform = rs.XformChangeBasis(cplane, rs.WorldXYPlane()) rs.EnableRedraw(False) old_plane = rs.ViewCPlane(plane=rs.WorldXYPlane()) gear = generate_gear_crv_with_outside(teeth=params["n"], module=params["m"], outside_diam=params["r"], pressure_angle=params["pa"]) rs.ViewCPlane(plane=old_plane) rs.TransformObjects(gear, xform) rs.EnableRedraw(True) if pc: circle = generate_pitch_circle_crv(teeth=params["n"], module=params["m"]) rs.TransformObjects(circle, xform) rs.SelectObjects([gear, circle]) else: rs.SelectObjects(gear) return 0 # Success
def RunCommand(is_interactive): global params pitch_line = rs.GetObject(message="Select pitch line", filter=rs.filter.curve, preselect=True) if pitch_line is None: return 1 # Cancel if not rs.IsLine(pitch_line): print "Selected curve is not a line!" return 1 # Cancel rs.SelectObjects(pitch_line) m = rs.GetReal(message="Rack module", number=params["m"]) pa = rs.GetReal(message="Pressure angle", number=params["pa"], minimum=0, maximum=45) if m is None or pa is None: return 1 # Cancel params["m"] = m params["pa"] = pa pitch_line_center = rs.CurveMidPoint(pitch_line) pitch_line_start = rs.CurveStartPoint(pitch_line) pitch_line_end = rs.CurveEndPoint(pitch_line) angle, reflex_angle = rs.Angle2(line1=((0, 0, 0), (1, 0, 0)), line2=(pitch_line_start, pitch_line_end)) x_vector = rs.VectorCreate(pitch_line_end, pitch_line_start) y_vector = rs.VectorRotate(x_vector, 90.0, [0, 0, 1]) cplane = rs.PlaneFromFrame(origin=pitch_line_center, x_axis=x_vector, y_axis=y_vector) xform = rs.XformChangeBasis(cplane, rs.WorldXYPlane()) rs.EnableRedraw(False) old_plane = rs.ViewCPlane(plane=rs.WorldXYPlane()) rack = draw_rack(length=rs.CurveLength(pitch_line), module=params["m"], pressure_angle=params["pa"]) rs.ViewCPlane(plane=old_plane) rs.TransformObjects(rack, xform) rs.EnableRedraw(True) rs.UnselectAllObjects() rs.SelectObjects(rack) return 0 # Success
def drawDivisionLine(emblem, color=True): objs = [] # line r = 24 for i in range(int(emblem.division)): p = [r, 0, 0] if (emblem.division % 4 == 0): angle = i * 360.0 / emblem.division + 360.0 / emblem.division / 2.0 else: angle = i * 360.0 / emblem.division p = rs.VectorRotate(p, angle, [0, 0, 1]) obj = rs.AddLine([0, 0, 0], p) if (color): layer = "line%s" % (i % int(emblem.division / 2.0)) else: layer = "lineGray" rs.ObjectLayer(obj, layer) objs.append(obj) # circle obj = rs.AddCircle([0, 0, 0], r) if (color): layer = "lineBlack" else: layer = "lineGray" rs.ObjectLayer(obj, layer) objs.append(obj) # text planeOri = rs.ViewCPlane() for i in range(int(emblem.division / 2.0)): if (emblem.division % 4 == 0): angle = i * 360.0 / emblem.division + 360.0 / emblem.division / 2.0 else: angle = i * 360.0 / emblem.division p = [r, 0, 0] txt = "%d" % (angle) height = 1.2 pt = [0, height / 2.0, 0] font_style = 0 justification = 2 + 65536 obj = rs.AddText(txt, pt, height, font, font_style, justification) rs.RotateObject(obj, [0, 0, 0], -90.0, [0, 0, 1], False) rs.MoveObject(obj, [r, 0, 0]) rs.RotateObject(obj, [0, 0, 0], angle, [0, 0, 1], False) rs.ObjectLayer(obj, "textLine") objs.append(obj) rs.ViewCPlane(None, planeOri) #return return objs
def makeEngraves(m, obj): tool_id = m.group(1) operation = m.group(2) z_pos = m.group(3) #restore view cplane p1 = rs.WorldXYPlane() rs.ViewCPlane(None, p1) subtracts = [] if operation == 'Engrave': # return sweepVolume(obj, tool_id, z_pos) subcurves = rs.ExplodeCurves(obj, True) if subcurves: for crv in subcurves: vol = sweepVolume(crv, tool_id, z_pos) if vol: subtracts += vol result = rs.BooleanUnion(subtracts) return result
def main(): print 'test' objs = rs.GetObjects() vec_x = [10,0,0] # restore viewport Cplane p1 = rs.WorldXYPlane() rs.ViewCPlane(None, p1) for obj in objs: if rs.IsBlockInstance(obj) and rs.BlockInstanceName(strObject): xform1 = rs.BlockInstanceXform(obj) crv = rs.AddCurve([ [0,0,0], [0,300,0] ]) xfrom1_inv = rs.TransformObject( crv, (xform1) ) rs.SelectObject(crv) vec1 = rs.CurveEndPoint(crv) - rs.CurveStartPoint(crv) print vec1, math.degrees(calcAngle(vec1, vec_x)) if __name__ == "__main__": main();
def makeEngraves(tool_id, operation, z_pos, obj): #restore view cplane p1 = rs.WorldXYPlane() rs.ViewCPlane(None, p1) subtracts = [] # return [sweepVolume(obj, tool_id, z_pos)] subcurves = rs.ExplodeCurves(obj, False) if subcurves: rs.DeleteObject(obj) for crv in subcurves: volumes = sweepVolume(crv, tool_id, z_pos) if not volumes or len(volumes) < 1: rs.MessageBox('Error with %s, %s, %s' % (tool_id, operation, z_pos)) for vol in volumes: subtracts.append( vol ) else: volumes = sweepVolume(obj, tool_id, z_pos) if not volumes or len(volumes) < 1: rs.MessageBox('Error with %s, %s, %s' % (tool_id, operation, z_pos)) for vol in volumes: subtracts.append( vol ) return subtracts
def profile2(plane, vec): rs.ViewCPlane(None, plane) sec = rs.AddLine((0, 0, 0), (louverW, 0, 0)) sec = rs.RotateObject(sec, plane.Origin, 45.0, plane.ZAxis, copy=True) # if sec: rs.DeleteObjects(sec) return sec
def transformMatrix(): obj_ids = rs.GetObjects("Select object(s) from which to create matrix", 0, True, True) if obj_ids is None: return box = rs.BoundingBox(obj_ids) if not isinstance(box, list): return origin = rs.PointDivide(rs.PointAdd(box[0], box[6]), 2) endpt = rs.GetPoint("To point") newpt = [1, 1, 1] translation1 = rs.VectorCreate(endpt, newpt) translation2 = rs.VectorCreate(translation1, origin) copied_obj_ids = rs.CopyObjects(obj_ids, translation2) for obj in copied_obj_ids: matrix = [] degrees = 90.0 # Some angle radians = math.radians(degrees) c = math.cos(radians) s = math.sin(radians) matrix.append([c, -s, 0, 0]) matrix.append([s, c, 0, 0]) matrix.append([0, 0, 1, 0]) matrix.append([0, 0, 0, 1]) pprint.pprint(matrix) rs.ScaleObject(obj, newpt, [3, 1, -9]) plane = rs.ViewCPlane() pprint.pprint(plane) rs.RotateObject(obj, newpt, uniform(0, 360), plane.XAxis) rs.RotateObject(obj, newpt, uniform(0, 360), plane.YAxis) rs.RotateObject(obj, newpt, uniform(0, 360), plane.ZAxis)
def RunCommand(is_interactive): ringSize = rs.GetReal("Ring size", 8.5, 0, 16) center = rs.GetPoint("Location") plane = rs.MovePlane(rs.ViewCPlane(), center) radius = (11.63 + 0.8128 * ringSize) * 0.5 objId = rs.AddCircle(plane, radius) rs.SelectObject(objId)
def cPlaneLvl(): userstr = rs.GetDocumentUserText("levels") objdict = ast.literal_eval(userstr) for i in objdict: lvlname = i["level"] elevation = float(i["elevation"]) newplane = rs.CreatePlane((0, 0, elevation)) rs.ViewCPlane(None, newplane) rs.AddNamedCPlane(lvlname)
def Orthographic_Cplane(): cpln_current = rs.ViewCPlane() Bool_Osnap = rs.Osnap() point = cpln_current.Origin if Bool_Osnap: rs.Osnap(False) rs.Command("_Circle 0,0,0 ") # rs.EnableRedraw(False) # Circle = rs.LastCreatedObjects() if Bool_Osnap: rs.Osnap(True) if Circle is None: # rs.EnableRedraw(True) # return if not rs.IsObject(Circle): rs.EnableRedraw(True) return rs.Command("_Point 0,0,1 ") pt_pos = rs.LastCreatedObjects() rs.Command("_Point 0,0,-1 ") pt_neg = rs.LastCreatedObjects() pt_cam = rs.ViewCamera() dist_pos = rs.Distance(pt_cam,pt_pos) dist_neg = rs.Distance(pt_cam,pt_neg) print pt_cam Disk = rs.AddPlanarSrf(Circle) rs.UnselectAllObjects() rs.SelectObjects(Disk) if dist_pos>dist_neg: rs.Command("OrientCameraToSrf _f 0,0,0 _pause") else: rs.Command("OrientCameraToSrf 0,0,0 _pause") rs.DeleteObjects((pt_pos,pt_neg,Circle,Disk)) rs.ViewProjection(None,1)
def Func(crvID): if rs.IsLine(crvID): plane = rs.ViewCPlane() else: plane = rs.CurvePlane(crvID) crv = sc.doc.Objects.Find(crvID).Geometry # if t_style==1: trans=Rhino.Geometry.CurveOffsetCornerStyle.Sharp # elif t_style==2: trans=Rhino.Geometry.CurveOffsetCornerStyle.Round # elif t_style==3: trans=Rhino.Geometry.CurveOffsetCornerStyle.Smooth # elif t_style==4: trans=Rhino.Geometry.CurveOffsetCornerStyle.Chamfer offset1 = crv.Offset(plane, dist, tol, trans) offset1ID = sc.doc.Objects.AddCurve(offset1[0])
def CreateCircle(circumference=None): center = rs.GetPoint("Center point of circle") if center: plane = rs.MovePlane(rs.ViewCPlane(), center) length = circumference if length is None: length = rs.GetReal("Circle circumference") if length and length > 0: radius = length / (2 * math.pi) objectId = rs.AddCircle(plane, radius) rs.SelectObject(objectId) return length return None
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 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 convertTextToPolylines2(obj): # get object properties text = rs.TextObjectText(obj) pt = rs.TextObjectPoint(obj) origin = rs.coerce3dpoint([0, 0, 0]) ht = rs.TextObjectHeight(obj) object_layer = rs.ObjectLayer(obj) plane = rs.TextObjectPlane(obj) diff = rs.coerce3dpoint([pt.X, pt.Y, pt.Z]) p1 = rs.WorldXYPlane() #restore view cplane rs.ViewCPlane(None, p1) matrix = rs.XformRotation4(p1.XAxis, p1.YAxis, p1.ZAxis, plane.XAxis, plane.YAxis, plane.ZAxis) rs.DeleteObject(obj) # split text at enters text = text.split('\r\n') opts = 'GroupOutput=No FontName="' + EXPORT_FONT + '" Italic=No Bold=No Height=' + str( ht) opts += " Output=Curves AllowOpenCurves=Yes LowerCaseAsSmallCaps=No AddSpacing=No " n_lines = len(text) origin.Y += 1.6 * ht * (len(text) - 1) polylines = [] for item in text: rs.Command( "_-TextObject " + opts + '"' + item + '"' + " " + str(origin), False) polylines += rs.LastCreatedObjects() origin.Y -= ht * 1.6 rs.ObjectLayer(polylines, object_layer) polylines = rs.ScaleObjects(polylines, (0, 0, 0), (0.7, 1, 1), True) # transform to old position rs.TransformObjects(polylines, matrix, copy=False) rs.MoveObjects(polylines, diff) return polylines
def OffsetCurve2Sides(crvID, dist, t_style, conn, tol): if rs.IsLine(crvID): plane = rs.ViewCPlane() else: plane = rs.CurvePlane(crvID) crv = sc.doc.Objects.Find(crvID).Geometry if t_style == 1: trans = Rhino.Geometry.CurveOffsetCornerStyle.Sharp elif t_style == 2: trans = Rhino.Geometry.CurveOffsetCornerStyle.Round elif t_style == 3: trans = Rhino.Geometry.CurveOffsetCornerStyle.Smooth elif t_style == 4: trans = Rhino.Geometry.CurveOffsetCornerStyle.Chamfer offset1 = crv.Offset(plane, dist, tol, trans) if offset1: offset2 = crv.Offset(plane, -dist, tol, trans) if offset2: if len(offset1) == 1 and len(offset2) == 1: offset1ID = sc.doc.Objects.AddCurve(offset1[0]) offset2ID = sc.doc.Objects.AddCurve(offset2[0]) if conn >= 0 and not rs.IsCurveClosed(crvID): AddEndsToOffset(offset1ID, offset2ID, conn, dist) #don't care if ends get made or not, exit afterward return True
def ProjectPlan(objs, plane): print "Projecting Plan" try: rs.SelectObjects(objs) except: rs.SelectObject(objs) rs.AddNamedCPlane('c_prev') rs.AddNamedCPlane('c_temp') rs.ViewCPlane(plane=plane) rs.Command('-_Make2d l c p f _Enter', False) projLines = rs.SelectedObjects() rs.DeleteNamedCPlane('c_temp') rs.RestoreNamedCPlane('c_prev') rs.DeleteNamedCPlane('c_prev') for line in projLines: rs.ObjectColor(line, (200, 200, 200)) return projLines
def main(): # get objects to export objs = rs.GetObjects("select objects to move to worldXY", 0, True, True) if not objs: print "moveToXY aborted" return rs.EnableRedraw(False) # reset world xy rs.ViewCPlane(None, rs.WorldXYPlane()) for obj in objs: # get lowest point point = getLowestPoint(obj) # move object to xy plane rs.MoveObject(obj, (0, 0, -point.Z)) rs.EnableRedraw(True)
def SampleArrayCrv(): obj_ids = rs.GetObjects("Select objects to array") if not obj_ids: return base_pt = rs.GetPoint("Base point") if not base_pt: return plane = rs.ViewCPlane() plane.Origin = base_pt crv_id = rs.GetObject("Select path curve") if not crv_id: return count = rs.GetInteger("Number of items", 2, 2) if not count: return if rs.IsCurveClosed(crv_id): count -= 1 crv_t = rs.DivideCurve(crv_id, count, False, False) for t in crv_t: frame = rs.CurveFrame(crv_id, t) xform = rs.XformRotation1(plane, frame) rs.TransformObjects(obj_ids, xform, True)
def __reset_view(self): rs.ViewCPlane(None, rs.WorldXYPlane() ) rs.Command("_Zoom _A _E _Enter") rs.Command("_SelAll") rs.Command("_Shade _d=r _Enter") rs.Command("_SelNone")
def main(): global inner_curves, outer_curves, curve_coords # save for later orig_hidden_objects = rs.HiddenObjects() # we put reference points in the dogbone-ref layer, so create it if it doesn't exist rs.AddLayer("dogbone-ref") panel, face = getsubsurface.GetSubSurface("select dogbone face") diameter = rs.GetReal("enter cutter diameter", number=0.25) diameter = diameter * 1.1 rs.EnableRedraw(False) # 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) rs.ProjectOsnaps(True) outer_curves = rs.DuplicateSurfaceBorder(face, 1) inner_curves = rs.DuplicateSurfaceBorder(face, 2) # make a dict mapping each curve to the coords in that curve curve_coords = dict() for curve in outer_curves + inner_curves: coords = rs.CurvePoints(curve)[:-1] curve_coords[curve] = coords # make a dict mapping each curve to the z component of its cross product at each index curve_cross_zs = dict() for curve, coords in curve_coords.items(): proj_coords = [rs.SurfaceClosestPoint(face, coord) for coord in coords] cross_zs = [] for idx in range(len(proj_coords)): triplet = [ proj_coords[(idx + 1) % len(proj_coords)], proj_coords[idx], proj_coords[(idx - 1) % len(proj_coords)] ] v0 = (triplet[1][0] - triplet[0][0], triplet[1][1] - triplet[0][1], 0) v1 = (triplet[2][0] - triplet[1][0], triplet[2][1] - triplet[1][1], 0) cross_z = rs.VectorCrossProduct(v0, v1)[2] cross_zs.append(cross_z) curve_cross_zs[curve] = cross_zs points = [] bones = [] temp_points = [] rs.EnableRedraw(True) while True: coord = rs.GetPoint("select corner") if coord is None: break try: curve, idx = get_curve_and_idx_for_coord(coord) point = rs.AddPoint(coord) rs.ObjectColor(point, (255, 0, 0)) temp_points.append(point) bones.append((curve, idx)) except ValueError: print "invalid curve point" continue rs.EnableRedraw(False) rs.DeleteObjects(temp_points) # try to automatically identify dogbone points if user selected none if len(bones) == 0: for curve, coords in curve_coords.items(): proj_coords = [ rs.SurfaceClosestPoint(face, coord) for coord in coords ] for idx in range(len(proj_coords)): triplet = [ proj_coords[(idx + 1) % len(proj_coords)], proj_coords[idx], proj_coords[(idx - 1) % len(proj_coords)] ] if curve_cross_zs[curve][idx] > 0: bones.append((curve, idx)) # make the bones extrusions = [] for bone in bones: curve, idx = bone coords = curve_coords[curve] point = rs.AddPoint(coords[idx]) rs.ObjectLayer(point, "dogbone-ref") triplet = [ coords[(idx + 1) % len(coords)], coords[idx], coords[(idx - 1) % len(coords)], ] angle = rs.Angle2( (triplet[1], triplet[0]), (triplet[1], triplet[2]), ) angle = angle[0] # This is a hacky method to determine the handedness of the curve # the cross product SHOULD have worked here, but for some reason # it did not. v0 = triplet[2][0] - triplet[1][0], triplet[2][1] - triplet[1][1], 0 v1 = triplet[1][0] - triplet[0][0], triplet[1][1] - triplet[0][1], 0 _angle = math.degrees( math.atan2(v0[1], v0[0]) - math.atan2(v1[1], v1[0])) while _angle > 180: _angle -= 360 while _angle < -180: _angle += 360 if math.copysign(1, angle) != math.copysign(1, _angle): angle -= 180 point = rs.VectorAdd( triplet[1], rs.VectorRotate( 0.5 * diameter * rs.VectorUnitize(rs.VectorSubtract(triplet[2], triplet[1])), angle / 2, (0, 0, 1))) circle = rs.AddCircle((point.X, point.Y, -10), diameter / 2.0) circle_srf = rs.AddPlanarSrf(circle) p0 = (point.X, point.Y, -10) p1 = (point.X, point.Y, 10) line = rs.AddLine(p0, p1) extrusion = rs.ExtrudeSurface(circle_srf, line) extrusions.append(extrusion) rs.DeleteObjects([circle, circle_srf, line]) rs.BooleanDifference([panel], extrusions, delete_input=True) rs.DeleteObject(panel) rs.DeleteObjects(extrusions) rs.DeleteObjects(points) rs.DeleteObjects(inner_curves) rs.DeleteObjects(outer_curves) rs.DeleteObject(face) rs.ShowObject(rs.AllObjects()) rs.HideObjects(orig_hidden_objects) rs.EnableRedraw(True)
def optimization_rotate(_origin_point, _x_point, _y_point, _unused_srf, _unused_line, _unused_polyline, _unused_mark_line, _used_srf1, unused_timber, tolerance): start_time = time.time() # 初期変数 origin_point = _origin_point x_point = _x_point y_point = _y_point unused_srf = _unused_srf unused_line = _unused_line unused_polyline = _unused_polyline unused_mark_line = _unused_mark_line used_srf1 = _used_srf1 angle1 = 0.1 angle2 = -0.03 curve_length = [] count1 = 0 angle2_flag = False end_joint_count = 0 # 回転平面を定義する new_plane = rs.PlaneFromPoints(origin_point, x_point, y_point) rs.ViewCPlane(None, new_plane) rotate_p = origin_point vec1 = rs.VectorCreate(x_point, rotate_p) vec2 = rs.VectorCreate(y_point, rotate_p) cross = rs.VectorCrossProduct(vec1, vec2) cross_unit = rs.VectorUnitize(cross) rotate_vec = rs.VectorScale(cross_unit, 100) # 描画 # rotate_axis = AddVector(rotate_p, rotate_vec) # print("-------------------------------------------------------") # 衝突判定 for i in range(200): curve = rs.IntersectBreps(unused_srf, used_srf1) # もし接触しなかった場合 if curve is None: curve_length = [] if i == 0: angle2_flag = True angle2 = -1.0 if i == 1: angle = (angle1 * -1.1) rs.RotateObject(unused_srf, rotate_p, angle, rotate_vec) rs.RotateObject(unused_line, rotate_p, angle, rotate_vec) rs.RotateObject(unused_polyline, rotate_p, angle, rotate_vec) rs.RotateObject(unused_mark_line[0], rotate_p, angle, rotate_vec) rs.RotateObject(unused_mark_line[1], rotate_p, angle, rotate_vec) if i == 199: print("tan2: Can not optimize") # input("Can not optimize") # object削除 if curve: for k in range(0, len(curve)): rs.DeleteObject(curve[k]) # 平面をもとのxy平面に戻す origin_point = (0, 0, 0) x_point = (100, 0, 0) y_point = (0, 100, 0) new_plane = rs.PlaneFromPoints(origin_point, x_point, y_point) rs.ViewCPlane(None, new_plane) # run time console end_time = time.time() optimization_rotate_run_time = end_time - start_time # print("---------------------------------------------------") # print("optimization_rotate Run time: %s" % optimization_rotate_run_time) return False # console # print("There is not curve[%s] angle2: %s" % (i, angle2)) rs.RotateObject(unused_srf, rotate_p, angle2, rotate_vec) rs.RotateObject(unused_line, rotate_p, angle2, rotate_vec) rs.RotateObject(unused_polyline, rotate_p, angle2, rotate_vec) rs.RotateObject(unused_mark_line[0], rotate_p, angle2, rotate_vec) rs.RotateObject(unused_mark_line[1], rotate_p, angle2, rotate_vec) count1 = count1 + 1 # もし20回連続で接触しない場合、回転方向を逆転する if count1 == 10 and angle2_flag: angle2 = angle2 * -1.0 angle = 10 * angle2 rs.RotateObject(unused_srf, rotate_p, angle, rotate_vec) rs.RotateObject(unused_line, rotate_p, angle, rotate_vec) rs.RotateObject(unused_polyline, rotate_p, angle, rotate_vec) rs.RotateObject(unused_mark_line[0], rotate_p, angle, rotate_vec) rs.RotateObject(unused_mark_line[1], rotate_p, angle, rotate_vec) angle2_flag = False continue # もし接触した場合 else: length = 0 for j in range(0, len(curve)): if rs.IsCurve(curve[j]): length = length + rs.CurveLength(curve[j]) else: rs.RotateObject(unused_srf, rotate_p, angle1, rotate_vec) rs.RotateObject(unused_line, rotate_p, angle1, rotate_vec) rs.RotateObject(unused_polyline, rotate_p, angle1, rotate_vec) rs.RotateObject(unused_mark_line[0], rotate_p, angle1, rotate_vec) rs.RotateObject(unused_mark_line[1], rotate_p, angle1, rotate_vec) continue # 接点2の接触部の長さを格納する curve_length.append(length) # もし衝突交線の値が大きくなる場合、回転の方向を逆転する if len(curve_length) == 5: if curve_length[0] < curve_length[1] < curve_length[ 2] < curve_length[3] < curve_length[4]: angle1 = angle1 * -1.0 # print("update angle1") # print("angle1: %s" % angle1) angle = 3.0 * angle1 rs.RotateObject(unused_srf, rotate_p, angle, rotate_vec) rs.RotateObject(unused_line, rotate_p, angle, rotate_vec) rs.RotateObject(unused_polyline, rotate_p, angle, rotate_vec) rs.RotateObject(unused_mark_line[0], rotate_p, angle, rotate_vec) rs.RotateObject(unused_mark_line[1], rotate_p, angle, rotate_vec) curve_length = [] # 接合条件を満たした場合 if length < tolerance: select_curve = curve[0] reference_point = createMidPointFromCurve(select_curve) check_domain = unused_timber.judgeSurfaceDomain( reference_point) # もし接触部が端部(domainが0か8の時) if check_domain == 0 or check_domain == 8: rs.RotateObject(unused_srf, rotate_p, angle1, rotate_vec) rs.RotateObject(unused_line, rotate_p, angle1, rotate_vec) rs.RotateObject(unused_polyline, rotate_p, angle1, rotate_vec) rs.RotateObject(unused_mark_line[0], rotate_p, angle1, rotate_vec) rs.RotateObject(unused_mark_line[1], rotate_p, angle1, rotate_vec) end_joint_count = end_joint_count + 1 if end_joint_count == 2: # print("tan2: Can not optimize(joint is ends)") # run time console end_time = time.time() optimization_rotate_run_time = end_time - start_time # print("---------------------------------------------------") # print("optimization_rotate Run time: %s" % optimization_rotate_run_time) return False continue else: # print("tan2 <count: %s | curve_length = %s>" % (i, length)) # 平面をもとのxy平面に戻す origin_point = (0, 0, 0) x_point = (100, 0, 0) y_point = (0, 100, 0) new_plane = rs.PlaneFromPoints(origin_point, x_point, y_point) rs.ViewCPlane(None, new_plane) # run time console end_time = time.time() optimization_rotate_run_time = end_time - start_time # print("optimization_rotate Run time: %s" % optimization_rotate_run_time) return curve # 接合条件を満たさなかった場合 else: # angleを更新 if length < 45: if angle1 > 0: angle1 = 0.05 else: angle1 = -0.05 elif length < 60: if angle1 > 0: angle1 = 0.25 else: angle1 = -0.25 elif length < 70: if angle1 > 0: angle1 = 0.35 else: angle1 = -0.35 elif length < 100: if angle1 > 0: angle1 = 0.65 else: angle1 = -0.65 elif length < 120: if angle1 > 0: angle1 = 1.75 else: angle1 = -1.75 else: if angle1 > 0: angle1 = 2.0 else: angle1 = -2.0 rs.RotateObject(unused_srf, rotate_p, angle1, rotate_vec) rs.RotateObject(unused_line, rotate_p, angle1, rotate_vec) rs.RotateObject(unused_polyline, rotate_p, angle1, rotate_vec) rs.RotateObject(unused_mark_line[0], rotate_p, angle1, rotate_vec) rs.RotateObject(unused_mark_line[1], rotate_p, angle1, rotate_vec) # print("curve length[%s]: %s | angle1: %s" % (i, length, angle1)) # object削除 for k in range(0, len(curve)): rs.DeleteObject(curve[k]) if i == 199: # print("tan2: Can not optimize") if curve: for k in range(0, len(curve)): rs.DeleteObject(curve[k]) # 平面をもとのxy平面に戻す origin_point = (0, 0, 0) x_point = (100, 0, 0) y_point = (0, 100, 0) new_plane = rs.PlaneFromPoints(origin_point, x_point, y_point) rs.ViewCPlane(None, new_plane) # run time console end_time = time.time() optimization_rotate_run_time = end_time - start_time # print("---------------------------------------------------") # print("optimization_rotate Run time: %s" % optimization_rotate_run_time) return False
def RunCommand(is_interactive): global params center = rs.GetPoint(message="Select center point") n = rs.GetInteger(message="Number of teeth", number=params["n"], minimum=4) m = rs.GetReal(message="Gear module", number=params["m"]) pa = rs.GetReal(message="Pressure angle", number=params["pa"], minimum=0, maximum=45) ca = rs.GetReal(message="Cone angle", number=params["ca"], minimum=0, maximum=180) bool_opts = rs.GetBoolean(message="Output options", items=(("PitchCone", "No", "Yes"),), defaults=(params["pc"],)) if None in [center, n, m, pa, ca, bool_opts]: return 1 # Cancel pc = bool_opts[0] params["n"] = n params["m"] = m params["pa"] = pa params["ca"] = ca params["pc"] = pc cplane = rs.ViewCPlane() # Get current CPlane cplane = rs.MovePlane(cplane, center) xform = rs.XformChangeBasis(cplane, rs.WorldXYPlane()) rs.EnableRedraw(False) old_plane = rs.ViewCPlane(plane=rs.WorldXYPlane()) gear = generate_gear_crv(teeth=params["n"], module=params["m"], pressure_angle=params["pa"], cone_angle=params["ca"]) # Calculate pitch cone tip cone_tip = [0, 0, (m * n / 2) / tan(radians(ca/2))] bevel_gear_srf = rs.ExtrudeCurvePoint(gear, cone_tip) rs.ViewCPlane(plane=old_plane) rs.TransformObjects(bevel_gear_srf, xform) if pc: circle = generate_pitch_circle_crv(teeth=params["n"], module=params["m"]) pitch_cone_srf = rs.ExtrudeCurvePoint(circle, cone_tip) rs.TransformObjects(pitch_cone_srf, xform) rs.DeleteObjects([gear, circle]) rs.SelectObjects([bevel_gear_srf, pitch_cone_srf]) else: rs.DeleteObject(gear) rs.SelectObjects(bevel_gear_srf) rs.EnableRedraw(True) return 0 # Success
def testDuplicationsAndSpaceAndScaleAndRotate(): print("\n testDuplicationsAndSpaceAndScaleAndRotate commands \n") obj_ids = rs.GetObjects( "Select object(s) from which to create the rectangular matrix", 0, True, True) if obj_ids is None: return box = rs.BoundingBox(obj_ids) if not isinstance(box, list): return origin = rs.PointDivide(rs.PointAdd(box[0], box[6]), 2) nXdups = rs.GetInteger("Max Duplications X", 1, 1) nYdups = rs.GetInteger("Max Duplications Y", 1, 1) nZdups = rs.GetInteger("Max Duplications Z", 1, 1) nXspace = rs.GetReal("Spacing X", 1, 0) rXspace = rs.GetReal("Spacing X rand", 0, 0, 100) / 100 nYspace = rs.GetReal("Spacing Y", 1, 0) rYspace = rs.GetReal("Spacing Y rand", 0, 0, 100) / 100 nZspace = rs.GetReal("Spacing Z", 1, 0) rZspace = rs.GetReal("Spacing Z rand", 0, 0, 100) / 100 nXscale = rs.GetReal("Scale X", 1, 0) rXscale = rs.GetReal("Scale X rand", 0, 0, 100) / 100 nYscale = rs.GetReal("Scale Y", 1, 0) rYscale = rs.GetReal("Scale Y rand", 0, 0, 100) / 100 nZscale = rs.GetReal("Scale Z", 1, 0) rZscale = rs.GetReal("Scale Z rand", 0, 0, 100) / 100 nXrotate = rs.GetReal("Rotate X", 0, 0, 360) rXrotate = rs.GetReal("Rotate X rand", 0, 0, 100) / 100 nYrotate = rs.GetReal("Rotate Y", 0, 0, 360) rYrotate = rs.GetReal("Rotate Y rand", 0, 0, 100) / 100 nZrotate = rs.GetReal("Rotate Z", 0, 0, 360) rZrotate = rs.GetReal("Rotate Z rand", 0, 0, 100) / 100 rKeep = 1 - rs.GetReal("Percent to erase", 0, 0, 100) / 100 endpt = rs.GetPoint("To point") sample_near_val = lambda val, rand: random.uniform(-rand * val, rand * val) translations = [] # Copy Points with Spacing for k in range(nZdups): for j in range(nYdups): for i in range(nXdups): newpt = [ origin[0] + i * nXspace + sample_near_val(nXspace, rXspace), origin[1] + j * nYspace + sample_near_val(nYspace, rYspace), origin[2] + k * nZspace + sample_near_val(nZspace, rZspace) ] translations = translations + [rs.VectorCreate(endpt, newpt)] nObjs = len(translations) objs_to_keep = random.sample(range(nObjs), int(round(nObjs * rKeep))) translations = [translations[i] for i in objs_to_keep] copied_objs = [] for tr in translations: copied_objs = copied_objs + rs.CopyObjects(obj_ids, tr) for obj in copied_objs: bb = rs.BoundingBox(obj) if bb: center_point = rs.PointDivide(rs.PointAdd(bb[0], bb[6]), 2) # pt = rs.SurfaceVolumeCentroid(obj) rs.ScaleObject(obj, center_point, [ nXscale + sample_near_val(nXscale, rXscale), nYscale + sample_near_val(nYscale, rYscale), nZscale + sample_near_val(nZscale, rZscale) ]) plane = rs.ViewCPlane() rs.RotateObject(obj, center_point, nXrotate + sample_near_val(nXrotate, rXrotate), plane.XAxis) rs.RotateObject(obj, center_point, nYrotate + sample_near_val(nYrotate, rYrotate), plane.YAxis) rs.RotateObject(obj, center_point, nZrotate + sample_near_val(nZrotate, rZrotate), plane.ZAxis)
def SetPlaneOrigin(): plane_origin = rs.PlaneFromPoints((0, 0, 0), (100, 0, 0), (0, 100, 0)) rs.ViewCPlane(None, plane_origin)
import rhinoscriptsyntax as rs # !-RunPythonScript "wallsFromCrvs.py" objs = rs.GetObjects("Pick curves to loft", rs.filter.curve, preselect=True) width = rs.GetReal("width", 0.4) height = rs.GetReal("height", 3) plane = rs.ViewCPlane() def wallBaseSrf(crv, width): rs.SimplifyCurve(crv) if rs.IsCurveClosed(crv): domain = rs.CurveDomain(crv) parameter = (domain[0] + domain[1]) / 2.0 rs.CurveSeam(crv, parameter) offsets = map(lambda x: rs.OffsetCurve(crv, [0, 0, 0], x), [width / 2, -width / 2]) section = rs.AddLoftSrf(offsets, loft_type=2) if offsets: rs.DeleteObjects(offsets) if rs.IsPolysurface(section): return rs.ExplodePolysurfaces(section, delete_input=True) return section def makeBrep(srf): point1 = rs.EvaluateSurface(srf, 0, 0) vec = rs.CreateVector(0, 0, height) point2 = rs.CopyObject(point1, vec) line = rs.AddLine(point1, point2) brep = rs.ExtrudeSurface(srf, line)
def MultiNestedBoundaryTrimCurves(): msg="Select closed boundary curves for trimming" TCrvs = rs.GetObjects(msg, 4, preselect=False) if not TCrvs: return cCrvs=[crv for crv in TCrvs if rs.IsCurveClosed(crv)] if len(cCrvs)==0: print "No closed trim curves found" return rs.LockObjects(cCrvs) origCrvs = rs.GetObjects("Select curves to trim", 4) rs.UnlockObjects(cCrvs) if not origCrvs : return #plane which is active when trim curve is chosen refPlane = rs.ViewCPlane() if sc.sticky.has_key("TrimSideChoice"): oldTSChoice = sc.sticky["TrimSideChoice"] else: oldTSChoice=True choice = [["Trim", "Outside", "Inside"]] res = rs.GetBoolean("Side to trim away?", choice, [oldTSChoice]) if not res: return trimIns = res[0] #False=Outside tol=sc.doc.ModelAbsoluteTolerance bb=rs.BoundingBox(origCrvs,refPlane) #CPlane box, world coords if not bb: return zVec=refPlane.ZAxis rs.EnableRedraw(False) botPlane=Rhino.Geometry.Plane(bb[0]-zVec,zVec) #check xform=rs.XformPlanarProjection(botPlane) cutCrvs=rs.TransformObjects(cCrvs,xform,True) ccc=CheckPlanarCurvesForCollision(cutCrvs) if ccc: msg="Boundary curves overlap, results may be unpredictable, continue?" res=rs.MessageBox(msg,1+32) if res!= 1: return bSrfs=rs.AddPlanarSrf(cutCrvs) rs.DeleteObjects(cutCrvs) if bSrfs == None: return line=rs.AddLine(bb[0]-zVec,bb[4]+zVec) vols=[] for srf in bSrfs: ext=rs.ExtrudeSurface(srf,line,True) if ext != None: vols.append(ext) rs.DeleteObjects(bSrfs) rs.DeleteObject(line) if len(vols)==0: return exGroup=rs.AddGroup() rs.AddObjectsToGroup(vols,exGroup) rs.Prompt("Splitting curves...") rs.SelectObjects(origCrvs) rs.Command("_Split _-SelGroup " + exGroup + " _Enter", False) splitRes=rs.LastCreatedObjects() rs.DeleteGroup(exGroup) rs.Prompt("Classifying trims...") noSplit=[] for crv in origCrvs: #add curve to list if it has not been split (still exists in doc) id=sc.doc.Objects.Find(crv) if id != None: noSplit.append(crv) errors=0 if splitRes: if len(noSplit)>0: splitRes.extend(noSplit) for crv in splitRes: inside=MultiTestInOrOut(crv,vols) if inside != None: if (inside and trimIns) or (not inside and not trimIns): rs.DeleteObject(crv) else: errors+=1 rs.DeleteObjects(vols) if errors>0: print "Problems with {} curves".format(errors) sc.sticky["TrimSideChoice"] = trimIns
# Draw object based on input emotion switch_on_new_emotion(object_id) else: exit_script() if __name__ == "__main__": # Fixes data reload problem in Rhino construction_functions = reload(construction_functions) emotion_class = reload(emotion_class) config = reload(config) # clear_all() # reset_view() rs.Command("_SelAll") rs.Command("Delete") rs.ViewCPlane(None, rs.WorldXYPlane() ) rs.Command("_Zoom _A _E _Enter") rs.Command("_SelAll") rs.Command("_Shade _d=r _Enter") rs.Command("_SelNone") next_action = "" while next_action != "n" and next_action not in config.exit_commands: next_action = rs.GetString('Enter (n) for new object') if next_action == "n": switch_on_new_object() else: exit_script()
def __generate_individual_levels(self, crosssectionplane, loft_height): cplane = rs.ViewCPlane(None, crosssectionplane) level_points = [] spikiness = self.emotion_properties["spikiness"] # max spikiness = 1 scaling_factor_aid = 0.2 * spikiness #draws profile curves on each spine level for i in xrange(self.emotion_properties["horizontal_AR"][loft_height] ["points_in_curve"]): scaling_factor = 1 - scaling_factor_aid if i % 2 == 0 else 1 #ranges from a difference in 0.8 and 1 (no difference) angle = 2 * math.pi * i / self.emotion_properties["horizontal_AR"][ loft_height]["points_in_curve"] x_point = scaling_factor * self.dimensions[ "actual_height"] * self.dimensions[ "vertical_AR"] * self.emotion_properties["vertical_AR"][ loft_height] * self.emotion_properties[ "horizontal_AR"][loft_height][ "level_horizontal_AR_x"] * math.cos(angle) / 2 y_point = scaling_factor * self.dimensions[ "actual_height"] * self.dimensions[ "vertical_AR"] * self.emotion_properties["vertical_AR"][ loft_height] * self.emotion_properties[ "horizontal_AR"][loft_height][ "level_horizontal_AR_y"] * math.sin(angle) / 2 z_point = 0 point = rs.XformCPlaneToWorld([x_point, y_point, z_point], cplane) level_points.append(rs.AddPoint(point)) connecting_point = level_points[0] level_points.append(rs.AddPoint(connecting_point)) level_curve = rs.AddCurve( level_points, self.emotion_properties["horizontal_AR"][str( loft_height)]["horizontal_smoothness"]) #twists curve start point 180deg if it is below the spine_x point (to make sure loft doesn't twist) crvStart = rs.CurveStartPoint(level_curve) if crvStart[0] <= self.x_points[int(loft_height) - 1]: crvDomain = rs.CurveDomain(level_curve) rs.CurveSeam(level_curve, (crvDomain[0] + crvDomain[1]) / 2) # add planar surface to top and bottom of bottle if loft_height == "5" or loft_height == "1": rs.AddPlanarSrf(level_curve) # hide curves and points on level profiles rs.HideObjects(level_curve) rs.HideObjects(level_points) # object finishing features if (self.object_id == "Bottle"): if loft_height == "5": rs.AddCylinder(cplane, 14.5, 7.4, cap=True) if (self.object_id == "Chair"): if loft_height == "5": rs.AddCylinder(cplane, 14.5, 7.4, cap=True) if (self.object_id == "Jewelry"): if loft_height == "5": major_radius = 5.0 minor_radius = major_radius - 1.5 # rotated_cplane = rs.RotatePlane(cplane, 45.0, cplane.XAxis) direction = rs.AddPoint((0, 0, 1)) rs.AddTorus(cplane.Origin, major_radius, minor_radius, direction) if (self.object_id == "Totem"): if loft_height == "1": base_width = 80 base_length = 60 base_depth = -10 base_points = [(-base_width / 2, -base_length / 2, 0), (base_width / 2, -base_length / 2, 0), (base_width / 2, base_length / 2, 0), (-base_width / 2, base_length / 2, 0), (-base_width / 2, -base_length / 2, base_depth), (base_width / 2, -base_length / 2, base_depth), (base_width / 2, base_length / 2, base_depth), (-base_width / 2, base_length / 2, base_depth)] rs.AddBox(base_points) return level_curve