def CreateKeyHole(self, z0, z1):
r = self.coreInnerRadius - self.tolerance
d = self.GetDraftDistance(z0, z1)
curve0 = self.CreateKeyCurve(r, z0)
curve1 = self.CreateKeyCurve(r - self.GetDraftDistance(z0, z1), z1, -d)
surface = rs.AddLoftSrf([curve0, curve1])
rs.DeleteObjects([curve0, curve1])
return surface
def __init__(self):
self.curve_object = rs.GetObject("Pick a backbone curve", 4, True,
False)
self.create_cross_sections()
self.brep = rs.AddLoftSrf(self.cross_sections)
self.points_from_cross()
self.add_text()
self.points_for_lines()
self.create_lines()
def render_path_visualization(points, mesh_normals, layer_heights, up_vectors,
extruder_toggles, cross_section,
planar_printing):
""" Visualize print paths with simple loft surfaces. """
# check input
assert len(points) == len(mesh_normals) == len(layer_heights) == len(up_vectors) == len(extruder_toggles), \
'Wrong length of input lists'
loft_surfaces = []
travel_path_lines = []
if points[0] and mesh_normals[0] and layer_heights[0] and up_vectors[
0]: # check if any of the values are None
if planar_printing: # then make sure that all normals lie on the xy plane
for n in mesh_normals:
n[2] = 0
# transform and scale cross sections accordingly
cen = rs.CurveAreaCentroid(cross_section)[0]
origin_plane = rg.Plane(cen, rg.Vector3d(1, 0, 0),
rg.Vector3d(0, 0, 1))
target_planes = []
for i, pt in enumerate(points):
target_plane = rg.Plane(pt, mesh_normals[i], up_vectors[i])
target_planes.append(target_plane)
cross_sections = []
for h, target_plane in zip(layer_heights, target_planes):
section = rs.ScaleObject(rs.CopyObject(cross_section),
origin=cen,
scale=[0.9 * h, 1, 0.9 * h])
T = rg.Transform.PlaneToPlane(origin_plane, target_plane)
rs.TransformObject(section, T)
cross_sections.append(section)
loft_surfaces = []
travel_path_lines = []
for i in range(len(points) - 1):
if extruder_toggles[i]:
loft = rs.AddLoftSrf(
[cross_sections[i], cross_sections[i + 1]])
if loft:
loft_surfaces.append(loft[0])
else:
line = rg.Curve.CreateControlPointCurve(
[points[i], points[i + 1]])
travel_path_lines.append(line) # add to travel path list
else:
print(
'At least one of the inputs that you have provided are invalid. ')
return loft_surfaces, travel_path_lines
def __generate_form_levels(self, spine_curve):
crvdomain = rs.CurveDomain(spine_curve)
printedState = ""
crosssection_planes = []
crosssection_plane_nums = []
crosssections = []
t_step = (crvdomain[1] - crvdomain[0]) / (
self.object_properties["number_of_lofts"] - 1)
t = crvdomain[0]
for t in rs.frange(crvdomain[0], crvdomain[1], t_step):
if (self.emotion_properties["vertical_AR"][str(int(t + 1))] !=
None):
crvcurvature = rs.CurveCurvature(spine_curve, t)
crosssectionplane = None
if not crvcurvature:
crvPoint = rs.EvaluateCurve(spine_curve, t)
crvTangent = rs.CurveTangent(spine_curve, t)
crvPerp = (0, 0, 1)
crvNormal = rs.VectorCrossProduct(crvTangent, crvPerp)
printedState = printedState + str(crvNormal)
crosssectionplane = rs.PlaneFromNormal(
crvPoint, crvTangent)
if (t == 0):
crosssectionplane = rs.PlaneFromNormal([0, 0, 0],
[0, 0, 1])
else:
crvPoint = crvcurvature[0]
crvTangent = crvcurvature[1]
crvPerp = rs.VectorUnitize(crvcurvature[4])
crvNormal = rs.VectorCrossProduct(crvTangent, crvPerp)
printedState = printedState + str(crvNormal)
crosssectionplane = rs.PlaneFromNormal(
crvPoint, crvTangent, crvNormal)
if crosssectionplane:
crosssection_planes.append(crosssectionplane)
crosssection_plane_nums.append(str(int(t + 1)))
if len(crosssection_plane_nums) > 0:
last_element = crosssection_plane_nums.pop(
len(crosssection_plane_nums) - 1)
crosssection_plane_nums.insert(0, last_element)
for index in xrange(len(crosssection_plane_nums)):
crosssections.append(
self.__generate_individual_levels(
crosssection_planes[index],
crosssection_plane_nums[index]))
if not crosssections: return
crosssections.append(crosssections.pop(0))
rs.AddLoftSrf(crosssections,
closed=False,
loft_type=int(
round(self.emotion_properties["vertical_wrapping"])))
return crosssection_planes[0]
def offsetBothCrvs(crvs, width):
if rs.IsCurveClosed(crvs):
domain = rs.CurveDomain(crvs)
parameter = (domain[0] + domain[1]) / 2.0
rs.CurveSeam(crvs, parameter)
offsets = []
offsets.append(rs.OffsetCurve(crvs, [0, 0, 0], width / 2))
offsets.append(rs.OffsetCurve(crvs, [0, 0, 0], -width / 2))
section = rs.AddLoftSrf(offsets, loft_type=2)
if offsets: rs.DeleteObjects(offsets)
return section
def CreateKey(self, z0, z1):
r = self.coreInnerRadius
d = self.GetDraftDistance(z0, z1)
curve0 = self.CreateKeyCurve(r, z0, d)
curve1 = self.CreateKeyCurve(r, z1)
surface = rs.AddLoftSrf([curve0, curve1])
rs.DeleteObjects([curve0, curve1])
curve0 = self.CreateKeyCurve(r, z0, d, True)
top = rs.AddPlanarSrf([curve0])
rs.DeleteObject(curve0)
surface = rs.JoinSurfaces([surface, top], True)
return surface
def wallBaseSrf(crv, width):
rs.SimplifyCurve(crv)
if rs.IsCurveClosed(crv):
domain = rs.CurveDomain(crv)
parameter = (domain[0] + domain[1]) / 2.0
rs.CurveSeam(crv, parameter)
offsets = map(lambda x: rs.OffsetCurve(crv, [0, 0, 0], x),
[width / 2, -width / 2])
section = rs.AddLoftSrf(offsets, loft_type=2)
if offsets: rs.DeleteObjects(offsets)
if rs.IsPolysurface(section):
return rs.ExplodePolysurfaces(section, delete_input=True)
return section
def CreateRadialBar(self, a, r0, r1, w, z0, z1, cap=False):
x0 = r0
y0 = -w / 2
x1 = r1
y1 = w / 2
r = w / 2
d = self.GetDraftDistance(z0, z1)
curve0 = self.CreateRadial(x0 + d, x1 - d, r - d, z0)
curve1 = self.CreateRadial(x0, x1, r, z1)
slot = rs.AddLoftSrf([curve0, curve1])
if cap:
slot = rs.JoinSurfaces([slot, rs.AddPlanarSrf([curve0])], True)
rs.DeleteObjects([curve0, curve1])
slot = rs.RotateObject(slot, (0, 0, 0), a, (0, 0, 1))
return slot
def curveVic(storyHt):
profiles = []
firstCrv = rs.GetObject("pick a base curve", 4, True, True)
count = rs.GetInteger("how many total curves")
#dentil = rs.GetObject("pick dentil", 8)
# vertically offset curves
for i in range(count):
if count == 0 or count == 1:
return
else:
profiles.append(rs.CopyObject(firstCrv, [0, 0, storyHt * i]))
# funk it up - needs to be more randomized?
for crv in profiles:
centerPt = rs.CurveAreaCentroid(crv)
# deg = random.randint(0,360)
# deg = random.randint(0,4) * 90 very swirly!
deg = profiles.index(crv) * 10
rs.RotateObject(crv, centerPt[0], deg)
# centerPt = rs.CurveAreaCentroid(profiles[3])
# rs.RotateObject(profiles[3], centerPt[0], 30)
# centerPt = rs.CurveAreaCentroid(profiles[7])
# rs.RotateObject(profiles[7], centerPt[0], 30)
# scale each crv randomly
# for crv in profiles:
# centerPt = rs.CurveAreaCentroid(crv)
# x = random.uniform(.25,2)
# y = random.uniform(.25,2)
# z = 1
# rs.ScaleObject(crv, centerPt[0], (x,y,z) )
# add dentils and trim. map to surface? project? rs.SporphObject() better to use in GUI flow?
# is there any flow along surface? no center box?!?! just acquire shape
# for j in range(len(profiles)):
# points = rs.DivideCurveEquidistant(profiles[j], 5)
# for k in points:
# rs.AddSphere(k, .25)
# loft curves and clean up
finalShape = rs.AddLoftSrf(profiles, closed=False)
#profiles.append(firstCrv)
rs.DeleteObjects(profiles)
rs.CapPlanarHoles(finalShape)
def __init__(self):
self.midpoints = []
self.partsHash = {}
self.curve_object = rs.GetObject("Pick a backbone curve", 4, True,
False)
self.outFile = rs.GetString('Input a name for the length file')
self.create_cross_sections()
self.brep = rs.AddLoftSrf(self.cross_sections)
self.points_from_cross()
# self.add_text()
self.points_for_lines()
self.create_lines()
self.label_and_len_lines()
rs.DeleteObjects(self.brep)
self.draw_points()
f = open('{0}.json'.format(self.outFile), 'w')
f.write(json.dumps(self.partsHash))
f.close()
def CreatingBeam(Crv, Rad):
EndPt = rs.CurveEndPoint(Crv)
StPt = rs.CurveStartPoint(Crv)
DirVec = EndPt - StPt
StPl = rs.PlaneFromNormal(StPt, DirVec)
EndPl = rs.PlaneFromNormal(EndPt, DirVec)
CirEd = rs.AddCircle(EndPl, Rad)
CirSt = rs.AddCircle(StPl, Rad)
IdsList = []
IdsList.append(CirSt)
IdsList.append(CirEd)
BeamGeometry = rs.AddLoftSrf(IdsList)
return BeamGeometry
def loft_profiles_aux(profiles, rails, is_ruled, is_closed):
profiles_refs = list([profile.realize()._ref for profile in profiles])
rails_refs = list([rail.realize()._ref for rail in rails])
if len(rails_refs) == 0:
return singleton(
rh.AddLoftSrf(profiles_refs, None, None, 2 if is_ruled else 0, 0,
0, is_closed))
elif len(rails_refs) == 1:
return singleton(rh.AddSweep1(rails_refs[0], profiles_refs))
elif len(rails_refs) == 2:
return singleton(rh.AddSweep2(rails_refs, profiles_refs))
elif len(rails_refs) > 2:
print('Warning: Rhino only supports two rails but were passed {0}'.
format(len(rails)))
return singleton(rh.AddSweep2(rails_refs[:2], profiles_refs))
else: #Remove?
raise RuntimeError(
'Rhino only supports two rails but were passed {0}'.format(
len(rails)))
def Main():
n = 15
radius = 3
width = 1
# two sets of points are defined
points_1 = []
points_2 = []
lines = []
for i in range(0, n): # notice how range() accepts variables
# a little trick here: as i goes from 0 to n-1, k will go from 0 to n / (n-1)
# the latter number is just a little under 1, so we don't add repetitive lines
k = i / n
# traverse the full circle
angle = k * 2 * math.pi
# first set of points
radius_p_1 = radius + width / 2 * math.cos(angle)
height_1 = width / 2 * math.sin(angle)
point_1 = [radius_p_1 * math.cos(angle), radius_p_1 * math.sin(angle), + height_1]
points_1.append(point_1)
# second set of points
radius_p_2 = radius - width / 2 * math.cos(angle)
height_2 = - width / 2 * math.sin(angle)
point_2 = [radius_p_2 * math.cos(angle), radius_p_2 * math.sin(angle), + height_2]
points_2.append(point_2)
for i in range(0, n):
lines.append(rs.AddLine(points_1[i], points_2[i]))
rs.AddLoftSrf(lines, None, None, 2, 0, 0, True)
def flatWorm():
curveObject = rs.GetObject("pick a backbone curve", 4, True, False)
samples = rs.GetInteger("# of crosssections", 100, 5)
bend_radius = rs.GetReal("bend radius", 0.5, 0.001) # r1
perp_radius = rs.GetReal("ribbon plan radius", 2.0, 0.001) #r2
crvDom = rs.CurveDomain(
curveObject
) # domain != length // why do we use domains? == "The domain is the set of all possible input values to the function that defines the curve or surface."
crossSections = [] # empty array to store sections
t_step = (crvDom[1] -
crvDom[0]) / samples # this is starting to be a pattern!
t = crvDom[0] # start pt for loop at the start of the line
for t in rs.frange(crvDom[0], crvDom[1],
t_step): # loop thru entire domain w/ floats
crvCurvature = rs.CurveCurvature(
curveObject, t
) # evaluate curve with a circle - gives 3d normals & gives radius info
crossSecPlane = None
if not crvCurvature:
crvPoint = rs.EvaluateCurve(curveObject, t)
crvTan = rs.CurveTangent(curveObject, t) # get tangent vector
crvPerp = (0, 0, 1)
crvNorm = rs.VectorCrossProduct(crvTan,
crvPerp) # = product of 2 vectors
crossSecPlane = rs.PlaneFromFrame(crvPoint, crvPerp, crvNorm)
else:
crvPoint = crvCurvature[0]
crvTan = crvCurvature[1]
crvPerp = rs.VectorUnitize(crvCurvature[4])
crvNorm = rs.VectorCrossProduct(crvTan, crvPerp) # look up
crossSecPlane = rs.PlaneFromFrame(crvPoint, crvPerp, crvNorm)
if crossSecPlane:
csec = rs.AddEllipse(
crossSecPlane, bend_radius, perp_radius
) # draw ellipse at tan/normal to point along curve with radii
crossSections.append(csec) # add ellipses to an array
t += t_step # step through domain
rs.AddLoftSrf(crossSections) # loft list of curves
rs.DeleteObjects(
crossSections) # delete original list of curves as cleanup
def FlatWorm():
curve_object = rs.GetObject("Pick a backbone curve", 4, True, False)
if not curve_object: return
samples = rs.GetInteger("Number of cross sections", 100, 5)
if not samples: return
bend_radius = rs.GetReal("Bend plane radius", 0.5, 0.001)
if not bend_radius: return
perp_radius = rs.GetReal("Ribbon plane radius", 2.0, 0.001)
if not perp_radius: return
crvdomain = rs.CurveDomain(curve_object)
crosssections = []
t_step = (crvdomain[1]-crvdomain[0])/samples
t = crvdomain[0]
while t<=crvdomain[1]:
crvcurvature = rs.CurveCurvature(curve_object, t)
crosssectionplane = None
if not crvcurvature:
crvPoint = rs.EvaluateCurve(curve_object, t)
crvTangent = rs.CurveTangent(curve_object, t)
crvPerp = (0,0,1)
crvNormal = rs.VectorCrossProduct(crvTangent, crvPerp)
crosssectionplane = rs.PlaneFromFrame(crvPoint, crvPerp, crvNormal)
else:
crvPoint = crvcurvature[0]
crvTangent = crvcurvature[1]
crvPerp = rs.VectorUnitize(crvcurvature[4])
crvNormal = rs.VectorCrossProduct(crvTangent, crvPerp)
crosssectionplane = rs.PlaneFromFrame(crvPoint, crvPerp, crvNormal)
if crosssectionplane:
csec = rs.AddEllipse(crosssectionplane, bend_radius, perp_radius)
crosssections.append(csec)
t += t_step
if not crosssections: return
rs.AddLoftSrf(crosssections)
rs.DeleteObjects(crosssections)
def CreatingNodeFun(Pt, Lines, BeamRad, BeamLength):
Beams = []
for i in Lines:
MidPt = rs.CurveMidPoint(i)
DirVe = MidPt - Pt
DirVecUni = rs.VectorUnitize(DirVe)
TrVec = rs.VectorScale(DirVecUni, BeamLength)
PtToMove = rs.AddPoint(pt)
EndPt = rs.MoveObject(PtToMove, TrVec)
Plane01 = rs.PlaneFromNormal(pt, DirVe)
Plane02 = rs.PlaneFromNormal(PtToMove, DirVe)
Ids = []
Cir01 = rs.AddCircle(Plane01, BeamRad)
Cir02 = rs.AddCircle(Plane02, BeamRad)
Ids.append(Cir01)
Ids.append(Cir02)
Beam = rs.AddLoftSrf(Ids)
Beams.append(Beam)
return Beams
def Previewwall(dict, index, crvs, zoommode):# 壁を作る # get_adjustの中身で処理を決める if dict[index][2] == 1: A = crvs[dict[index][0]] B = rs.OffsetCurve(crvs[dict[index][0]], rs.CurveMidPoint(crvs[dict[index][1]]), dict[index][3]) elif dict[index][2] == 2: A = rs.OffsetCurve(crvs[dict[index][1]], rs.CurveMidPoint(crvs[dict[index][0]]), dict[index][3]) B = crvs[dict[index][1]] elif dict[index][2] == 3: A = rs.OffsetCurve(crvs[dict[index][1]], rs.CurveMidPoint(crvs[dict[index][0]]), dict[index][3]) B = crvs[dict[index][1]] elif dict[index][2] == 4: A = crvs[dict[index][0]] B = rs.OffsetCurve(crvs[dict[index][0]], rs.CurveMidPoint(crvs[dict[index][1]]), dict[index][3]) obj_srf = rs.AddLoftSrf([A, B]) obj_height = rs.AddLine((0,0,0), (0,0,dict[index][4])) obj_wall = rs.ExtrudeSurface(obj_srf, obj_height) if zoommode:# 壁と曲線で箱を作り、箱をズーム obj_zoom = rs.BoundingBox([obj_wall, crvs[dict[index][0]], crvs[dict[index][1]]]) rs.ZoomBoundingBox(obj_zoom) return obj_wall
def leaf_gen(self, radius, thickness):
edge_pts = [
(0.0, radius, 0.0),
(0.0, radius, 2.0 * radius),
(- radius * 1.5, radius * 2.0, radius * 5.0),
(- radius * 1.5, radius * 2.0, radius * 8.0),
(0.0, radius / 2.0, radius * 12.0),
(radius, 0.0, radius * 13.0)
]
profile_pts_top = [[pt, ((0.5 * thickness) + pt[0], 0.0, pt[2]), (pt[0], -pt[1], pt[2])] for pt in edge_pts[:-1]]
profile_pts_bottom = [[(pt[0], -pt[1], pt[2]), ((-0.5 * thickness) + pt[0], 0.0, pt[2]), pt] for pt in edge_pts[:-1]]
crvs_top = [rs.AddCurve(pts) for pts in profile_pts_top]
crvs_bottom = [rs.AddCurve(pts) for pts in profile_pts_bottom]
profile_crvs = [rs.JoinCurves(crvs) for crvs in zip(crvs_top, crvs_bottom)]
srf = rs.AddLoftSrf(profile_crvs, end=edge_pts[-1])
cap = rs.AddPlanarSrf([profile_crvs[0]])
result = rs.JoinSurfaces([srf, cap])
return result
points = []
pointsRef = []
sides = 10
steps = 360/segements
theta = (2*math.pi)/segements
degrees = theta*(180/math.pi)
levels = 20
lofts = []
lastCircle = []
def createSegments():
for i in range(levels):
points = []
origin = [0+random.random()*depth,0+random.random()*depth,i*levelres]
point1 = rs.AddPoint(radius,0,i*levelres)
points.append(point1)
for i in range(1, segements):
tempPoint = points[-1]
tempOrgin = [origin[0] + random.random()*depth, origin[1] + random.random()*depth, origin[2]+1]
newPt = rs.RotateObject(tempPoint,tempOrgin,degrees,None,True)
points.append(newPt)
points.append(point1)
lastCircle.append(tempOrgin)
polygon = rs.AddPolyline(points)
lofts.append(polygon)
return lofts
lofts = createSegments()
rs.AddLoftSrf(lofts, loft_type = 3)
rs.AddPlanarSrf(lofts[0])
x = i
y = yFactor * math.cos(i)
z = 0
points.append(x)
points.append(y)
points.append(z)
cosCurve = rs.AddCurve(points)
points2 = []
for i in range(-50, 50):
x = i
y = yFactor2 * math.cos(i)
z = 50
points2.append(x)
points2.append(y)
points2.append(z)
cosCurve2 = rs.AddCurve(points2)
ids = [cosCurve, cosCurve2]
rs.AddLoftSrf(ids)
def loft(self, f, s, t):
if not rs.CurveDirectionMatch(f, s):
rs.ReverseCurve(s)
if not rs.CurveDirectionMatch(s, t):
rs.ReverseCurve(t)
return rs.AddLoftSrf([f, s, t])
y3 = random.randint(0,50) z3 = random.randint(0,50) x4 = random.randint(0,50) y4 = random.randint(0,50) z4 = random.randint(0,50) p1 = rs.AddPoint(x1,y1,0) p2 = rs.AddPoint(x2,0,z2) p3 = rs.AddPoint(0,y3,z3) p4 = rs.AddPoint(x4,y4,50) p5 = rs.AddPoint(x4,50,z4) p6 = rs.AddPoint(50,y4,z4) A = rs.AddInterpCurve([a,p3,b],3,0,None,None) B = rs.AddInterpCurve([b,p4,c],3,0,None,None) C = rs.AddInterpCurve([c,p6,d],3,0,None,None) D = rs.AddInterpCurve([d,p1,a],3,0,None,None) rs.ReverseCurve(B) rs.ReverseCurve(D) rs.AddLoftSrf([A,B],None,None,0,0,0,False) rs.AddLoftSrf([C,B],None,None,0,0,0,False) rs.AddLoftSrf([C,D],None,None,0,0,0,False) rs.AddLoftSrf([A,D],None,None,0,0,0,False) #
import rhinoscriptsyntax as rs
import random
point = []
z = 0
for i in range(10):
x = random.random() * 30
y = random.random() * 30
p = rs.AddPoint(x, y, z)
point.append(p)
curve1 = rs.AddCurve(point)
for i in range(10):
x = random.random() * 30
y = random.random() * 30
p = rs.AddPoint(x, y, z)
point.append(p)
curve2 = rs.AddCurve(point)
move = rs.MoveObject(curve2, [0, 0, 10])
curves = [curve1, curve2]
if curves:
rs.AddLoftSrf(curves)
import rhinoscriptsyntax as rs
##################Inputs##################
#get curve from rhino space
crv1 = rs.GetObject("Select First Curve", rs.filter.curve)
crv2 = rs.GetObject("Select Second Curve", rs.filter.curve)
#number of divisions for curve
ndiv = 20
#List definition
pt1 = []
pt2 = []
Lines = []
##################Geometric Operations##################
#divide curves
pt1 = rs.DivideCurve(crv1, ndiv, True, True)
pt2 = rs.DivideCurve(crv2, ndiv, True, True)
#when range is used, it starts at 0 and ends at number inside ()
for i in range(ndiv + 1):
#add elements to lines
Lines.append(rs.AddLine(pt1[i], pt2[i]))
#prints i on every loop
print i
Srf1 = rs.AddLoftSrf(Lines)
def reconSrf(self, crvList):
assert (crvList != None)
return rs.AddLoftSrf(crvList, closed=True)
width = 3.325
gap = .8
spaceBetweenBricks = length+gap
rowCount = 10
rotation = 0
#create the world axis as vectors
worldZAxis = rs.VectorCreate([0,0,1],[0,0,0])
#create curves to define wall and loft to get wall surface
upperCurve = rs.AddCurve([[0,0,0],[50,0,0]])
lowerCurve = rs.AddCurve([[0,0,0],[50,0,0]])
#lowerCurve = rs.AddCurve(rs.GetPoints(True,True,'Please select points to create lower curve of wall'))
#upperCurve = rs.AddCurve(rs.GetPoints(True,True,'Please select points to create upper curve of wall, be sure to start on the same end of the wall as the lower curve'))
upperCurve2 = rs.CopyObject(upperCurve,rs.VectorScale(worldZAxis,(height*rowCount)))
loftedSurface = rs.AddLoftSrf([lowerCurve,upperCurve2])
rs.HideObjects([loftedSurface,lowerCurve,upperCurve,upperCurve2])
#intersect planes with surface to get the profile of the wall at each row
intersected = rs.AddSrfContourCrvs(loftedSurface,([0,0,0], [0,0,(height*rowCount)]),height)
rs.HideObjects(intersected)
#make list of even and list of odd row profiles
intersectedEven = []
intersectedOdd = []
for i in range(len(intersected)):
if i%2 == 0 :
intersectedEven.append(intersected[i])
else:
intersectedOdd.append(intersected[i])
obj = CurveSplit(leCurve, teCurve, NumberOfSegments)
lePoints = obj.GetPoints(leCurve)
tePoints = obj.GetPointsOnSecondCurve(teCurve, lePoints)
# Adjust the leading edge point locaiton based on the desired dihedral
newLEPoints = obj.generateLeadingEdgeWithDihedral(
lePoints, NumberOfSegments)
Sections = []
for i in range(0, len(lePoints)):
epsilon = i / len(lePoints)
print "Epsilon %.2f" % (epsilon)
# Determine the length of the chord to generate
chordLength = abs(lePoints[i][0] - tePoints[i][0])
Airfoil, ChordLine = obj.AerofoilAtPoint(NumberOfSegments, epsilon,
lePoints[i], chordLength)
#Airfoil, ChordLine = obj.AerofoilAtPoint(NumberOfSegments, epsilon, newLEPoints[i],chordLength)
rs.DeleteObjects(ChordLine)
list.append(Sections, Airfoil)
#lss = rs.AddLoftSrf(Sections,)
LS = rs.AddLoftSrf(Sections)
rs.DeleteObjects(Sections)
if LS == None:
# Failed to fit loft surface. Try another fitting algorithm
print "loft failed"
d = rs.Distance(pts_gcrv1[i], pts_gcrv2[i])
sf = -d * 0.3 # shear factor
nz1 = pts_gcrv1[i][2] #n = new # z = coordinate
nx1 = pts_gcrv1[i][0] + sf # x = coordinate
ny1 = pts_gcrv1[i][1] # y = coordinate
npts_gcrv1 = (nx1, ny1, nz1)
spts_list1.append(npts_gcrv1)
nz2 = pts_gcrv2[i][2] #n = new # z = coordinate
nx2 = pts_gcrv2[i][0] - sf # x = coordinate
ny2 = pts_gcrv2[i][1] # y = coordinate
npts_gcrv2 = (nx2, ny2, nz2)
spts_list2.append(npts_gcrv2)
print("TEST", "Point added")
scrv1 = rs.AddInterpCurve(spts_list1)
scrv2 = rs.AddInterpCurve(spts_list2)
pts_scrv1 = rs.DivideCurve(scrv1, div)
pts_scrv2 = rs.DivideCurve(scrv2, div)
rs.AddLoftSrf([gcrv1, scrv1])
rs.AddLoftSrf([gcrv2, scrv2])
#add the pipe for outer frame
pipe_frame1 = rs.AddPipe(scrv1, 0, rad)
pipe_frame2 = rs.AddPipe(scrv2, 0, rad)
import rhinoscriptsyntax as rs
import random
pickedCurves = rs.GetObjects("pick some curves", 4)
for curve in pickedCurves:
counter = 0
vector = (random.uniform(-5, 5), random.uniform(-5,
5), random.uniform(-5, 5))
newCurve = rs.CopyObject(curve, vector)
surface = rs.AddLoftSrf([curve, newCurve])
newCurveMidPoint = rs.CurveMidPoint(newCurve)
x = newCurveMidPoint[0]
y = newCurveMidPoint[1]
z = newCurveMidPoint[2]
while x < 100 and x > -100 and y < 100 and y > -100 and z < 100 and z > -100:
counter += 1
previousCurve = newCurve
newCurve = rs.CopyObject(newCurve, vector)
if counter % 2 == 0:
surface = rs.AddLoftSrf([previousCurve, newCurve])
newCurveMidPoint = rs.CurveMidPoint(newCurve)
x = newCurveMidPoint[0]
y = newCurveMidPoint[1]
z = newCurveMidPoint[2]
x1 = random.randint(0, 50)
y1 = random.randint(0, 50)
z1 = random.randint(0, 50)
x2 = random.randint(0, 50)
y2 = random.randint(0, 50)
z2 = random.randint(0, 50)
x3 = random.randint(0, 50)
y3 = random.randint(0, 50)
z3 = random.randint(0, 50)
x4 = random.randint(0, 50)
y4 = random.randint(0, 50)
z4 = random.randint(0, 50)
p1 = rs.AddPoint(x1, y1, z1)
p2 = rs.AddPoint(x2, y2, z2)
p3 = rs.AddPoint(x3, y3, z3)
p4 = rs.AddPoint(x4, y4, z4)
A = rs.AddInterpCurve([a, p1, b], 3, 0, None, None)
B = rs.AddInterpCurve([c, p2, d], 3, 0, None, None)
C = rs.AddInterpCurve([e, p3, f], 3, 0, None, None)
D = rs.AddInterpCurve([g, p4, h], 3, 0, None, None)
m = 20
A1 = rs.DivideCurve(A, m, True, True)
B1 = rs.DivideCurve(B, m, True, True)
C1 = rs.DivideCurve(C, m, True, True)
D1 = rs.DivideCurve(D, m, True, True)
rs.AddLoftSrf([A, B], None, None, 0, 0, 0, False)
for i in range(m):
rs.AddLine(A1[i], B1[i])
rs.AddLine(B1[i], C1[i])
