def deflect(self, deflectPoint): """ Takes a Point as an input. Point creates a force field. The turtle deflects around the point """ defPtPos = rs.PointCoordinates(deflectPoint) prevPos = rs.PointCoordinates(self.point) deflectVector1 = rs.VectorScale(rs.VectorCreate(prevPos, defPtPos), 0.33) deflectVector2 = -deflectVector1 deflectVector90_1 = rs.VectorScale( rs.VectorRotate(deflectVector1, 90, [0, 0, 1]), 0.33) deflectVector90_2 = -deflectVector90_1 deflectVectorList = [ deflectVector1, deflectVector2, deflectVector90_1, deflectVector90_2 ] forcePts = [] for i in deflectVectorList: newPt = rs.CopyObject(deflectPoint) rs.MoveObject(newPt, i) forcePts.append(newPt) gotoPt = rs.PointCoordinates(forcePts[0]) self.goto(gotoPt[0], gotoPt[1]) rs.AddArc3Pt(forcePts[0], forcePts[1], forcePts[2]) rs.AddArc3Pt(forcePts[1], forcePts[0], forcePts[3]) rs.DeleteObjects(forcePts)
def CreateRadial(self, x0, x1, d, z): return rs.JoinCurves([ rs.AddLine((x0, -d, z), (x1, -d, z)), rs.AddArc3Pt((x1, -d, z), (x1, d, z), (x1 + d, 0, z)), rs.AddLine((x1, d, z), (x0, d, z)), rs.AddArc3Pt((x0, d, z), (x0, -d, z), (x0 - d, 0, z)) ], True)
def CreateULine(self, x0, x1, y0, y1, z): r = 0.5 sp4 = r - math.sin(math.pi / 4) * r return rs.JoinCurves([ rs.AddLine((x0, y1, z), (x0, y0 + r, z)), rs.AddArc3Pt((x0, y0 + r, z), (x0 + r, y0, z), (x0 + sp4, y0 + sp4, z)), rs.AddLine((x0 + r, y0, z), (x1 - r, y0, z)), rs.AddArc3Pt((x1 - r, y0, z), (x1, y0 + r, z), (x1 - sp4, y0 + sp4, z)), rs.AddLine((x1, y0 + r, z), (x1, y1, z)) ], True)
def CreateArc(self, a0, a1, r0, r1, z0): aa = (a0 + a1) / 2 pa = (r0 * math.cos(aa), r0 * math.sin(aa), z0) pb = (r1 * math.cos(aa), r1 * math.sin(aa), z0) p0 = (r0 * math.cos(a0), r0 * math.sin(a0), z0) p1 = (r0 * math.cos(a1), r0 * math.sin(a1), z0) p2 = (r1 * math.cos(a1), r1 * math.sin(a1), z0) p3 = (r1 * math.cos(a0), r1 * math.sin(a0), z0) return rs.JoinCurves([ rs.AddArc3Pt(p0, p1, pa), rs.AddLine(p1, p2), rs.AddArc3Pt(p2, p3, pb), rs.AddLine(p3, p0) ], True)
def make_chine_edge(p1, p2, wc, wg, l1, l2, p_top): objs = [] l = normalized(sd(p2, p1)) p = sm(wc, unit_perp(l, [1, 0, 0])) p3 = sd(ss(p1, sm(l1, l)), p) p4 = sd(sd(p2, sm(l2, l)), sm(wg / wc, p)) up = normalized(sd(p_top, p2)) if up[2] == 0: p2 = sd(p2, [0, sqrt(wg**2 + (l1 * l[1])**2), 0]) else: t = ((p2[1] - p4[1]) / up[1] - (p2[2] - p4[2]) / up[2]) / (l[1] / up[1] - l[2] / up[2]) p2 = ss(p4, sm(t, l)) p1 = sd(p1, p) # p2 = sd(p2,[0,(wg/wc)*p[1],0]) # p2 = sd(p2,[0,sqrt(wg**2+(l2*l[1])**2),0]) objs.append(rs.AddLine(p1, ss(p1, sm(l1, l)))) objs.append(rs.AddLine(p3, ss(p, p3))) objs.append(rs.AddLine(p2, p4)) objs.append(rs.AddLine(p4, ss(sm(wg / wc, p), p4))) p5 = mid(p1, p2) objs.append(rs.AddArc3Pt(ss(p, p3), ss(sm(wg / wc, p), p4), p5)) return rs.JoinCurves(objs, delete_input=True)
def ArcTo(self, a, b, xm, ym): p = (a, b, self.z) if p == self.currentPoint: return self.curves.append(rs.AddArc3Pt(self.currentPoint, p, (xm, ym, self.z))) self.currentPoint = p
def draw_arc(p, theta, k): #k=-1,1 p1 = rs.AddPoint(p) p2 = rs.CopyObject(p1, polar(t, theta, 0)) p3 = rs.CopyObject(p1, polar(t / 2, theta, 0)) p4 = rs.CopyObject(p3, (0, 0, t / 4 * k)) arc = rs.AddArc3Pt(p1, p2, p4) return arc
def rivet_tab(self, pntJ, pntI, prev_point, left_side): radius = self.rivet_diameter / 2.0 + self.tab_padding a, b, c, d, e = edgeGeom.get_arc_rod_points(pntI, pntJ, radius, not left_side) arc = rs.AddArc3Pt(b, d, c) line_ab = rs.AddLine(a, b) line_de = rs.AddLine(d, e) hole = rs.AddCircle(rs.PlaneFromNormal(pntI, self.normal), self.rivet_diameter / 2.0) line_connect = rs.AddLine(prev_point, a) self.geom_temp.extend([line_connect, line_ab, arc, line_de, hole]) return a, e
def test_get_arc_cap_works(self): offset = 2 radius = 1 pntA, pntB, pntC = edgeGeom.get_arc_cap(( 0.0, 0.0, 0.0, ), (5.0, 0.0, 0.0), offset, radius) self.assertTrue(rs.PointCompare(pntB, (offset, 0.0, 0.0))) self.assertTrue(rs.PointCompare(pntA, (offset + radius, -radius, 0.0))) self.assertTrue(rs.PointCompare(pntC, (offset + radius, radius, 0.0))) rs.AddArc3Pt(pntA, pntC, pntB)
def AddArcDir(ptStart, ptEnd, vecDir): vecBase = rs.PointSubtract(ptEnd, ptStart) if rs.VectorLength(vecBase)==0.0: return if rs.IsVectorParallelTo(vecBase, vecDir): return vecBase = rs.VectorUnitize(vecBase) vecDir = rs.VectorUnitize(vecDir) vecBisector = rs.VectorAdd(vecDir, vecBase) vecBisector = rs.VectorUnitize(vecBisector) dotProd = rs.VectorDotProduct(vecBisector, vecDir) midLength = (0.5*rs.Distance(ptStart, ptEnd))/dotProd vecBisector = rs.VectorScale(vecBisector, midLength) return rs.AddArc3Pt(ptStart, rs.PointAdd(ptStart, vecBisector), ptEnd)
def pill_shape(pntI, pntJ, offset, width, color=(0, 0, 0)): ''' creates a pill shape between the two points returns the polycurve guid C --- D / \ I --- B -------- E ----> J \ / A -- F ''' radius = width / 2.0 pntA, pntC, pntB = edgeGeom.get_arc_cap(pntI, pntJ, offset, radius) pntD, pntF, pntE = edgeGeom.get_arc_cap(pntJ, pntI, offset, radius) first_arc = rs.AddArc3Pt(pntA, pntC, pntB) second_arc = rs.AddArc3Pt(pntD, pntF, pntE) first_line = rs.AddLine(pntC, pntD) second_line = rs.AddLine(pntF, pntA) geom = [first_arc, second_arc, first_line, second_line] curves = rs.JoinCurves(geom, delete_input=True) assert len(curves) == 1, "in pill_shape JoinCurves failed" curve = curves[0] rs.ObjectColor(curve, color) return curve
def createSupPt(origin, nCores, nFloors, rad1, rad2, hP, ang): for i in range((nCores * nFloors) + 1): ptO = rs.PointAdd(origin, (0, 0, hP * i / nCores)) pt1 = rs.Polar(ptO, (360 * i / nCores), rad1) pt1AuxA = rs.Polar(ptO, (360 * i / nCores) + ang, rad1) pt1AuxB = rs.Polar(ptO, (360 * i / nCores) - ang, rad1) pt2 = rs.Polar(ptO, (360 * i / nCores), rad2) pt2AuxA = rs.Polar(ptO, (360 * i / nCores) + ang, rad2) pt2AuxB = rs.Polar(ptO, (360 * i / nCores) - ang, rad2) #pExt.append(pt1) pExt.Add(pt1, g.Kernel.Data.GH_Path(i // nCores)) auxExtPts.extend([pt1AuxA, pt1AuxB]) arc1 = rs.AddArc3Pt(pt1AuxA, pt1AuxB, pt1) #arc drawing pedestrian path in core area arcPed.Add( rs.OffsetCurve(arc1, origin, pedOff)[0], g.Kernel.Data.GH_Path(i // nCores)) arcPark.Add( rs.OffsetCurve(arc1, origin, pedOff + parkOff)[0], g.Kernel.Data.GH_Path(i // nCores)) #extArcs.append(arc1) extArcs.Add(arc1, g.Kernel.Data.GH_Path(i // nCores)) #pInt.append(pt2) pInt.Add(pt2, g.Kernel.Data.GH_Path(i // nCores)) auxIntPts.extend([pt2AuxA, pt2AuxB]) arc2 = rs.AddArc3Pt(pt2AuxA, pt2AuxB, pt2) #intArcs.append(arc2) intArcs.Add(arc2, g.Kernel.Data.GH_Path(i // nCores)) pSupExt.AddRange([pt1AuxA, pt1AuxB, pt2AuxA, pt2AuxB], g.Kernel.Data.GH_Path(i // nCores))
def addArc(startPt, endPt, vecDir): vecBase = rs.PointSubtract(endPt, startPt) if rs.VectorLength(vecBase) == 0.0: return if rs.IsVectorParallelTo(vecBase, vecDir): return vecBase = rs.VectorUnitize(vecBase) vecDir = rs.VectorUnitize(vecDir) vecBisector = rs.VectorAdd(vecDir, vecBase) vecBisector = rs.VectorUnitize(vecBisector) midlength = (0.5*rs.Distance(startPt, endPt)) / (rs.VectorDotProduct(vecBisector, vecDir)) vecBisector = rs.VectorScale(vecBisector, midlength) return rs.AddArc3Pt(startPt, endPt, rs.PointAdd(startPt, vecBisector))
def addArcDiv(ptStart, ptEnd, vecDir): vecBase = rs.PointSubtract(ptEnd, ptStart) # error handling if rs.VectorLength(vecBase) == 0.0: return if rs.IsVectorParallelTo(vecBase, vecDir): return vecBase = rs.VectorUnitize( vecBase ) # normalize vector == force magnitude to 1 to just compare direction vecDir = rs.VectorUnitize(vecDir) vecBisector = rs.VectorAdd(vecDir, vecBase) vecBisector = rs.VectorUnitize(vecBisector) dotProd = rs.VectorDotProduct(vecBisector, vecDir) midLength = (0.5 * rs.Distance(ptStart, ptEnd)) / dotProd vecBisector = rs.VectorScale(vecBisector, midLength) return rs.AddArc3Pt(ptStart, rs.PointAdd(pt.Start, vecBisector), ptEnd)
def GenerateCylindricalSlot(): filled = False radius = 6 + random.random()*6 length = 15 + random.random()*5 centerPoint = Rhino.Geometry.Point3d(0,0,0) orientation = Rhino.Geometry.Vector3d(1,0,0) brepCylinder = AddCylinder(centerPoint,orientation,radius,length) curveLength = 3 + random.random()*(2*math.pi*radius -3) angleCovered = (curveLength/2*math.pi*radius)*2*math.pi startAngle = 0 + random.random()*(2*math.pi-angleCovered) endAngle = startAngle + angleCovered widthOfSlot = 2 + random.random()*(6-2); randomPointOnALength = 2 + random.random()*(length -2 - widthOfSlot/2); curvPoint1 = Rhino.Geometry.Point3d(randomPointOnALength,radius*(math.cos(startAngle)),radius*(math.sin(startAngle))) curvPoint2 = Rhino.Geometry.Point3d(randomPointOnALength,radius*(math.cos(startAngle*0.5 + endAngle*0.5)),radius*(math.sin(startAngle*0.5 + endAngle*0.5))) curvPoint3 = Rhino.Geometry.Point3d(randomPointOnALength,radius*(math.cos(endAngle)),radius*(math.sin(endAngle))) arc = rs.AddArc3Pt(curvPoint1,curvPoint3,curvPoint2) arcBrep = rs.coercecurve(arc) height = 2 + random.random()*(4-2) point1 = Rhino.Geometry.Point3d(randomPointOnALength - widthOfSlot/2 ,(radius+height/2)*math.cos(startAngle),(radius+height/2)*math.sin(startAngle)) point2 = Rhino.Geometry.Point3d(randomPointOnALength - widthOfSlot/2 ,(radius-height/2)*math.cos(startAngle),(radius-height/2)*math.sin(startAngle)) point3 = Rhino.Geometry.Point3d(randomPointOnALength + widthOfSlot/2 ,(radius-height/2)*math.cos(startAngle),(radius-height/2)*math.sin(startAngle)) point4 = Rhino.Geometry.Point3d(randomPointOnALength + widthOfSlot/2 ,(radius+height/2)*math.cos(startAngle),(radius+height/2)*math.sin(startAngle)) point5 = point1 points = [point1,point2,point3,point4,point5] rectSrf = rs.AddPolyline(points) rectSurfBrep = rs.coercecurve(rectSrf) rs.DeleteObjects(arc) rs.DeleteObjects(rectSrf) breps = Rhino.Geometry.Brep.CreateFromSweep(arcBrep,rectSurfBrep,True,scriptcontext.doc.ModelAbsoluteTolerance) brepsCurveBox = Rhino.Geometry.Brep.CapPlanarHoles(breps[0],scriptcontext.doc.ModelAbsoluteTolerance) brepArray = Rhino.Geometry.Brep.CreateBooleanDifference([brepCylinder],[brepsCurveBox],scriptcontext.doc.ModelAbsoluteTolerance) scriptcontext.doc.Views.Redraw() if(brepArray is not None and brepCylinder.GetBoundingBox(Rhino.Geometry.Vector3d(0,0,1)).Volume == brepArray[0].GetBoundingBox(Rhino.Geometry.Vector3d(0,0,1)).Volume): for brep in brepArray: scriptcontext.doc.Objects.AddBrep(brep) scriptcontext.doc.Views.Redraw() return 1 else : return 0
def DecodeCurve(string): try: fullList = ast.literal_eval(string) segList = [] for eachSegment in fullList: if eachSegment[0] == "line": segList.append(rs.AddLine(eachSegment[1][0], eachSegment[1][1])) elif eachSegment[0] == "arc": segList.append( rs.AddArc3Pt(eachSegment[1][0], eachSegment[1][2], eachSegment[1][1])) elif eachSegment[0] == "curve": segList.append(rs.AddCurve(eachSegment[1])) if len(segList) < 2: segList[0] else: return rs.JoinCurves(segList, True) except: print "Error" return None
def CreateKeyCurve(self, r, z0, d=0, close=False): a = 0.15 - d / r x = r * math.sin(a) y = r * math.cos(a) points = [] # yr = 18.1 yr = self.coreInnerRadius - self.coreSpacerLedgeWidth + 0.4 points.append((-x, -y, z0)) points.append((-1.5, -yr - d, z0)) points.append((-0.8, -yr + 0.3 - d, z0)) points.append((0.8, -yr + 0.3 - d, z0)) points.append((1.5, -yr - d, z0)) points.append((x, -y, z0)) start_tangent = (y / r, -x / r, 0) end_tangent = (y / r, x / r, 0) degree = 3 knotstyle = 0 curve = rs.AddInterpCurve(points, degree, knotstyle, start_tangent, end_tangent) if close: arc = rs.AddArc3Pt((-x, -y, z0), (x, -y, z0), (0, -r, z0)) curve = rs.JoinCurves([curve, arc], True) return curve
def generate_gear_crv(teeth, module, pressure_angle=20, cone_angle=0, clearance=0.167, involute_samples=5): pressure_angle = radians(pressure_angle) pitch_diam = module * teeth base_circle = pitch_diam * cos(pressure_angle) addendum = module dedendum = (1 + clearance) * module outside_diam = pitch_diam + 2 * addendum root_diam = pitch_diam - 2 * dedendum chordal_thickness = pitch_diam * sin((pi / 2) / teeth) # Partial function to transform point from xy plane to surface # perpendicular to pitch cone surface. Used for bevel gears. tilt = partial(tilt_pt_around_circle, angle=cone_angle / 2, circle_diam=pitch_diam) invol_start_angle = (pi / 2 + asin(chordal_thickness / pitch_diam) - pressure_angle + sqrt((pitch_diam / base_circle)**2 - 1)) invol_end_angle = (invol_start_angle - sqrt((outside_diam / base_circle)**2 - 1)) if root_diam > base_circle: invol_angle_mod = sqrt((root_diam / base_circle)**2 - 1) else: invol_angle_mod = 0 invol_pts = generate_involute_pts(base_circle_diam=base_circle, start_angle=invol_start_angle, end_angle=invol_end_angle, angle_mod=invol_angle_mod, samples=involute_samples) invol_pts = map(tilt, invol_pts) tooth_crvs = [] invol_crv1 = rs.AddInterpCurve(invol_pts, degree=3, knotstyle=1) invol_crv2 = rs.MirrorObject(invol_crv1, [0, 0, 0], [0, 1, 0], copy=True) top_arc = rs.AddArc3Pt(start=rs.CurveEndPoint(invol_crv1), end=rs.CurveEndPoint(invol_crv2), point_on_arc=tilt([0, outside_diam / 2, 0])) tooth_crvs.append(invol_crv1) tooth_crvs.append(invol_crv2) tooth_crvs.append(top_arc) # Dedendum if root_diam < base_circle: pt = [ root_diam / 2 * cos(invol_start_angle), root_diam / 2 * sin(invol_start_angle), 0 ] ded_crv1 = rs.AddLine(rs.CurveStartPoint(invol_crv1), tilt(pt)) ded_crv2 = rs.MirrorObject(ded_crv1, [0, 0, 0], [0, 1, 0], copy=True) tooth_crvs.append(ded_crv1) tooth_crvs.append(ded_crv2) tooth = rs.JoinCurves(tooth_crvs, delete_input=True)[0] # Tooth bottom angle = 2 * pi / teeth start_pt = rs.CurveStartPoint(tooth) end_pt = rs.CurveEndPoint(tooth) end_pt = [ end_pt[0] * cos(angle) - end_pt[1] * sin(angle), end_pt[1] * cos(angle) + end_pt[0] * sin(angle), end_pt[2] ] pt_on_arc = [ -sin(angle / 2) * (root_diam / 2), cos(angle / 2) * (root_diam / 2), 0 ] bottom_arc = rs.AddArc3Pt(start_pt, end_pt, tilt(pt_on_arc)) tooth = rs.JoinCurves([tooth, bottom_arc], delete_input=True)[0] # Copy and rotate tooth N times crvs = [tooth] for i in xrange(1, teeth): crv = rs.RotateObject(tooth, [0, 0, 0], degrees(i * angle), copy=True) crvs.append(crv) crvs = rs.JoinCurves(crvs, delete_input=True) return crvs
def handrailGen(self, sender, e): flip = self.flipC.Checked hType = self.handrailTypeC.SelectedIndex handrailOffset = int(self.handrailOffsetC.Value) * scale tread = int(self.treadC.Value) * scale riser = int(self.riserC.Value) * scale numSteps = int(self.numStepsC.Value) hEndLength = int(self.handrailExtensionC.Value) * scale pipeDiameter = int(self.handrailDiameterC.Value) * scale hHeight = int(self.handrailHeightC.Value) * scale topLine = rs.AddLine(line[0], line[1]) rs.ObjectName(topLine, "BC6#DT5LCQX*#8r97Tquf5gNF") topPoint = line[0] genHandrail = self.genHandrailBool.Checked rs.EnableRedraw(False) if genHandrail == False: iteration = rs.ObjectsByName( "qe7g&G5LzXEvbudtPT8xCxQbisusFVqCPqMsiHK2jc") if iteration: rs.DeleteObjects(iteration) rs.EnableRedraw(True) if genHandrail == True: # Delete any existing iteration iteration = rs.ObjectsByName( "qe7g&G5LzXEvbudtPT8xCxQbisusFVqCPqMsiHK2jc") if iteration: rs.DeleteObjects(iteration) # get perp line - length of stair t = rs.CurveClosestPoint(topLine, topPoint) planeNormal = rs.CurveNormal(topLine) tangent = rs.CurveTangent(topLine, t) if flip == False: curveNormal = rs.VectorCrossProduct(planeNormal, tangent) else: curveNormal = rs.VectorReverse( rs.VectorCrossProduct(planeNormal, tangent)) # Get guide curve scaledV = rs.VectorReverse( rs.VectorScale(curveNormal, tread*numSteps)) ptGuide1 = rs.AddPoint(line[0]) ptGuide2 = rs.CopyObject(ptGuide1, scaledV) rs.MoveObjects([ptGuide1, ptGuide2], [ 0, 0, (riser*numSteps)*-1]) curve = rs.AddCurve([ptGuide1, ptGuide2]) # Get vector for step run vectorRun = rs.VectorCreate( topPoint, topPoint + curveNormal * tread) # Setup curves for handrail curve1 = curve curve2 = rs.MoveObject(rs.CopyObject(curve1, rs.VectorCreate(line[1], rs.CurveStartPoint(curve1))), [0, 0, (riser * numSteps)*-1]) midPoint = rs.CurveMidPoint(userCurve) # Main slanted handrail curve pt1 = rs.MoveObject(rs.MoveObject(rs.CurveStartPoint(curve1), vectorRun), [ 0, 0, hHeight + (riser*numSteps)]) pt2 = rs.MoveObject(rs.MoveObject( rs.CurveEndPoint(curve1), vectorRun), [0, 0, hHeight]) mainCurve = rs.AddCurve([pt1, pt2]) # Top leveled handrail curve at 300mm standard DDA pt3 = rs.CopyObject(pt1, rs.VectorReverse( rs.VectorScale(rs.VectorUnitize(vectorRun), hEndLength))) topCurve = rs.AddCurve([pt1, pt3]) # Bottom leveled handrail curve at 300mm standard DDA pt4 = rs.CopyObject(pt2, rs.VectorScale( rs.VectorUnitize(vectorRun), hEndLength)) bottomCurve = rs.AddCurve([pt2, pt4]) # Start list of construction geometry for later cleanup hGeoList = [curve1, curve2, pt1, pt2, mainCurve, pt3, topCurve, pt4, bottomCurve, ptGuide1, ptGuide2, curve, topLine] # IF STATEMENTS FOR HANDRAIL TYPE # 1 180 degree, no return if hType == 0: # Lower Handrail return hpt1 = rs.CopyObject(pt4, [0, 0, (pipeDiameter * 2) * -1]) hpt2 = rs.MoveObject(rs.CopyObject( pt4, [0, 0, pipeDiameter * -1]), rs.VectorScale(rs.VectorUnitize(vectorRun), pipeDiameter)) lowerH = rs.AddArc3Pt(pt4, hpt1, hpt2) # Upper Handrail return hpt3 = rs.CopyObject(pt3, [0, 0, (pipeDiameter * 2) * -1]) hpt4 = rs.MoveObject(rs.CopyObject(pt3, [0, 0, pipeDiameter * -1]), rs.VectorReverse( rs.VectorScale(rs.VectorUnitize(vectorRun), pipeDiameter))) upperH = rs.AddArc3Pt(pt3, hpt3, hpt4) # Draw leg upper lpt1 = rs.CurveMidPoint(topCurve) lpt2 = rs.CopyObject(lpt1, [0, 0, hHeight*-1]) lCurveUpper = rs.AddCurve([lpt1, lpt2]) # Draw leg lower lpt3 = rs.CopyObject(pt2, [0, 0, hHeight*-1]) lCurveLower = rs.AddCurve([pt2, lpt3]) # Make vectors to move handrails into place moveShort = rs.VectorScale(userVector, handrailOffset) moveLong = rs.VectorScale( userVector, rs.CurveLength(userCurve) - (handrailOffset*2)) # Join, offset skeleton hCurve = rs.JoinCurves( [mainCurve, topCurve, bottomCurve, lowerH, upperH]) hCurve1 = rs.CopyObject(hCurve, moveShort) lCurveUpper1 = rs.CopyObject(lCurveUpper, moveShort) lCurveLower1 = rs.CopyObject(lCurveLower, moveShort) # Pipe skeleton pipe1 = rs.AddPipe( hCurve1, 0, pipeDiameter/2, blend_type=0, cap=1) pipe2 = rs.AddPipe( lCurveUpper1, 0, pipeDiameter/2, blend_type=0, cap=1) pipe3 = rs.AddPipe( lCurveLower1, 0, pipeDiameter/2, blend_type=0, cap=1) # form list of generated geo handrailGeo1 = [pipe1, pipe2, pipe3] # Name geo for deletion for i in handrailGeo1: rs.ObjectName( i, "qe7g&G5LzXEvbudtPT8xCxQbisusFVqCPqMsiHK2jc") # copy handrailGeo2 = rs.CopyObjects(handrailGeo1, moveLong) # Cleanup construction linework hGeoList.extend([hpt1, hpt2, lowerH, hpt3, hpt4, upperH, lpt2, lpt3, lCurveLower, hCurve, hCurve1, lCurveUpper1, lCurveLower1, lCurveUpper]) rs.DeleteObjects(hGeoList) rs.EnableRedraw(True) # 2 180 degree, full return if hType == 1: rs.EnableRedraw(False) # Lower handrail return hpt1 = rs.CopyObject(pt4, [0, 0, (hEndLength/3)*-2]) hpt2 = rs.CopyObject(pt2, [0, 0, (hEndLength/3)*-2]) hCurve11 = rs.AddPolyline([pt4, hpt1, hpt2]) lowerH = rs.JoinCurves([bottomCurve, hCurve11]) # Upper handrail return hpt3 = rs.CopyObject(pt3, [0, 0, (hEndLength/3)*-2]) hpt4 = rs.CopyObject(rs.CurveMidPoint( topCurve), [0, 0, (hEndLength/3)*-2]) hCurve2 = rs.AddPolyline([pt3, hpt3, hpt4]) upperH = rs.JoinCurves([topCurve, hCurve2]) # Draw leg upper lpt1 = rs.CurveMidPoint(topCurve) lpt2 = rs.CopyObject(lpt1, [0, 0, hHeight*-1]) lCurveUpper = rs.AddCurve([lpt1, lpt2]) # Draw leg lower lpt3 = rs.CopyObject(pt2, [0, 0, hHeight*-1]) lCurveLower = rs.AddCurve([pt2, lpt3]) # Make vectors to move handrails into place moveShort = rs.VectorScale(userVector, handrailOffset) moveLong = rs.VectorScale( userVector, rs.CurveLength(userCurve) - (handrailOffset*2)) # Pipe skeleton move hCurve1 = rs.JoinCurves([lowerH, upperH, mainCurve]) rs.MoveObjects( [hCurve1, lCurveUpper, lCurveLower], moveShort) # Pipe pipe1 = rs.AddPipe( hCurve1, 0, pipeDiameter/2, blend_type=0, cap=1) pipe2 = rs.AddPipe( lCurveUpper, 0, pipeDiameter/2, blend_type=0, cap=1) pipe3 = rs.AddPipe( lCurveLower, 0, pipeDiameter/2, blend_type=0, cap=1) handrailGeo1 = [pipe1, pipe2, pipe3] # Name geo for deletion for i in handrailGeo1: rs.ObjectName( i, "qe7g&G5LzXEvbudtPT8xCxQbisusFVqCPqMsiHK2jc") # Move and copy into position handrailGeo2 = rs.CopyObjects(handrailGeo1, moveLong) # Cleanup hGeoList.extend([hpt1, hpt2, hCurve11, lowerH, hpt3, hpt4, hCurve2, upperH, lpt2, lCurveUpper, lpt3, lCurveLower, hCurve1]) rs.DeleteObjects(hGeoList) rs.EnableRedraw(True) # 3 Ground triangle return if hType == 2: rs.EnableRedraw(False) # Draw leg upper lpt1 = rs.CurveMidPoint(topCurve) lpt2 = rs.CopyObject(lpt1, [0, 0, hHeight*-1]) lCurveUpper = rs.AddCurve([lpt1, lpt2]) # Draw leg lower lpt3 = rs.CopyObject(pt2, [0, 0, hHeight*-1]) lCurveLower = rs.AddCurve([pt2, lpt3]) # Lower Return lowerH = rs.AddCurve([pt4, lpt3]) # Upper Return upperH = rs.AddCurve([pt3, lpt2]) # Make vectors to move handrails into place moveShort = rs.VectorScale(userVector, handrailOffset) moveLong = rs.VectorScale( userVector, rs.CurveLength(userCurve) - (handrailOffset*2)) # Join Curves and move hCurve = rs.JoinCurves( [mainCurve, topCurve, bottomCurve, lowerH, upperH]) rs.MoveObjects( [hCurve, lCurveUpper, lCurveLower], moveShort) # pipe pipe1 = rs.AddPipe(hCurve, 0, pipeDiameter / 2, blend_type=0, cap=1) pipe2 = rs.AddPipe( lCurveUpper, 0, pipeDiameter/2, blend_type=0, cap=1) pipe3 = rs.AddPipe( lCurveLower, 0, pipeDiameter/2, blend_type=0, cap=1) handrailGeo1 = [pipe1, pipe2, pipe3] # Name geo for deletion for i in handrailGeo1: rs.ObjectName( i, "qe7g&G5LzXEvbudtPT8xCxQbisusFVqCPqMsiHK2jc") # move and copy into place handrailGeo2 = rs.CopyObjects(handrailGeo1, moveLong) # Cleanup hGeoList.extend( [lpt2, lCurveUpper, lpt3, lCurveLower, lowerH, upperH, hCurve, topLine]) rs.DeleteObjects(hGeoList) rs.EnableRedraw(True) # 4 Ground return if hType == 3: rs.EnableRedraw(False) # Draw leg upper lpt1 = rs.CurveMidPoint(topCurve) lpt2 = rs.CopyObject(lpt1, [0, 0, hHeight*-1]) lCurveUpper = rs.AddCurve([lpt1, lpt2]) # Draw leg lower lpt3 = rs.CopyObject(pt2, [0, 0, hHeight*-1]) lCurveLower = rs.AddCurve([pt2, lpt3]) # Lower Return hpt1 = rs.CopyObject(pt4, [0, 0, hHeight*-1]) hCurve1 = rs.AddCurve([pt4, hpt1]) # Upper Return hpt2 = rs.CopyObject(pt3, [0, 0, hHeight*-1]) hCurve2 = rs.AddCurve([pt3, hpt2]) # Join curves hCurve = rs.JoinCurves( [mainCurve, topCurve, bottomCurve, hCurve1, hCurve2]) # Get Vectors moveShort = rs.VectorScale(userVector, handrailOffset) moveLong = rs.VectorScale( userVector, rs.CurveLength(userCurve) - (handrailOffset*2)) # move rs.MoveObjects( [hCurve, lCurveUpper, lCurveLower], moveShort) # Pipe pipe1 = rs.AddPipe(hCurve, 0, pipeDiameter / 2, blend_type=0, cap=1) pipe2 = rs.AddPipe( lCurveUpper, 0, pipeDiameter/2, blend_type=0, cap=1) pipe3 = rs.AddPipe( lCurveLower, 0, pipeDiameter/2, blend_type=0, cap=1) handrailGeo1 = [pipe1, pipe2, pipe3] # Name geo for deletion for i in handrailGeo1: rs.ObjectName( i, "qe7g&G5LzXEvbudtPT8xCxQbisusFVqCPqMsiHK2jc") # move and copy into place handrailGeo2 = rs.CopyObjects(handrailGeo1, moveLong) # Clean up hGeoList.extend([lpt2, lCurveUpper, lpt3, lCurveLower, hpt1, hCurve1, hpt2, hCurve2, hCurve, topLine]) rs.DeleteObjects(hGeoList) rs.EnableRedraw(True) # 5 Wall return if hType == 4: rs.EnableRedraw(False) # Draw leg upper lpt1 = rs.CurveMidPoint(topCurve) lpt2 = rs.CopyObject(lpt1, [0, 0, hHeight*-1]) lCurveUpper = rs.AddCurve([lpt1, lpt2]) # Draw leg lower lpt3 = rs.CopyObject(pt2, [0, 0, hHeight*-1]) lCurveLower = rs.AddCurve([pt2, lpt3]) # get vectors vector1 = rs.VectorScale(rs.VectorUnitize( rs.VectorReverse(userVector)), handrailOffset) vector2 = rs.VectorScale( userVector, rs.CurveLength(userCurve)) # Lower Return hpt1 = rs.CopyObject(pt4, vector1) hCurve1 = rs.AddCurve([pt4, hpt1]) # Upper Return hpt2 = rs.CopyObject(pt3, vector1) hCurve2 = rs.AddCurve([pt3, hpt2]) # Join main curves hCurveMain1 = rs.JoinCurves( [mainCurve, topCurve, bottomCurve]) # Get Vectors moveShort = rs.VectorScale(userVector, handrailOffset) moveLong = rs.VectorScale( userVector, rs.CurveLength(userCurve) - handrailOffset) # Copy hanrail 2 hCurveMain2 = rs.CopyObject(hCurveMain1, moveLong) hCurve3 = rs.CopyObject(hCurve1, vector2) hCurve4 = rs.CopyObject(hCurve2, vector2) lCurveUpper2 = rs.CopyObject(lCurveUpper, moveLong) lCurveLower2 = rs.CopyObject(lCurveLower, moveLong) # Join curves hCurveJoined1 = rs.JoinCurves( [hCurve1, hCurve2, hCurveMain1]) hCurveJoined2 = rs.JoinCurves( [hCurveMain2, hCurve3, hCurve4, ]) # Pipe pipe1 = rs.AddPipe( hCurveJoined1, 0, pipeDiameter/2, blend_type=0, cap=1) pipe2 = rs.AddPipe( lCurveLower, 0, pipeDiameter/2, blend_type=0, cap=1) pipe3 = rs.AddPipe( lCurveUpper, 0, pipeDiameter/2, blend_type=0, cap=1) pipe4 = rs.AddPipe( hCurveJoined2, 0, pipeDiameter/2, blend_type=0, cap=1) pipe5 = rs.AddPipe( lCurveUpper2, 0, pipeDiameter/2, blend_type=0, cap=1) pipe6 = rs.AddPipe( lCurveLower2, 0, pipeDiameter/2, blend_type=0, cap=1) handrailGeo1 = [pipe1, pipe2, pipe3, pipe3, pipe4, pipe5, pipe6] # Name geo for deletion for i in handrailGeo1: rs.ObjectName( i, "qe7g&G5LzXEvbudtPT8xCxQbisusFVqCPqMsiHK2jc") # Move handrail 1 into place rs.MoveObjects([pipe1, pipe2, pipe3], moveShort) # Cleanup hGeoList.extend([lpt2, lCurveUpper, lpt3, lCurveLower, hpt1, hCurve1, hpt2, hCurve2, hCurveMain1, hCurveMain2, hCurve3, hCurve4, lCurveUpper2, lCurveLower2, hCurveJoined1, hCurveJoined2]) rs.DeleteObjects(hGeoList) rs.EnableRedraw(True)
PlaceSmd(1.698669, 20.338546, 0.365022, 0.521305, 0.000000, 1) PlaceSmd(2.301331, 18.861454, 0.365022, 0.521305, 0.000000, 1) PlaceSmd(1.464244, 19.009055, 0.365022, 0.521305, 0.000000, 1) PlaceSmd(2.418543, 19.526200, 0.373704, 0.472065, 0.000000, 1) PlaceSmd(1.581457, 19.673800, 0.373704, 0.472065, 0.000000, 1) PlaceInstance("SMLP36", 1.800000, 17.000000, False, 270.000000) PlaceSmd(2.225000, 17.675000, 0.450000, 0.450000, 0.000000, 1) PlaceSmd(1.375000, 17.675000, 0.450000, 0.450000, 0.000000, 1) PlaceSmd(2.225000, 16.325000, 0.450000, 0.450000, 0.000000, 1) PlaceSmd(1.375000, 16.325000, 0.450000, 0.450000, 0.000000, 1) PlaceSmd(2.225000, 17.000000, 0.450000, 0.400000, 0.000000, 1) PlaceSmd(1.375000, 17.000000, 0.450000, 0.400000, 0.000000, 1) PlaceInstance("R0201", 4.064000, 21.082000, False, 270.000000) PlaceSmd(4.064000, 21.337000, 0.430000, 0.280000, 0.000000, 1) PlaceSmd(4.064000, 20.827000, 0.430000, 0.280000, 0.000000, 1) curves = [] curves.append( rs.AddArc3Pt((12.887300, 33.495000, 0), (21.112700, 33.495000, 0), (17.000000, -0.000254, 0))) curves.append(rs.AddLine((21.112700, 33.495000, 0), (12.887300, 33.495000, 0))) curves.append( rs.AddCircle3Pt((21.679000, 29.210000, 0), (23.279000, 29.210000, 0), (22.479000, 30.010000, 0))) curves.append( rs.AddCircle3Pt((10.757000, 29.210000, 0), (12.357000, 29.210000, 0), (11.557000, 30.010000, 0))) curves.append( rs.AddCircle3Pt((12.916000, 2.032000, 0), (14.516000, 2.032000, 0), (13.716000, 2.832000, 0))) PlacePCB(curves)
def Draw(self): if (self.error == True): return #Nothing to do self.CalcInvolute() rs.EnableRedraw(False) #Show various gear related circles on the viewport if (self.show["PitchCir"] == True or math.fabs(self.PD / 2 - rs.CircleRadius(self.curve[0])) > self.epsilon): rs.SelectObject(rs.AddCircle( self.plane, self.PD / 2)) #if the pitch circle has changed --> show it if (self.show["BCcircle"] == True): rs.SelectObject(rs.AddCircle(self.plane, self.BC / 2)) if (self.show["ODcircle"] == True): rs.SelectObject(rs.AddCircle(self.plane, self.OD / 2)) if (self.show["RDcircle"] == True): rs.SelectObject(rs.AddCircle(self.plane, self.RD / 2)) #Make the first gear tooth #Note: (gearTooth is an array of curve IDs [left involute, right involute, top arc, leftDedendumLine, RightDedendumLine]) gearTooth = [ rs.AddInterpCurve(self.involute["pointsLeft"], 3, 1), rs.AddInterpCurve(self.involute["pointsRight"], 3, 1) ] gearTooth.append( rs.AddArc3Pt(self.involute["pointsTop"][0], self.involute["pointsTop"][1], self.involute["pointsTop"][2])) if (len(self.involute["ptsLeftDed"]) > 0): gearTooth.append( rs.AddLine(self.involute["ptsLeftDed"][0], self.involute["ptsLeftDed"][1])) if (len(self.involute["ptsRightDed"]) > 0): gearTooth.append( rs.AddLine(self.involute["ptsRightDed"][0], self.involute["ptsRightDed"][1])) #Join all curves of the first tooth and add it in the wholeGear array wholeGear = [ rs.JoinCurves(gearTooth, True)[0], [] ] #contains the first tooth and space for its right root arc #Create a datum point (in local coordinates) on the root circle and to the right of the first gear tooth #This becomes the seed for all midPoints of the root arcs datumPoint = rs.VectorRotate([0, self.RD / 2, 0], -180 / self.N, [0, 0, 1]) #VectorRotate works in degrees #Loop through each gear tooth for n in range(1, self.N + 1): #Compute the midpoint of the root arc midPoint = rs.VectorRotate(datumPoint, n * 360 / self.N, [0, 0, 1]) #local coordinates midPoint = rs.XformCPlaneToWorld(self.CalcBevelPoint(midPoint), self.plane) #world coordinates if (n < self.N): wholeGear.append( rs.RotateObject( wholeGear[0], self.plane[0], n * 360 / self.N, self.plane[3], True)) #Rotate and copy (in world coordinates) wholeGear.append( rs.AddArc3Pt( rs.CurveEndPoint(wholeGear[-1]), rs.CurveStartPoint(wholeGear[-3]), midPoint)) #AddArc3Pt(start, end, point_on_arc) else: wholeGear[1] = (rs.AddArc3Pt(rs.CurveEndPoint(wholeGear[0]), rs.CurveStartPoint(wholeGear[-2]), midPoint)) #Join the all the gear curves together wholeGear = rs.JoinCurves(wholeGear, True)[0] rs.UnselectObject(self.curve[0]) rs.SelectObject(wholeGear) rs.EnableRedraw(True)
def LEAF(startX, startY, width, left): if (left == True): rotationAngle = random.uniform(40, 140) elif (left == False): rotationAngle = random.uniform(200, 300) halfLeaf = rs.AddArc3Pt((startX, startY, 0), (startX, startY + 12, 0), (startX + width, startY + 4, 0)) secondHalf = rs.MirrorObject(halfLeaf, (startX, startY, 0), (startX, startY + 12, 0), copy=True) rs.RotateObject(halfLeaf, (startX, startY, 0), rotationAngle, axis=None, copy=False) rs.RotateObject(secondHalf, (startX, startY, 0), rotationAngle, axis=None, copy=False) veinPoints = [(startX, startY, 0)] widthFixer = 2.2 for points in range(1, 12, 2): veinPoint = (startX + random.uniform(-1, 1), startY + points, 0) veinPoints.append(veinPoint) # rs.AddPoint(veinPoint) if (points < 7): points = (startX - width + widthFixer, startY + points + random.uniform(-.5, .5), 0), veinPoint, (startX + width - widthFixer, startY + points + random.uniform(-.5, .5), 0) vein = rs.AddCurve(points) rs.RotateObject(vein, (startX, startY, 0), rotationAngle, axis=None, copy=False) widthFixer = widthFixer - 1 # print(widthFixer) elif (points == 7): widthFixer = .2 points = (startX - width + widthFixer, startY + points + random.uniform(-.5, .5), 0), veinPoint, (startX + width - widthFixer, startY + points + random.uniform(-.5, .5), 0) vein = rs.AddCurve(points) rs.RotateObject(vein, (startX, startY, 0), rotationAngle, axis=None, copy=False) elif (points > 7): widthFixer = widthFixer + 1 points = (startX - width + widthFixer, startY + points + random.uniform(-.5, .5), 0), veinPoint, (startX + width - widthFixer, startY + points + random.uniform(-.5, .5), 0) vein = rs.AddCurve(points) rs.RotateObject(vein, (startX, startY, 0), rotationAngle, axis=None, copy=False) # print(widthFixer) middleVein = rs.AddInterpCurve(veinPoints) rs.RotateObject(middleVein, (startX, startY, 0), rotationAngle, axis=None, copy=False)
petalWidth = 4 petalCurves = [] outerCircle = rs.AddCircle(flowerCenter, flowerRadius) points = rs.AddPoints(rs.DivideCurve(outerCircle, petalCount)) rs.HideObjects(points) for i in range(len(points)): centerLine = rs.AddLine(points[i], flowerCenter) rs.HideObject(centerLine) petalMidpoint = rs.AddPoint(rs.CurveMidPoint(centerLine)) rs.HideObjects(petalMidpoint) vector = rs.VectorCreate(points[i], petalMidpoint) vector = rs.VectorUnitize(vector) vector = rs.VectorScale(vector, (petalWidth / 2)) vector = rs.VectorRotate(vector, 90, [0, 0, 1]) petalEdgePoint = rs.CopyObject(petalMidpoint) petalEdgePoint = rs.MoveObject(petalEdgePoint, vector) curve = rs.AddArc3Pt(flowerCenter, points[i], petalEdgePoint) vector2 = rs.VectorRotate(vector, 180, [0, 0, 1]) petalEdgePoint2 = rs.CopyObject(petalMidpoint) petalEdgePoint2 = rs.MoveObject(petalEdgePoint2, vector2) curve2 = rs.AddArc3Pt(flowerCenter, points[i], petalEdgePoint2) petalCurves.append(rs.JoinCurves([curve, curve2])) rs.AddPlanarSrf(petalCurves) rs.MoveObject(rs.AddPlanarSrf(rs.AddCircle(flowerCenter, centerRadius)), [0, 0, .1]) rs.HideObjects(rs.ObjectsByType(4, True))
import rhinoscriptsyntax as rs p = rs.AddPoint(0, 0, 0) q = rs.AddPoint(0, 0, 10) t = rs.AddPoint(0, 5, 10) #l=rs.AddLine(p,q) l = rs.AddArc3Pt(p, q, t) c = rs.AddCircle(p, 5) m = rs.RotateObject(c, p, 45, None, False) cy = rs.ExtrudeCurve(m, l) for i in range(1, 25): i = i * 5 p = rs.AddPoint(0, i, i) q = rs.AddPoint(i, i, i * 10) t = rs.AddPoint(i, i * 5, 0) l = rs.AddArc3Pt(p, q, t) c = rs.AddCircle(p, 5) m = rs.RotateObject(c, p, 45, None, False) cy = rs.ExtrudeCurve(c, l)
def ArcTo(self, a, b, r, s): p = (a, 0, b) if p == self.currentPoint: return self.curves.append(rs.AddArc3Pt(self.currentPoint, p, (r, 0, s))) self.currentPoint = p