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
