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 RemoveFromBlock(): block = rs.GetObject("Select Block to extract objects from", rs.filter.instance, preselect=True) if not block: return blockName = rs.BlockInstanceName(block) objref = rs.coercerhinoobject(block) idef = objref.InstanceDefinition idefIndex = idef.Index XformBlock = rs.BlockInstanceXform(block) blockObjects = rs.BlockObjects(blockName) blockInstanceObjects = rs.TransformObjects(blockObjects, XformBlock, True) objs = rs.GetObjects("Select Objects to extract from Block", objects=blockInstanceObjects) if not objs: rs.DeleteObjects(blockInstanceObjects) return keep = [] #List to keep in block delete = [] #list to delete from block and add to doc rs.EnableRedraw(False) for object in blockInstanceObjects: if object in objs: delete.append(object) else: keep.append(object) if rs.IsBlockReference(blockName): print "Block is referenced from file; unable to modify block" rs.DeleteObjects(keep) return rs.TransformObjects(keep, rs.XformInverse(XformBlock), False) newGeometry = [] newAttributes = [] for object in keep: newGeometry.append(rs.coercegeometry(object)) ref = Rhino.DocObjects.ObjRef(object) attr = ref.Object().Attributes newAttributes.append(attr) InstanceDefinitionTable = sc.doc.ActiveDoc.InstanceDefinitions InstanceDefinitionTable.ModifyGeometry(idefIndex, newGeometry, newAttributes) rs.DeleteObjects(keep) rs.EnableRedraw(True)
def BlockTxt(block, str = False, cstr = False, boolFlipHeb=True): if not block: return blockName = rs.BlockInstanceName(block) objref = rs.coercerhinoobject(block) idef = objref.InstanceDefinition idefIndex = idef.Index XformBlock = rs.BlockInstanceXform(block) blockObjects = rs.BlockObjects(blockName) txtobjs = False for obj in blockObjects: if rs.IsText(obj): if not str: txtobjs = True elif rs.TextObjectText(obj) == str: txtobjs = True if txtobjs: blockInstanceObjects = rs.TransformObjects(blockObjects, XformBlock, True) keep = [] rs.EnableRedraw(False) for obj in blockInstanceObjects: if rs.IsText(obj): if not str and not cstr: str = rs.TextObjectText(obj) cstr = ConvTxt(str, boolFlipHeb) if not cstr == str: rs.TextObjectText(obj, cstr) keep.append(obj) else: keep.append(obj) rs.TransformObjects(keep, rs.XformInverse(XformBlock), False) newGeometry = [] newAttributes = [] for object in keep: newGeometry.append(rs.coercegeometry(object)) ref = Rhino.DocObjects.ObjRef(object) attr = ref.Object().Attributes newAttributes.append(attr) InstanceDefinitionTable = sc.doc.ActiveDoc.InstanceDefinitions InstanceDefinitionTable.ModifyGeometry(idefIndex, newGeometry, newAttributes) rs.DeleteObjects(keep)
def teardown(cfg): print("teardown") cfg['view'].Close() """ activate_display_mode(cfg['view_restore']['disp_mode'], cfg) cfg['view'].Maximized = cfg['view_restore']['maximized'] cfg['view'].Size = cfg['view_restore']['size'] """ if 'pad_obj_ids' in cfg and cfg['pad_obj_ids']: print("... deleting padding objects") rs.DeleteObjects(cfg['pad_obj_ids']) if 'tmp_obj_ids' in cfg and cfg['tmp_obj_ids']: print("... deleting xformed objects") rs.DeleteObjects(cfg['tmp_obj_ids']) if 'rot_group' in cfg and cfg['rot_group']: print("... rotating objects back to their starting position") rxf = rs.XformRotation2(-cfg['tot_rot'], (0, 0, 1), cfg['rot_group']['bbox'].Center) rs.TransformObjects(cfg['rot_group']['obj_ids'], rxf) show_all_groups(cfg) sc.doc.RenderSettings = cfg['render_settings'] for mode in cfg['display_modes'].keys(): if mode == 'rndr': continue if not Rhino.Display.DisplayModeDescription.DeleteDiplayMode( cfg['display_modes'][mode].Id): print( "Temporary display mode {} was not deleted. Consider removing this yourself." .format(cfg['display_modes'][mode].EnglishName)) delete_residual_display_modes() return
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 ScaleObjectWorld000(ObjectId, Scaling): # Scales an object in the World coordinate system. Similar functionality to # Rhino's ScaleObject, but the latter uses the current construction plane. # The scaling is done with respect to the origin of the World system (0,0,0) # Arguments: ObjectId - the object to be scaled # Scaling - a three element list or tuple containg the scaling # factors along x, y and z respectively xform = rs.XformScale(Scaling) ObjectId = rs.TransformObjects(ObjectId, xform) return ObjectId
def reorient_objects(objects, basePlane, targetPlane, copy=True): """performs a plane to plane reorient on an object w/ or w/out copying""" if targetPlane == None: return None else: world = rs.WorldXYPlane() xform1 = rs.XformChangeBasis(world, basePlane) xform2 = rs.XformChangeBasis(targetPlane, world) xform_final = rs.XformMultiply(xform2, xform1) transform = rs.TransformObjects(objects, xform_final, copy) return transform
def applyXform(target, source): targetXform = rs.BlockInstanceXform(target) sourceXform = rs.BlockInstanceXform(source) if targetXform is not None: plane = rs.PlaneTransform(rs.WorldXYPlane(), targetXform) # xformscale = rs.XformScale((1.0,20.0,1.0)) cob = rs.XformChangeBasis(rs.WorldXYPlane(), plane) cob_inverse = rs.XformChangeBasis(plane, rs.WorldXYPlane()) temp = rs.XformMultiply(sourceXform, cob) xform = rs.XformMultiply(cob_inverse, temp) rs.TransformObjects(target, xform)
def MakeBlockUnique(block, newName): """ Explodes a block and makes a new one with 'newName' """ xform = rs.BlockInstanceXform(block) insertPt = rs.BlockInstanceInsertPoint(block) objs = rs.ExplodeBlockInstance(block, False) rs.TransformObjects(objs, rs.XformInverse(xform)) pt = rs.TransformObject(insertPt, rs.XformInverse(xform)) rs.AddBlock(objs, insertPt, newName, True) newBlock = rs.InsertBlock2(newName, xform) rs.DeleteObject(pt) return newBlock
def convertToPolylines(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() matrix = rs.XformRotation4(p1.XAxis, p1.YAxis, p1.ZAxis, plane.XAxis, plane.YAxis, plane.ZAxis) rs.DeleteObject(obj) # set current layer to put strings in prevlayer = rs.CurrentLayer() layer = rs.AddLayer('temptextlayer') rs.CurrentLayer('temptextlayer') # split text at enters text = text.split('\r\n') opts='GroupOutput=No FontName="timfont" Italic=No Bold=No Height='+ str(ht) opts+=" Output=Curves AllowOpenCurves=Yes LowerCaseAsSmallCaps=No AddSpacing=No " origin.Y += ht * len(text) *1.2 for item in text: rs.Command("_-TextObject " + opts + '"'+item+'"' + " " + str(origin) , False) origin.Y -= ht *1.5 #restore current layer rs.CurrentLayer(prevlayer) #select newly created texts polylines = rs.ObjectsByLayer('temptextlayer') # transform to old position rs.TransformObjects(polylines, matrix, copy=False) rs.MoveObjects(polylines, diff) rs.ObjectLayer(polylines, object_layer) return polylines
def blkObjs(blkid): blockName = rs.BlockInstanceName(blkid) # objref = rs.coercerhinoobject(blkid) # idef = objref.InstanceDefinition # idefIndex = idef.Index lvl = levels[rs.GetUserText(blkid, 'level')] height = lvl['height'] xform = rs.BlockInstanceXform(blkid) objects = [x for x in rs.BlockObjects(blockName) if rs.IsPolysurfaceClosed(x)] objects = map(lambda x: rs.SetUserText(x, 'level', lvl), objects) # map(lambda x: rs.SetUserText(x, 'height', lvl)) blockInstanceObjects = rs.TransformObjects(objects, xform, True)
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 redefineBlockScale(block): block_name = rs.BlockInstanceName(block) # rs.RenameBlock (block_name, "{}-old".format(block_name)) blockXform = rs.BlockInstanceXform(block) plane = rs.PlaneTransform(rs.WorldXYPlane(), blockXform) cob = rs.XformChangeBasis(plane, rs.WorldXYPlane()) cob_inverse = rs.XformChangeBasis(rs.WorldXYPlane(), plane) refBlock = rs.TransformObjects(block, cob_inverse, True) exploded = rs.ExplodeBlockInstance(refBlock) rs.AddBlock(exploded, rs.WorldXYPlane().Origin, block_name, True) newBlock = rs.InsertBlock2(block_name, cob) copySourceLayer(newBlock, block) try: copySourceData(newBlock, block) except: pass rs.DeleteObjects(block)
def bbsolid(obj): if rs.IsBlockInstance(obj): arrMatrix = rs.BlockInstanceXform(obj) if arrMatrix is not None: # pointId = rs.AddPoint([0,0,0]) plane = rs.PlaneTransform(rs.WorldXYPlane(), arrMatrix) box = rs.BoundingBox(obj, plane) bb = rs.AddBox(box) # if box: # for i, point in enumerate(box): # rs.AddTextDot( i, point ) xformscale = rs.XformScale((1.0, 20.0, 1.0)) cob = rs.XformChangeBasis(rs.WorldXYPlane(), plane) cob_inverse = rs.XformChangeBasis(plane, rs.WorldXYPlane()) temp = rs.XformMultiply(xformscale, cob) xform = rs.XformMultiply(cob_inverse, temp) rs.TransformObjects(bb, xform) return bb
def blkObjs(blkid): blockName = rs.BlockInstanceName(blkid) # objref = rs.coercerhinoobject(blkid) # idef = objref.InstanceDefinition # idefIndex = idef.Index # lvl = levels[rs.GetUserText(blkid, 'level')] # height = lvl['height'] xform = rs.BlockInstanceXform(blkid) # objects = [x for x in rs.BlockObjects(blockName) if 'mass' in rs.ObjectLayer(x)] objects = filter(lambda x: 'mass' in rs.ObjectLayer(x), rs.BlockObjects(blockName)) # objects = filter(lambda x: 'mass' in rs.ObjectLayer(x) and rs.GetUserText(x, 'class') != 'na', rs.BlockObjects(blockName)) # objects = map(lambda x: rs.SetUserText(x, 'level', lvl), objects) # map(lambda x: rs.SetUserText(x, 'height', lvl)) blockInstanceObjects = rs.TransformObjects(objects, xform, True) masses.extend(blockInstanceObjects)
def calcFootprint(_zoneObjs, _opaqueSurfaces): # Finds the 'footprint' of the building for 'Primary Energy Renewable' reference # 1) Re-build the zone Breps # 2) Join all the zone Breps into a single brep # 3) Find the 'box' for the single joined brep # 4) Find the lowest Z points on the box, offset another 10 units 'down' # 5) Make a new Plane at this new location # 6) Projects the brep onto the new Plane #----- zoneBreps = [] for zone in _zoneObjs: zoneSurfaces = [] for srfc in _opaqueSurfaces: if srfc.HostZoneName == zone.ZoneName: zoneSurfaces.append(ghc.BoundarySurfaces(srfc.Boundary)) zoneBrep = ghc.BrepJoin(zoneSurfaces).breps zoneBreps.append(zoneBrep) bldg_mass = ghc.SolidUnion(zoneBreps) if bldg_mass == None: return None #------- Find Corners, Find 'bottom' (lowest Z) bldg_mass_corners = [v for v in ghc.BoxCorners(bldg_mass)] bldg_mass_corners.sort(reverse=False, key=lambda point3D: point3D.Z) rect_pts = bldg_mass_corners[0:3] #------- Project Brep to Footprint projection_plane1 = ghc.Plane3Pt(rect_pts[0], rect_pts[1], rect_pts[2]) projection_plane2 = ghc.Move(projection_plane1, ghc.UnitZ(-10)).geometry matrix = rs.XformPlanarProjection(projection_plane2) footprint_srfc = rs.TransformObjects(bldg_mass, matrix, copy=True) footprint_area = rs.Area(footprint_srfc) #------- Output Footprint = namedtuple('Footprint', ['Footprint_surface', 'Footprint_area']) fp = Footprint(footprint_srfc, footprint_area) return fp
def AddToBlock(): objects = rs.GetObjects("Choose Objects to Add to Block", preselect=True) if not objects: return block = rs.GetObject("Choose Block to Add Object to", rs.filter.instance) if not block: return rs.EnableRedraw(False) blockName = rs.BlockInstanceName(block) objref = rs.coercerhinoobject(block) idef = objref.InstanceDefinition idefIndex = idef.Index if rs.IsBlockReference(blockName): print "Block is referenced from file; unable to add object(s)" return blnCopy = False XformBlock = rs.BlockInstanceXform(block) rs.TransformObjects(objects, rs.XformInverse(XformBlock), blnCopy) objects.extend(rs.BlockObjects(blockName)) newGeometry = [] newAttributes = [] for object in objects: newGeometry.append(rs.coercegeometry(object)) ref = Rhino.DocObjects.ObjRef(object) attr = ref.Object().Attributes newAttributes.append(attr) InstanceDefinitionTable = sc.doc.ActiveDoc.InstanceDefinitions InstanceDefinitionTable.ModifyGeometry(idefIndex, newGeometry, newAttributes) rs.DeleteObjects(objects) 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 drawRhombusOnRegularOffsetLine(emblem): tmpObjs = [] for rhomboid in emblem.rhomboids: objs = [] # 中点長方形の対角四角形 for i in range(len(rhomboid.midPts)): p0 = rhomboid.midPts[i] if (i == 0): nextMidPt = rhomboid.midPts[i + 1] prevtMidPt = rhomboid.midPts[len(rhomboid.midPts) - 1] elif (i == len(rhomboid.midPts) - 1): nextMidPt = rhomboid.midPts[0] prevtMidPt = rhomboid.midPts[i - 1] else: nextMidPt = rhomboid.midPts[i + 1] prevtMidPt = rhomboid.midPts[i - 1] p1 = rs.VectorAdd(p0, nextMidPt) p1 = rs.VectorDivide(p1, 2.0) p2 = rhomboid.ellipsePts[0] p3 = rs.VectorAdd(p0, prevtMidPt) p3 = rs.VectorDivide(p3, 2.0) pts = [p0, p1, p2, p3, p0] obj = rs.AddPolyline(pts) if (i % 2 == 0): rs.ObjectLayer(obj, "srf%s" % rhomboid.lines[1].no) else: rs.ObjectLayer(obj, "srf%s" % rhomboid.lines[0].no) objs.append(obj) # 外周面 pts = [] for pt in rhomboid.pts: pts.append(pt) pts.append(pts[0]) obj = rs.AddPolyline(pts) rs.ObjectLayer(obj, "srfRhomboid") objs.append(obj) # 外周線 for i in range(len(rhomboid.pts)): if (i == len(rhomboid.pts) - 1): obj = rs.AddLine(rhomboid.pts[i], rhomboid.pts[0]) else: obj = rs.AddLine(rhomboid.pts[i], rhomboid.pts[i + 1]) rs.ObjectLayer(obj, "lineBlack") objs.append(obj) # move to center objs = rs.MoveObjects(objs, [ -rhomboid.ellipsePts[0][0], -rhomboid.ellipsePts[0][1], -rhomboid.ellipsePts[0][2] ]) # rotate xform = rs.XformRotation2(rhomboid.rotateAng, [0, 0, 1], [0, 0, 0]) rs.TransformObjects(objs, xform) # move pts = rs.LineLineIntersection( [rhomboid.lines[0].sPt, rhomboid.lines[0].ePt], [rhomboid.lines[1].sPt, rhomboid.lines[1].ePt]) rs.MoveObjects(objs, pts[0]) # tmpObjs for obj in objs: tmpObjs.append(obj) return tmpObjs
def FixedFractureGen(n, aspect_ratio=None, sides=None): """ A function to add a fixed number of circles in a cube. It also writes data to fracture data text file for regenerating fracture networks. """ if fracture_shape == 'circle': # initialize a to store fractures fracture_list = [] # a loop to insert the fixed number of fractures for i in range(n): #layer name for the frcature layer_name = "FRACTURE_" + str(i + 1) #create an istance of Fracture class frac = Fracture() #store fracture name frac.fracture_name = layer_name #generate origin for fracture origin = GeneratePoint(boxlength) #store farcture center frac.fracture_center = origin #convert the origin to a plane plane = InclinePlane(origin) #add layer and color rs.AddLayer(layer_name, rs.CreateColor(0, 255, 0)) #make current layer rs.CurrentLayer(layer_name) #insert the fracture in the domain my_circle = rs.AddCircle(plane, radius) #circle_list.append(my_circle) surf = rs.AddPlanarSrf(my_circle) #delete initial fracture drawn which is a curve rs.DeleteObject(my_circle) #save fracture's GUID frac.fracture_GUID = surf[0] #append fracture into fracture list fracture_list.append(frac) elif fracture_shape == 'ellipse': #list to store fracture surface GUIDs fracture_list = [] for i in range(n): #layer name for the frcature layer_name = "FRACTURE_" + str(i + 1) #create an istance of Fracture class frac = Fracture() frac.fracture_name = layer_name #generate fracture origin origin = GeneratePoint(boxlength) frac.fracture_center = origin #plane for fracture plane = InclinePlane(origin) #calculate r_y ry = radius / aspect_ratio #create layer for fracture rs.AddLayer(layer_name, rs.CreateColor(0, 255, 0)) rs.CurrentLayer(layer_name) #draw ellipse fracture = rs.AddEllipse(plane, radius, ry) # write the plane, r_x and r_y to file for re-plotting ##file.write("\n" + str(plane[0]) + "," + str(plane[1]) + "," + str(plane[2]) + "," + str(radius) + ","+ str(ry)) #make fracture a surface frac_surf = rs.AddPlanarSrf(fracture) #delete initial fracture drawn which is a curve rs.DeleteObject(fracture) #append surface GUID to list of fracture surfaces frac.fracture_GUID = frac_surf[0] fracture_list.append(frac) elif fracture_shape == 'polygon': #list to store fracture surface GUIDs fracture_list = [] #write the shape type ##file.write('\npolygon\n') for i in range(n): layer_name = "FRACTURE_" + str(i + 1) frac = Fracture() frac.fracture_name = layer_name #theta in radian theta_rad = (2 * math.pi) / sides #theta in degree (interior angles) theta_deg = theta_rad * (180 / math.pi) #generate origin origin = GeneratePoint(boxlength) frac.fracture_center = origin #create a 3D point object which isn't visible to the rhino document pt_01 = rs.coerce3dvector( [radius + origin[0], origin[1], origin[2]]) #empty list to store all points points = [] #a rotation axis ax = rs.coerce3dvector([0, 0, 1]) #loop to generate points for polygon vertices #file.write("\n") for j in range(sides): #rotation transform with rotation from the origin trans = rs.XformRotation2(theta_deg * j, ax, origin) #transform the original 3D point and append to list points.append(rs.PointTransform(pt_01, trans)) # append the initial point to close the polygon points.append(pt_01) # create layer for fracture # layer_name = "FRACTURE_" + str(i+1) rs.AddLayer(layer_name, rs.CreateColor(0, 255, 0)) rs.CurrentLayer(layer_name) # get GUID of created polygon polygon = rs.AddPolyline(points) # polygon = rs.AddPolyline(points) plane = InclinePlane(origin, boxlength) cob = rs.XformChangeBasis(rs.WorldXYPlane(), plane) shear2d = rs.XformIdentity() shear2d[0, 2] = math.tan(math.radians(45.0)) cob_inverse = rs.XformChangeBasis(plane, rs.WorldXYPlane()) temp = rs.XformMultiply(shear2d, cob) xform = rs.XformMultiply(cob_inverse, temp) fracture = rs.TransformObjects(polygon, xform, False) # make fracture a surface frac_surf = rs.AddPlanarSrf(fracture) # delete initial fracture drawn which is a curve rs.DeleteObject(fracture) frac.fracture_GUID = frac_surf[0] fracture_list.append(frac) return fracture_list
def main(): # get our curves profile, cross = get_two_curves() if profile is None or cross is None: return ################################################## # get bounding box for cross section cross_bbox = rs.BoundingBox([cross]) cmin, cmax = box_to_points(cross_bbox) cz_range = cmax[2] - cmin[2] cz = 0.5 * (cmax[2] + cmin[2]) c_ctr, _ = rs.CurveAreaCentroid(cross) # make sure it's planar in XY if cz_range > 1e-9: print 'cross section curve should be planar in XY plane' return ################################################## # get bounding box for profile profile_bbox = rs.BoundingBox([profile]) # make sure it's planar in in YZ pmin, pmax = box_to_points(profile_bbox) px_range = pmax[0] - pmin[0] if px_range > 1e-9: print 'profile curve should be planar in YZ plane' return ################################################## # get the point closest to the center for the # cross-section curve r, pc = get_inscribed_radius(cross, c_ctr) ################################################## # get the range of z-values for the profile curve _, _, z0 = pmin _, _, z1 = pmax ################################################## # build list of rings and list of points points = [] ring_pipes = [] # for each level for i in range(num_levels): # get the Z value of the ith plane u = float(i) / (num_levels-1) z = z0 + u*(z1 - z0) # build the i'th plane plane = rs.PlaneFromNormal([0, 0, z], [0, 0, 1], [1, 0, 0]) # find out where the plane intersects the profile curve intersect = rs.PlaneCurveIntersection(plane, profile) # there should be exactly one intersection of type 1 (point) if intersect is None or len(intersect) > 1 or intersect[0][0] != 1: print 'bad intersection' return # get the intersection point pi = intersect[0][1] # get the desired XY radius at this z value ri = abs(pi[1]) # we need to set up some transformations: # translate cross section curve down to z=0 T1 = rs.XformTranslation(mz.vec_mul(list(c_ctr), -1.0)) # scale it along XY by the ratio of radii S1 = rs.XformScale([ri/r, ri/r, 1.0]) # scale a piped cross section along Z by a vertical scale factor S2 = rs.XformScale([1.0, 1.0, ring_vscale]) # translate piped cross section up to our desired z value T2 = rs.XformTranslation([0, 0, z]) # scale and translate cross section curve ci = rs.TransformObject(cross, rs.XformMultiply(S1, T1), copy=True) # pipe it ring = rs.AddPipe(ci, [0, 1], [ring_rad, ring_rad]) # scale vertically and transform up ring = rs.TransformObject(ring, rs.XformMultiply(T2, S2)) # delete the copy of the cross section curve rs.DeleteObject(ci) # add to list of ring pipes ring_pipes.append(ring) # create a rotation by the i'th angle angle_i_deg = i*360.0/num_sides Ri = rs.XformRotation2(angle_i_deg, [0, 0, 1], [0, 0, 0]) # transform the closest point by rotation and scale pci = rs.PointTransform(pc, rs.XformMultiply(rs.XformMultiply(Ri, T2), S1)) # add to list of points points.append(pci) # we have built up a list of points for a single spiral of struts to connect, # now we need to pipe them all together and do the ArrayPolar thing around # the z axis # first build a single spiral of struts strut_pipes = [] for i0 in range(num_levels-1): i1 = i0+1 p0 = points[i0] p1 = points[i1] l01 = rs.AddLine(p0, p1) pipe = rs.AddPipe(l01, [0, 1], [strut_rad, strut_rad], cap=2) rs.DeleteObject(l01) strut_pipes.append(pipe) # then array polar around Z axis all_strut_pipes = [] all_strut_pipes += strut_pipes for j in range(1, num_sides): angle_j_deg = j*360.0/num_sides Rj = rs.XformRotation2(angle_j_deg, [0, 0, 1], [0, 0, 0]) all_strut_pipes += rs.TransformObjects(strut_pipes, Rj, copy=True) # now just select all the objects we created rs.SelectObjects(ring_pipes + all_strut_pipes) # done! print 'yay'
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
def projectLayersToClpane(layers): for layer in layers: curves = rs.ObjectsByLayer(layer) xform = rs.XformPlanarProjection(rs.WorldXYPlane()) rs.TransformObjects(curves, xform, False)
def alingBlock(block_a, block_b, model_inside): """ Scale box to the correct dimentions Align box a and what is inside to box b The dimention of the box is expected to be equal lenght :param block_a: :param block_b: block to align block_a to :param model_inside: models inside block_a """ # Find center of box_a exp_a = rs.ExplodePolysurfaces(block_a) cen_a = Vector3d(0, 0, 0) for exp in exp_a: cen_a += rs.SurfaceAreaCentroid(exp)[0] cen_a /= 6.0 # Find center of box_b exp_b = rs.ExplodePolysurfaces(block_b) cen_b = Vector3d(0, 0, 0) for exp in exp_b: cen_b += rs.SurfaceAreaCentroid(exp)[0] cen_b /= 6.0 # Find side Lenght c = rs.DuplicateEdgeCurves(exp_a[0]) L = float(rs.CurveLength(c[0])) def sqrt_length(a, b, c): return math.sqrt(a * a + b * b + c * c) def create_matrix(a, b, c, d): M = [[a[0], a[1], a[2], d[0]], [b[0], b[1], b[2], d[1]], [c[0], c[1], c[2], d[2]], [0, 0, 0, 1]] return M # find basic function of box_a basic_0 = cen_a - rs.SurfaceAreaCentroid(exp_a[0])[0] basic_0 /= sqrt_length(basic_0[0], basic_0[1], basic_0[2]) basic_1 = rs.SurfaceAreaCentroid(exp_a[1])[0] - cen_a basic_1 /= sqrt_length(basic_1[0], basic_1[1], basic_1[2]) basic_2 = cen_a - rs.SurfaceAreaCentroid(exp_a[4])[0] basic_2 /= sqrt_length(basic_2[0], basic_2[1], basic_2[2]) # create tranformation matrix M = create_matrix(basic_0, basic_1, basic_2, [0, 0, 0]) # scale rs.ScaleObjects([block_a] + model_inside, cen_a, [200 / L, 200 / L, 200 / L]) # move to [0,0,0] rs.MoveObjects([block_a] + model_inside, -cen_a) # rotate rs.TransformObjects([block_a] + model_inside, M) # move to object rs.MoveObjects([block_a] + model_inside, cen_b) rs.DeleteObjects(exp_a) rs.DeleteObjects(exp_b) rs.DeleteObjects(c)
def main(): cfg = setup() rs.CurrentView(cfg['view'].ActiveViewportID) # MAIN LOOP msg0 = "{} views at {} zoom levels across {} xforms of {} objects.".format( cfg['view_count'], len(cfg['obj_bbox_pads']), cfg['xform_count'], len(cfg['groups_info'])) msg1 = "{} images will result.".format(cfg['total_image_count']) print(msg0) print(msg1) if rs.MessageBox( "This script will plot {}\n{}\nThe folder {} has been created for this purpose.\nShall we proceed?" .format(msg0, msg1, cfg['pth_save']), 4, "Ready to plot {} images?".format(cfg['total_image_count'])) != 6: teardown(cfg) exit() cfg['tmp_obj_ids'] = False cfg['rot_group'] = False cfg['tot_rot'] = False try: #raise Exception("nope") for g, group_info in enumerate(cfg['groups_info']): print("##### {} ({} of {})".format(group_info['name'].lower(), g + 1, len(cfg['groups_info']))) #print("{} objects in this group".format(len(group_info['obj_ids']))) #set_camera(group_info['bbox'], cfg) isolate_group(g, cfg) deg = 360.0 / cfg['view_count'] rxf = rs.XformRotation2(deg, (0, 0, 1), group_info['bbox'].Center) cfg['rot_group'] = group_info cfg['tot_rot'] = 0 for r in range(cfg['view_count']): for x, xf in enumerate( xforms_to_apply(group_info['bbox'], cfg, DEBUG)): all_layers_on(cfg) cfg['tmp_obj_ids'] = apply_xf( xf, group_info['obj_ids']) # apply this transformation rs.RemoveObjectsFromGroup(cfg['tmp_obj_ids'], group_info['name']) rs.HideGroup(group_info['name']) for p, pad in enumerate(cfg['obj_bbox_pads']): xbbox = bbox_of_objects(cfg['tmp_obj_ids']) set_camera(xbbox, pad, cfg) name = "{}_r{:03}_x{:02}_p{:02}_{}".format( group_info['name'].lower(), r, x, p, cfg['layer_info']['parent'].Name.lower()) is_first = (r == 0 and x == 0) do_capture(name, is_first, cfg) # capture view isolate_group(g, cfg) all_layers_on(cfg) rs.DeleteObjects(cfg['tmp_obj_ids']) cfg['tmp_obj_ids'] = False Rhino.RhinoApp.Wait() if (sc.escape_test(False)): raise Exception('Esc key caught in main()') rs.TransformObjects(group_info['obj_ids'], rxf) cfg['tot_rot'] += deg cfg['rot_group'] = False cfg['tot_rot'] = 0 except Exception as e: print("!!!! SCRIPT STOPPED !!!!") print e exc_type, exc_obj, exc_tb = sys.exc_info() fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1] print(exc_type, fname, exc_tb.tb_lineno) finally: teardown(cfg)
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 drawEhombusTilingByRegularOffsetLine(emblem): tmpObjs = [] # self.rhomboids for rhomboid in emblem.rhomboids: objs = [] # 中点長方形の対角四角形 for i in range(len(rhomboid.midPts)): p0 = rhomboid.midPts[i] if (i == 0): nextMidPt = rhomboid.midPts[i + 1] prevtMidPt = rhomboid.midPts[len(rhomboid.midPts) - 1] elif (i == len(rhomboid.midPts) - 1): nextMidPt = rhomboid.midPts[0] prevtMidPt = rhomboid.midPts[i - 1] else: nextMidPt = rhomboid.midPts[i + 1] prevtMidPt = rhomboid.midPts[i - 1] p1 = rs.VectorAdd(p0, nextMidPt) p1 = rs.VectorDivide(p1, 2.0) p2 = rhomboid.ellipsePts[0] p3 = rs.VectorAdd(p0, prevtMidPt) p3 = rs.VectorDivide(p3, 2.0) pts = [p0, p1, p2, p3, p0] obj = rs.AddPolyline(pts) if (i % 2 == 0): rs.ObjectLayer(obj, "srf%s" % rhomboid.lines[1].no) else: rs.ObjectLayer(obj, "srf%s" % rhomboid.lines[0].no) objs.append(obj) # 外周面 pts = [] for pt in rhomboid.pts: pts.append(pt) pts.append(pts[0]) obj = rs.AddPolyline(pts) rs.ObjectLayer(obj, "srfRhomboid") objs.append(obj) # 外周線 for i in range(len(rhomboid.pts)): if (i == len(rhomboid.pts) - 1): obj = rs.AddLine(rhomboid.pts[i], rhomboid.pts[0]) else: obj = rs.AddLine(rhomboid.pts[i], rhomboid.pts[i + 1]) rs.ObjectLayer(obj, "lineBlack") objs.append(obj) # rotate xform = rs.XformRotation2(rhomboid.rotateAng, [0, 0, 1], [0, 0, 0]) rs.TransformObjects(objs, xform) # move rs.MoveObjects(objs, rhomboid.movePt) # text txt = "%s" % (rhomboid.name) pt = rhomboid.getAbsolutePt(rhomboid.ellipsePts[0]) height = 1.2 pt = [pt[0], pt[1] + height / 2.0, pt[2]] obj = rs.AddText(txt, pt, height, font, font_style=0, justification=2 + 65536) rs.ObjectLayer(obj, "textRhomboid") objs.append(obj) # tmpObjs for obj in objs: tmpObjs.append(obj) # move to center pts = rs.BoundingBox(tmpObjs) center = rs.VectorAdd(pts[0], pts[2]) center = rs.VectorScale(center, 0.5) center = rs.VectorSubtract([0, 0, 0], center) rs.MoveObjects(tmpObjs, center) return tmpObjs
rs.CapPlanarHoles(surf) #Draw spines cone = rs.AddCone([0, 0, -sh], sh, sr) basis = [] theta = ma.pi / 8 dphi = 2 * ma.pi / m for k in range(0, m): phi = k * dphi x = ma.sin(theta) * ma.cos(phi) y = ma.sin(theta) * ma.sin(phi) z = ma.cos(theta) matrix = rs.XformRotation3([0, 0, 1], [x, y, z], [0, 0, 0]) basis.append(rs.TransformObject(cone, matrix, True)) rs.DeleteObject(cone) for crv in ridges: domain = rs.CurveDomain(crv) dt = (domain[1] - domain[0]) / 10 for j in range(1, 10): t = domain[0] + j * dt point = rs.EvaluateCurve(crv, t) xaxis = rs.CurveTangent(crv, t) yaxis = rs.VectorCrossProduct(xaxis, point) zaxis = rs.VectorCrossProduct(xaxis, yaxis) matrix = rs.XformRotation3([0, 0, 1], zaxis, [0, 0, 0]) copy = rs.TransformObjects(basis, matrix, True) matrix = rs.XformTranslation(point) rs.TransformObjects(copy, matrix) rs.DeleteObjects(basis)
def profileXform(sec, plane, vec): xvec = rs.XformTranslation(vec) cob = rs.XformChangeBasis(plane, rs.WorldXYPlane()) xform = rs.XformMultiply(cob, xvec) return rs.TransformObjects(sec, xform, False)
import rhinoscriptsyntax as rs import operator hatch = rs.GetObject(message="Pick any hatch", filter=rs.filter.hatch) trim_lines = rs.GetObjects(message="Select cutting lines", filter=rs.filter.curve) # Project trim_lines to cplane plane = rs.ViewCPlane() matrix = rs.XformPlanarProjection(plane) rs.TransformObjects(trim_lines, matrix, copy=False) selected_objects = [] selected_objects.append(trim_lines) if hatch: # Store original hatch settings hatch_pattern = rs.HatchPattern(hatch) hatch_rotation = rs.HatchRotation(hatch) hatch_scale = rs.HatchScale(hatch) # Make hatch solid so we able to explode it and get surface instead if hatch_pattern != "Solid": rs.HatchPattern(hatch, "Solid") dup_border_surface = [] dup_border_surface.append(rs.ExplodeHatch(hatch)[0]) rs.SurfaceIsocurveDensity(dup_border_surface, 100) selected_objects.append(dup_border_surface) reduced_selected_objects = reduce(operator.add, selected_objects) rs.SelectObjects(reduced_selected_objects) rs.HideObject(hatch) rs.Command("_Trim")