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 transf_t(t, r, s): plane = rh.CurvePerpFrame(path, rh.CurveParameter(path, t)) xform = rh.XformChangeBasis(plane, geo.Plane.WorldXY) xform = rh.XformMultiply(xform, rh.XformScale(s)) xform = rh.XformMultiply( xform, geo.Transform.Rotation(r, geo.Vector3d(0, 0, 1), rawu0)) return rh.TransformObject(profile, xform, True)
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 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 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 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 resetBlockScale(block): block_name = rs.BlockInstanceName(block) blockXform = rs.BlockInstanceXform(block) plane = rs.PlaneTransform(rs.WorldXYPlane(), blockXform) # newplane = rs.CreatePlane(plane.Origin, plane.XAxis, plane.YAxis) # cob = rs.XformChangeBasis(newplane, rs.WorldXYPlane()) cob = rs.XformChangeBasis(plane, rs.WorldXYPlane()) newBlock = rs.InsertBlock2(block_name, cob) copySourceLayer(newBlock, block) try: copySourceData(newBlock, block) except: pass rs.DeleteObjects(block) return newBlock
def GenerateCrossSection(sectionPoints, radius, rotation, smooth, curve, samples, p, q): points = [] avoidRoundoff = 0.01 for angle in rs.frange(0.0, 360.0 + avoidRoundoff, 360.0 / sectionPoints): points.append(rs.Polar((0.0, 0.0, 0.0), angle, radius)) rotXform = rs.XformRotation2(rotation, (0, 0, 1), (0, 0, 0)) points = rs.PointArrayTransform(points, rotXform) t = curve.Domain[0] crossSections = [] curveCurvature = curve.CurvatureAt(t) crossSectionPlane = None if not curveCurvature: crvPoint = curve.PointAt(t) crvTangent = curve.TangentAt(t) crvPerp = (0, 0, 1) crvNormal = Rhino.Geometry.Vector3d.CrossProduct(crvTangent, crvPerp) crossSectionPlane = Rhino.Geometry.Plane(crvPoint, crvPerp, crvNormal) else: crvPoint = curve.PointAt(t) crvTangent = curve.TangentAt(t) crvPerp = curve.CurvatureAt(t) crvPerp.Unitize crvNormal = Rhino.Geometry.Vector3d.CrossProduct(crvTangent, crvPerp) crossSectionPlane = Rhino.Geometry.Plane(crvPoint, crvPerp, crvNormal) if crossSectionPlane: xform = rs.XformChangeBasis(crossSectionPlane, rs.WorldXYPlane()) sectionVerts = rs.PointArrayTransform(points, xform) if (smooth): # Degree 3 curve to smooth it sectionCurve = Rhino.Geometry.Curve.CreateControlPointCurve( sectionVerts, 3) else: # Degree 1 curve (polyline) sectionCurve = Rhino.Geometry.Curve.CreateControlPointCurve( sectionVerts, 1) crossSection = rs.coercecurve(sectionCurve) return crossSection
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
import rhinoscriptsyntax as rs crvIds = rs.GetObjects("Pick curves", rs.filter.curve) ptIds = rs.GetObjects("Pick points", rs.filter.point) blockId = rs.GetObject("Pick Block", rs.filter.instance) if rs.IsBlockInstance(blockId): block_name = rs.BlockInstanceName(blockId) for crv in crvIds: for pt in ptIds: if rs.IsPointOnCurve(crv, pt): param = rs.CurveClosestPoint(crv, pt) tangent = rs.CurveTangent(crv, param) tangent = rs.VectorUnitize(tangent) normal = rs.WorldXYPlane().ZAxis # normal = rs.VectorUnitize(normal) plane = rs.PlaneFromNormal(pt, normal, tangent) # plane = rs.CurvePerpFrame(crv, param) xform = rs.XformChangeBasis(plane, rs.WorldXYPlane()) rs.InsertBlock2(block_name, xform)
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)
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 RedrawNetwork(path): """ A function to reload/regenerate fracture networks. Parameter -------- path: str path where the text file containing fracture data is stored. """ # open text file m = open(path, 'r') # read first line of text file; length of the domain l = m.readline() # convert length to float length = float(l) # read the second line of the domain; shape of the fracture shape = m.readline().split() #corners = ([(0,0,0),(length,0,0),(length,length,0),(0,length,0),(0,0,length),(length,0,length),(length,length,length),(0,length,length)]) #rs.AddBox(corners) # create the domain dom = Domain.Domain(length) # display the domain dom.Show() if shape[0] != 'polygon': # a list to store GUIDs of regenerated fractures frac_list = [] # list to store the x_axis of the fracture plane x_axis = [] # list to store the y_axis of the fracture plane y_axis = [] # list to store the origin of the fracture location origin = [] # list to store the size of fracture size = [] # read file line by line for line in m: # split line by comma words = line.split(",") #if words[0] != 'circle': # append the origin, x_axis and y_axis values in each line origin.append(float(words[0])) origin.append(float(words[1])) origin.append(float(words[2])) x_axis.append(float(words[3])) x_axis.append(float(words[4])) x_axis.append(float(words[5])) y_axis.append(float(words[6])) y_axis.append(float(words[7])) y_axis.append(float(words[8])) size.append(float((words[9]))) # if the shape is ellipse, we have two radii, so append the second radius if shape[0] == 'ellipse': size.append(float((words[10]))) # close file m.close() # display fractures if they are circles/disks if shape[0] == 'circle': n = 0 # go through the lists of origin, x_axis and y_axis # we divide by 3, because the list contains 3 consecutive values # representing a single origin, x_axis or y_axis for i in range(int(len(origin) / 3)): # lists to store the origin, x_axis and y_axis of each fracture o = [] x = [] y = [] # append the origin, x_axis and y_axis of each fracture for j in range(3): o.append(origin[n + j]) x.append(x_axis[n + j]) y.append(y_axis[n + j]) # convert the origin, x_axis and y_axis to a plane plane = rs.PlaneFromFrame(o, x, y) # name the current layer # we are creating layers so that we can trim out of bounds fractures # the function that does this makes use of the layer names layer_name = "FRACTURE_" + str(i + 1) # give the layer a color rs.AddLayer(layer_name, rs.CreateColor(0, 255, 0)) # make layer the current layer rs.CurrentLayer(layer_name) # draw fracture my_disk = rs.AddCircle(plane, size[i]) # convert to a surface surf = rs.AddPlanarSrf(my_disk) #delete initial fracture drawn which is a curve rs.DeleteObject(my_disk) # append fracture frac_list.append(surf) # increment n used for parsing n += 3 # trim out of bounds fractures # the function all creates new fractures at the locations of all # exixting fractures dom.RemoveSurfacesOutsideOfBox(length) # delete all old fractures for frac in frac_list: rs.DeleteObject(frac) dom_frac = dom.my_fractures #get the fractures in the domain #print(dom_frac) #swap old guids with new ones and put new guids in old frac layers #new_frac_guids = Frac.NewFracturesGuids(dom_frac,frac_list) # display fractures if they are ellipse if shape[0] == 'ellipse': # lists to store the origin, x_axis and y_axis of each fracture n = 0 p = 0 q = 1 # go through the lists of origin, x_axis and y_axis # we divide by 3, because the list contains 3 consecutive values # representing a single origin, x_axis or y_axis for i in range(int(len(origin) / 3)): o = [] x = [] y = [] # append the origin, x_axis and y_axis of each fracture for j in range(3): o.append(origin[n + j]) x.append(x_axis[n + j]) y.append(y_axis[n + j]) # convert the origin, x_axis and y_axis to a plane plane = rs.PlaneFromFrame(o, x, y) # name the current layer # we are creating layers so that we can trim out of bounds fractures # the function that does this makes use of the layer names layer_name = "FRACTURE_" + str(i + 1) # give the layer a color rs.AddLayer(layer_name, rs.CreateColor(0, 255, 0)) # make layer current layer rs.CurrentLayer(layer_name) # draw fracture my_frac = rs.AddEllipse(plane, size[i + p], size[i + q]) # convert to a surface from curve surf = rs.AddPlanarSrf(my_frac) # delete initial fracture drawn which is a curve rs.DeleteObject(my_frac) # append fracture frac_list.append(surf) # increment varaiables used for parsing n += 3 p += 1 q += 1 # trim out of bounds fractures dom.RemoveSurfacesOutsideOfBox(length) # delete old fractures for frac in frac_list: rs.DeleteObject(frac) dom_frac = dom.my_fractures if shape[0] == 'polygon': # list to store origin origin = [] # list to store number of sides of each polygon size = [] # list to store the x_axis of the fracture plane x_axis = [] # list to store the y_axis of the fracture plane y_axis = [] # list to store fractures frac_list = [] # list to store points points = [] for line in m: # split each line by comma words = line.split(",") # store the number of sides of the polygon size.append(float(words[-1])) # store the x axis x_axis.extend( (float(words[-7]), float(words[-6]), float(words[-5]))) y_axis.extend( (float(words[-4]), float(words[-3]), float(words[-2]))) # store the origin origin.extend( (float(words[-10]), float(words[-9]), float(words[-8]))) # length of all points on the line # this will ensure we capture lines with disparate points when # generating polygon of different sides ex = int(3 * (size[-1] + 1)) # store all points on the line points.extend((words[:ex])) # close file m.close() # variables to use for parsing n = 0 m = 0 # iterate for the number of fractures generated for i in range(len(size)): # list to store points and origin o = [] x = [] y = [] p = [] # get the origin and axes of the fracture for j in range(3): o.append(origin[n + j]) x.append(x_axis[n + j]) y.append(y_axis[n + j]) # variable for parsing r = 0 # get the points of fracture edges for k in range(int(size[i]) + 1): p.append([]) for l in range(3): p[k].append(float(points[m + l + r])) # increment r r += 3 # increment parsing variables m += ((int(size[i]) + 1) * 3) n += 3 # name the current layer # we are creating layers so that we can trim out of bounds fractures # the function that does this makes use of the layer names layer_name = "FRACTURE_" + str(i + 1) # give the layer a color rs.AddLayer(layer_name, rs.CreateColor(0, 255, 0)) # make layer the current layer rs.CurrentLayer(layer_name) # joing the points poly = rs.AddPolyline(p) # get the plane plane = rs.PlaneFromFrame(o, x, y) # transform fracture to the plane 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) frac = rs.TransformObjects(poly, xform, False) # convert to a surface surf = rs.AddPlanarSrf(frac) #delete initial fracture drawn which is a curve rs.DeleteObject(frac) frac_list.append(surf) # trim out of bounds fractures # the function all creates new fractures at the locations of all # exixting fractures dom.RemoveSurfacesOutsideOfBox(length) # delete all old fractures for fr in frac_list: rs.DeleteObject(fr) dom_frac = dom.my_fractures return dom_frac
def RandomFractureGen(frac_min, frac_max, radius_min, radius_max, aspect_min=None, aspect_max=None, polysize_min=None, polysize_max=None): """ Funtions to generate fractures of random number and sizes Parameters ---------- frac_min: int minimum number of fractures to generate frac_max: int maximum number of fractures to generate radius_min: float minimum size of fractures radius_max: float maximum number of fractures to generate aspect_min: float minimum aspect ratio fpr ellipses (Default:None) aspect_max: float maximum aspect ratio fpr ellipses (Default:None) polysize_min: int minimum size of polygon (Default:None) polysize_max: int maximum size of polygon (Default:None) """ # randomly determine the number of fractures to generate num_frac = random.randint(frac_min, frac_max) # open file and append to it file = open(path, 'a') if fracture_shape == 'circle': # write the shape type file.write('\ncircle') # initialize list to store fractures fracture_list = [] # loop to generate fractures for i in range(num_frac): # name the layer layer_name = "FRACTURE_" + str(i + 1) # an instance of fracture object frac = Fracture() # get fracture name frac.fracture_name = layer_name # generate fracture center origin = GeneratePoint(boxlength) # store fracture center frac.fracture_center = origin # convert the origin to a plane plane = InclinePlane(origin, boxlength) # add layer and create color for it rs.AddLayer(layer_name, rs.CreateColor(0, 255, 0)) # make layer current layer rs.CurrentLayer(layer_name) # generate fracture size radius = FractureSize(size_dist, radius_min, radius_max) # insert the circle in the domain my_circle = rs.AddCircle(plane, radius) # write the plane and radius to file for re-plotting file.write("\n" + str(plane[0]) + "," + str(plane[1]) + "," + str(plane[2]) + "," + str(radius)) surf = rs.AddPlanarSrf(my_circle) # delete initial fracture drawn which is a curve rs.DeleteObject(my_circle) # set fracture guid into its object frac.fracture_GUID = surf[0] fracture_list.append(frac) elif fracture_shape == 'ellipse': # initialize list to store fractures fracture_list = [] # write the shape type file.write('\nellipse') for i in range(num_frac): # name the layer layer_name = "FRACTURE_" + str(i + 1) # an instance of fracture object frac = Fracture() # get fracture name frac.fracture_name = layer_name # generate fracture center origin = GeneratePoint(boxlength) # store fracture center frac.fracture_center = origin # plane for fracture plane = InclinePlane(origin, boxlength) # randomly generate radius(rx) radius = FractureSize(size_dist, radius_min, radius_max) # randomly generate aspect ratio aspect_ratio = random.randint(aspect_min, aspect_max) # calculate r_y ry = radius / aspect_ratio # add layer with color rs.AddLayer(layer_name, rs.CreateColor(0, 255, 0)) # make current layer rs.CurrentLayer(layer_name) # draw fracture 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) # set fracture guid into its object frac.fracture_GUID = frac_surf[0] # append fracture guid to list fracture_list.append(frac) elif fracture_shape == 'polygon': # initialize list to store fractures fracture_list = [] # write the shape type file.write('\npolygon\n') for i in range(num_frac): # name the layer layer_name = "FRACTURE" + str(i + 1) # an instance of fracture class frac = Fracture() # get farcture name frac.fracture_name = layer_name # randomly determine the sides of the polygon sides = random.randint(polysize_min, polysize_max) # 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) # save fracture center frac.fracture_center = origin # randomly generate radius(rx) radius = FractureSize(size_dist, radius_min, radius_max) # 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 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)) if j == 0: file.write( str(rs.PointTransform(pt_01, trans)[0]) + "," + str(rs.PointTransform(pt_01, trans)[1]) + "," + str(rs.PointTransform(pt_01, trans)[2]) + ",") if j != 0: file.write( str(rs.PointTransform(pt_01, trans)[0]) + "," + str(rs.PointTransform(pt_01, trans)[1]) + "," + str(rs.PointTransform(pt_01, trans)[2]) + ",") # append the initial point to close the polygon points.append(pt_01) file.write( str(pt_01[0]) + "," + str(pt_01[1]) + "," + str(pt_01[2]) + ",") # 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) # get the plane plane = InclinePlane(origin, boxlength) # transform the polygon to the plane 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) # write to file #file.write(str(origin[0]) + "," + str(origin[1]) + "," + str(origin[2])+ "," ) file.write( str(plane[0]) + "," + str(plane[1]) + "," + str(plane[2]) + "," + str(sides) + "\n") # make fracture a surface frac_surf = rs.AddPlanarSrf(fracture) # delete initial fracture drawn which is a curve rs.DeleteObject(fracture) # set fracture guid into its objects frac.fracture_GUID = frac_surf[0] # append fracture guid to list fracture_list.append(frac) # close file file.close() return fracture_list
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) ha = rs.GetReal(message="Helix angle", number=params["ha"], minimum=-45, maximum=45) t = rs.GetReal(message="Thickness", number=params["t"], minimum=0) bool_opts = rs.GetBoolean(message="Output options", items=(("PitchCylinder", "No", "Yes"),), defaults=(params["pc"],)) if None in [center, n, m, pa, ha, t, bool_opts]: return 1 # Cancel pc = bool_opts[0] params["n"] = n params["m"] = m params["pa"] = pa params["ha"] = ha params["t"] = t 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"]) pitch = abs((n * m * pi) / tan(radians(ha))) turns = t / pitch if ha < 0: # Left handed helix turns = -turns centerline = rs.AddLine([0, 0, 0], [0, 0, t]) helix = rs.AddSpiral([0, 0, 0], [0, 0, t], pitch=pitch, turns=turns, radius0=(m * n) / 2) helical_gear_srf = rs.AddSweep2(rails=[centerline, helix], shapes=[gear]) rs.DeleteObjects([centerline, helix, gear]) rs.ViewCPlane(plane=old_plane) rs.TransformObjects(helical_gear_srf, xform) if pc: circle = generate_pitch_circle_crv(teeth=params["n"], module=params["m"]) pitch_cyl_srf = rs.ExtrudeCurveStraight(circle, start_point=[0, 0, 0], end_point=[0, 0, t]) rs.TransformObjects(pitch_cyl_srf, xform) rs.DeleteObject(circle) rs.SelectObjects([helical_gear_srf, pitch_cyl_srf]) else: rs.SelectObjects(helical_gear_srf) rs.EnableRedraw(True) return 0 # Success