def fillet_lines(self):
self.lines = []
for i in range(0, len(self.line_lists)):
fillets = []
new_line = []
for j in range(0, len(self.line_lists[i]) - 1):
fillets.append(
rs.AddFilletCurve(self.line_lists[i][j],
self.line_lists[i][j + 1], 1))
for k in range(0, len(self.line_lists[i])):
line = self.line_lists[i][k]
if (k < len(self.line_lists[i]) - 1):
line_domain = rs.CurveDomain(line)
line_intersect = rs.CurveCurveIntersection(
line, fillets[k])[0][5]
line = rs.TrimCurve(self.line_lists[i][k],
(line_domain[0], line_intersect), True)
if (k > 0):
line_domain = rs.CurveDomain(line)
line_intersect = rs.CurveCurveIntersection(
line, fillets[k - 1])
line = rs.TrimCurve(line,
(line_intersect[0][5], line_domain[1]),
True)
new_line.append(line)
if (k < len(self.line_lists[i]) - 1):
new_line.append(fillets[k])
self.lines.append(rs.JoinCurves(new_line))
def double_pitch(m, n, o, p, diffY, diffZ):
"""generates a double pitch roof"""
# cullis
cullisN = rs.AddLine(m, n)
cullisP = rs.AddLine(p, o)
# ridge
cullisO = rs.AddLine(n, o)
domainO = rs.CurveDomain(cullisO)
cullisM = rs.AddLine(p, m)
domainM = rs.CurveDomain(cullisM)
midCullisO = rs.EvaluateCurve(cullisO, (domainO[1] / 2.0))
midCullisM = rs.EvaluateCurve(cullisM, (domainM[1] / 2.0))
ridgeM = rs.PointAdd(rs.PointAdd(midCullisM, [0, 0, diffZ]), [0, diffY, 0])
ridgeO = rs.PointAdd(rs.PointAdd(midCullisO, [0, 0, diffZ]),
[0, -diffY, 0])
ridge = rs.AddLine(ridgeM, ridgeO)
allGeometry.append(rs.AddLoftSrf([cullisN, ridge]))
allGeometry.append(rs.AddLoftSrf([cullisP, ridge]))
# gable
ridgeOPt = ridgeO
ridgeMPt = ridgeM
# print(m)
# print(ridgeMPt)
# print(p)
allGeometry.append(rs.AddSrfPt([m, ridgeMPt, p]))
allGeometry.append(rs.AddSrfPt([n, ridgeOPt, o]))
def createPipe(self, first, mid, last, text):
first_fillet = rs.AddFilletCurve(first, mid, 0.25)
fillet_points = rs.CurveFilletPoints(first, mid, 0.25)
first_circle = rs.AddCircle(fillet_points[2], 0.125)
first_cp = rs.CurveClosestPoint(first, fillet_points[0])
first_domain = rs.CurveDomain(first)
nfirst = rs.TrimCurve(first, (first_domain[0], first_cp), False)
second_cp = rs.CurveClosestPoint(mid, fillet_points[1])
second_domain = rs.CurveDomain(mid)
nmid = rs.TrimCurve(mid, (second_cp, second_domain[1]), False)
second_fillet = rs.AddFilletCurve(mid, last, 0.25)
fillet_points = rs.CurveFilletPoints(mid, last, 0.25)
second_circle = rs.AddCircle(fillet_points[2], 0.125)
first_cp = rs.CurveClosestPoint(mid, fillet_points[0])
first_domain = rs.CurveDomain(mid)
nmid = rs.TrimCurve(nmid, (first_domain[0], first_cp), False)
second_cp = rs.CurveClosestPoint(last, fillet_points[1])
second_domain = rs.CurveDomain(last)
nlast = rs.TrimCurve(last, (second_cp, second_domain[1]), False)
curve = rs.JoinCurves(
[nfirst, first_fillet, nmid, second_fillet, nlast])
print curve
pipe = rs.AddPipe(curve, 0, 0.09375, 0, 1)
points = [
rs.CurveStartPoint(first),
rs.CurveEndPoint(first),
rs.CurveStartPoint(last),
rs.CurveEndPoint(last)
]
self.copyAndMover(first, mid, last, points, text)
def fillet_lines(self):
self.lines = []
for i in range(0, len(self.line_lists)):
fillets = []
new_line = []
for j in range(0, len(self.line_lists[i]) - 1):
first_line = self.line_lists[i][j]
second_line = self.line_lists[i][j + 1]
fillet = rs.AddFilletCurve(first_line, second_line, 0.125)
fillet_points = rs.CurveFilletPoints(first_line, second_line,
0.125)
first_cp = rs.CurveClosestPoint(first_line, fillet_points[0])
first_domain = rs.CurveDomain(first_line)
self.line_lists[i][j] = rs.TrimCurve(
first_line, (first_domain[0], first_cp), True)
second_cp = rs.CurveClosestPoint(second_line, fillet_points[1])
second_domain = rs.CurveDomain(second_line)
self.line_lists[i][j + 1] = rs.TrimCurve(
second_line, (second_cp, second_domain[1]), True)
fillets.append(fillet)
for k in range(0, len(self.line_lists[i])):
new_line.append(self.line_lists[i][k])
if (k < len(self.line_lists[i]) - 1):
new_line.append(fillets[k])
new_curve = self.get_curve_from_segments(new_line)
self.lines.append(new_curve)
def copyAndMover(self, first, mid, last, points, text):
plane = rs.PlaneFromPoints(points[0], points[1], points[2])
uv1 = rs.PlaneClosestPoint(plane, points[1], False)
uv2 = rs.PlaneClosestPoint(plane, points[2], False)
distHor = abs(uv1[0] - uv2[0])
distVert = abs(uv1[1] - uv2[1])
key = 'len{0}{1}'.format(distHor, distVert)
key = re.sub(r'\.', '', key)
if key in self.partsHash:
self.partsHash[key].append(text)
else:
self.partsHash[key] = []
self.partsHash[key].append(text)
ypos = len(self.partsHash.keys()) + len(self.partsHash.keys())
rs.AddText(key, [0, ypos, 0], 0.3)
newPoints = [
rs.AddPoint(0, ypos, 0),
rs.AddPoint(self.FLAT_LENGTH, ypos, 0),
rs.AddPoint(self.FLAT_LENGTH + distHor, ypos + distVert, 0),
rs.AddPoint((self.FLAT_LENGTH * 2) + distHor, ypos + distVert,
0)
]
first = rs.OrientObject(first, points, newPoints, 1)
mid = rs.OrientObject(mid, points, newPoints, 1)
last = rs.OrientObject(last, points, newPoints, 1)
first_fillet = rs.AddFilletCurve(first, mid, 0.09375)
fillet_points = rs.CurveFilletPoints(first, mid, 0.09375)
first_circle = rs.AddCircle(fillet_points[2], 0.09375)
first_cp = rs.CurveClosestPoint(first, fillet_points[0])
first_domain = rs.CurveDomain(first)
first = rs.TrimCurve(first, (first_domain[0], first_cp), True)
second_cp = rs.CurveClosestPoint(mid, fillet_points[1])
second_domain = rs.CurveDomain(mid)
mid = rs.TrimCurve(mid, (second_cp, second_domain[1]), True)
second_fillet = rs.AddFilletCurve(mid, last, 0.09375)
fillet_points = rs.CurveFilletPoints(mid, last, 0.09375)
second_circle = rs.AddCircle(fillet_points[2], 0.09375)
first_cp = rs.CurveClosestPoint(mid, fillet_points[0])
first_domain = rs.CurveDomain(mid)
mid = rs.TrimCurve(mid, (first_domain[0], first_cp), True)
second_cp = rs.CurveClosestPoint(last, fillet_points[1])
second_domain = rs.CurveDomain(last)
last = rs.TrimCurve(last, (second_cp, second_domain[1]), True)
curve = rs.JoinCurves(
[first, first_fillet, mid, second_fillet, last])
rs.AddCircle([0, ypos - 0.125 - 0.09375, 0], 0.09375)
rs.AddCircle([(self.FLAT_LENGTH * 2) + distHor,
ypos + distVert + 0.125 + 0.09375, 0], 0.09375)
def BSearchCurve(idCrv, Length, Tolerance):
Lcrv = rs.CurveLength(idCrv)
if Lcrv < Length: return
tmin = rs.CurveDomain(idCrv)[0]
tmax = rs.CurveDomain(idCrv)[1]
t0 = tmin
t1 = tmax
while True:
t = 0.5 * (t1 + t0)
Ltmp = rs.CurveLength(idCrv, 0, [tmin, t])
if abs(Ltmp - Length) < Tolerance: return t
if Ltmp < Length: t0 = t
else: t1 = t
def RecursiveGrowth(ptStart, vecDir, props, gen):
minTwigCount, maxTwigCount, maxGen, maxTwigLength, lengthMutation,maxTwigAngle, angleMutation = props
if gen > maxGen : return
newProps = props
maxTwigLength *= lengthMutation
maxTwigAngle *= angleMutation
if maxTwigAngle>90:maxTwigAngle=90
newProps = minTwigCount, maxTwigCount, maxGen, maxTwigLength, lengthMutation, maxTwigAngle, angleMutation
maxN=int(minTwigCount+random.random()* (maxTwigCount-minTwigCount))
for n in range (0,maxN):
newPoint = RandomPointInCone (ptStart, vecDir, .25*maxTwigLength, maxTwigLength, maxTwigAngle)
newProps = minTwigCount, maxTwigCount, maxGen, maxTwigLength, lengthMutation,maxTwigAngle, angleMutation
maxN=int(minTwigCount+random.random()* (maxTwigCount-minTwigCount) )
for n in range(0,maxN):
newPoint = RandomPointInCone(ptStart, vecDir, .25*maxTwigLength, maxTwigLength, maxTwigAngle)
newTwig = AddArcDir(ptStart, newPoint, vecDir)
if newTwig:
vecGrow = rs.CurveTangent(newTwig, rs.CurveDomain(newTwig)[1])
RecursiveGrowth(newPoint, vecGrow, newProps, gen+1)
def cxc(crv, pt, r, onlyNext=True):
trash = []
xc = rs.AddCircle(pt, r)
xx = rs.CurveCurveIntersection(crv, xc)
xpts = []
if xx is None: return None
#print('xx len:',len(xx))
for xxe in xx:
if xxe[0] == 1:
xpts.append(xxe[1])
rs.DeleteObject(xc)
dom = rs.CurveDomain(crv)
# endT=rs.CurveClosestPoint(crv,rs.CurveEndPoint(crv))
# print('endT :'endT)
if onlyNext:
centerT = rs.CurveClosestPoint(crv, pt)
maxT = dom[0]
maxI = 0
for i in range(0, len(xpts)):
p = xpts[i]
t = rs.CurveClosestPoint(crv, p)
if t > maxT:
maxT = t
maxI = i
# print(dom[1],centerT,t)
if maxT > dom[1] or maxT < centerT:
return None
return xpts[maxI]
return xpts
def slice_sequence(crvs, seq_count):
pt_slice = []
frame = 1 / seq_count
# print frame
for i in xrange(len(crvs)):
crv = crvs[i]
crv = rs.coercecurve(crv)
start_pt, end_pt = rs.CurveDomain(crv)
# print start_pt, "to", end_pt ### [0 to len(Curves)]
param_slice = []
for j in xrange(int(end_pt)):
for k in xrange(seq_count):
value = j + k * frame
param_slice.append(value)
param_slice.append(end_pt)
# print param_slice
# print len(param_slice)
sub_list = []
for l in xrange(len(param_slice)):
pt = rg.Curve.PointAt(crv, param_slice[l])
sub_list.append(pt)
pt_slice.append(sub_list)
return pt_slice
def getExtendedCrv(self, crvList, dist=50, layer_height=2.5, vecMul=.66):
segmentCount = int(math.floor(dist / layer_height)) - 1
tmpList = []
fullHeight = []
for i in range(len(crvList)):
extendedCrv = rs.ExtendCurveLength(crvList[i], 2, 0, dist)
fullHeight.append(extendedCrv)
domStart, domEnd = rs.CurveDomain(extendedCrv)
trimmedCrv = rs.TrimCurve(extendedCrv, (domStart, 0))
tmpList.append(trimmedCrv)
tmp = []
###Smooth Curves###
for i in range(len(tmpList)):
bottomPt = rs.CurveEndPoint(tmpList[i])
zVec = rs.VectorAdd((0, 0, 0), (0, 0, dist))
topPt = rs.CopyObject(bottomPt, zVec)
line = rs.AddLine(bottomPt, topPt)
crvPts = rs.DivideCurve(tmpList[i], segmentCount)
LinePts = rs.DivideCurve(line, segmentCount)
for i in range(segmentCount):
tmpVec = rs.VectorCreate(LinePts[segmentCount - i - 1],
crvPts[i])
tmpVec = rs.VectorScale(tmpVec, vecMul)
rs.MoveObject(crvPts[i], tmpVec)
tmp.append(rs.AddInterpCurve(crvPts))
result = []
for crv in tmp:
crvLen = rs.CurveLength(crv)
if crvLen < dist:
tmpExt = dist - crvLen
result.append(rs.ExtendCurveLength(crv, 2, 0, tmpExt))
else:
result.append(rs.CopyObject(crv))
return result
def get_edge_keys_and_param(message='Select edge.', layer=None):
if layer:
objs = rs.ObjectsByLayer(layer)
selectable = []
for obj in objs:
if "edge" in rs.ObjectName(obj):
selectable.append(obj)
else:
selectable = None
guid = rs.GetObjectEx(message, 4, False, False, selectable)
uv = None
t = None
if guid:
guid = guid[0]
name = rs.ObjectName(guid).split('.')
if 'edge' in name:
pt = rs.GetPointOnCurve(guid, "Select point on edge")
if not pt: return None, None
param = rs.CurveClosestPoint(guid, pt)
lb, ub = rs.CurveDomain(guid)
t = (param - lb) / (ub - lb)
print(lb, ub)
key = name[-1]
uv = tuple(key.split('-'))
return uv, t
def create_jig(self, list):
jigs = []
for i in range(0, len(list), 2):
domain = rs.CurveDomain(list[i])
start_point = rs.EvaluateCurve(list[i], domain[0])
end_point = rs.EvaluateCurve(list[i], domain[1])
start_plane = rs.PlaneFromNormal(
start_point, rs.VectorUnitize(end_point - start_point))
end_plane = rs.PlaneFromNormal(
end_point, rs.VectorUnitize(start_point - end_point))
start_curve_point = self.closest_intersection(
rs.PlaneCurveIntersection(start_plane, self.curve_object),
start_point)
end_curve_point = self.closest_intersection(
rs.PlaneCurveIntersection(end_plane, self.curve_object),
end_point)
start_vector = rs.VectorUnitize(
rs.VectorCreate(start_point, start_curve_point))
end_vector = rs.VectorUnitize(
rs.VectorCreate(end_point, end_curve_point))
start_vector_scale = rs.VectorScale(start_vector, -5)
end_vector_scale = rs.VectorScale(end_vector, -5)
start_square = self.create_square(
rs.PointAdd(start_point, start_vector_scale),
rs.PointAdd(end_point, end_vector_scale), start_vector)
end_square = self.create_square(
rs.PointAdd(end_point, end_vector_scale),
rs.PointAdd(start_point, start_vector_scale), end_vector)
jigs.append(self.create_jig_section(start_square, end_square))
return jigs
def create_cross_sections(self):
crvdomain = rs.CurveDomain(self.curve_object)
self.cross_sections = []
self.cross_section_planes = []
t_step = (crvdomain[1] - crvdomain[0]) / self.SAMPLES
pi_step_size = math.pi / self.SAMPLES
pi_step = 0
prev_normal = None
prev_perp = None
for t in rs.frange(crvdomain[0], crvdomain[1], t_step):
crvcurvature = rs.CurveCurvature(self.curve_object, t)
crosssectionplane = None
if not crvcurvature:
crosssectionplane = self.cross_section_plane_no_curvature(
t, prev_normal, prev_perp)
else:
crosssectionplane = self.cross_section_plane_curvature(
crvcurvature, prev_normal, prev_perp)
if crosssectionplane:
prev_perp = crosssectionplane.XAxis
prev_normal = crosssectionplane.YAxis
pi_scalar = self.create_scalar(pi_step)
radii = self.ellipse_radii(pi_scalar)
csec = rs.AddEllipse(crosssectionplane, radii[0], radii[1])
self.cross_sections.append(csec)
self.cross_section_planes.append(crosssectionplane)
pi_step += pi_step_size
def addpointat_r1_parameter(curve_id, parameter):
domain = rs.CurveDomain(curve_id)
if not domain: return
r1_param = domain[0] + parameter * (domain[1] - domain[0])
r3point = rs.EvaluateCurve(curve_id, r1_param)
if r3point:
point_id = rs.AddPoint(r3point)
rs.ObjectColor(point_id, parametercolor(parameter))
def renderSubTree(self, startRadius, growthFactor, curveDegree): #start radius is the radius at the tip of the smallest branches #growth Factor is the factor by which the start radius grows #as it moves towards the root, node by node #curveDegree is the degree of the curves of the tree treeID = rs.AddGroup() while True: deepCh = self.deepestChild() startNode = deepCh[0] if startNode == None: #this is the case where the whole tree is rendered #later return the group id of the group #that contains the whole tree from here return treeID curNode = startNode nodeList = [startNode] while (not curNode.parent is None) and (not curNode.isDone): nodeList.append(curNode.parent) curNode = curNode.parent posList = [] i = 0 while i < len(nodeList): posList.append(nodeList[i].pos) i += 1 curveID = rs.AddCurve(posList,curveDegree) curDom = rs.CurveDomain(curveID) node1 = rs.EvaluateCurve(curveID, curDom[0]) node2 = rs.EvaluateCurve(curveID, curDom[1]) tan1 = rs.CurveTangent(curveID, curDom[0]) tan2 = rs.CurveTangent(curveID, curDom[1]) plane1 = rs.PlaneFromNormal(node1, tan1) plane2 = rs.PlaneFromNormal(node2, tan2) radius1 = startRadius radius2 = (growthFactor**len(nodeList))*startRadius circles = [] circles.append(rs.AddCircle(plane1, radius1)) circles.append(rs.AddCircle(plane2, radius2)) branch = rs.AddSweep1(curveID, circles, True) rs.AddObjectToGroup(branch, treeID) rs.DeleteObjects(circles) rs.DeleteObject(curveID) for nd in nodeList: nd.isDone = True
def draw_hole(grid00, grid01):
grids = [grid00, grid01]
points = []
lists = []
for i in grids:
domain = rs.CurveDomain(i)
domains = [domain[0] + b, domain[1] - b0 * b, domain[1] - b]
lists.append(domains)
for ii in domains:
point = rs.EvaluateCurve(i, ii)
points.append(point)
for i in range(2):
grid = rs.AddCurve([points[i * 3], points[5 - i * 3]])
domain0 = rs.CurveDomain(grid)
domain1 = domain0[1] - c
point = rs.EvaluateCurve(grid, domain1)
#rs.AddPoint(point)
rs.AddCurve([point, points[i * 3 + 1]])
rs.TrimCurve(grids[i], (lists[i][0], lists[i][1]))
rs.TrimCurve(grid, (domain0[0], domain1))
def addPoint(curve_id, parameter):
domain = rs.CurveDomain(curve_id)
r1_param = domain[0] + (parameter *
(domain[1] - domain[0])) # slice curve domain
r3point = rs.EvaluateCurve(curve_id,
r1_param) # at each domain chunk, store a var
if r3point:
point_id = rs.AddPoint(
r3point) # add new point object along each domain chunk
rs.ObjectColor(point_id, paramColor(
parameter)) # color each point with a incrementing param
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 __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 GetHolepoint ():
id = rs.GetObject("select hole curve",4,True,True)
n = rs.GetInteger("How may hole point")
if not id or n <=0:
print "illegal selection or interger"
return
domain = rs.CurveDomain(id)
t = 0
while t<=1.0:
point = rs.EvaluateCurve(id,domain[0]+t*(domain[1]-domain[0]))
print point[0],' ',point[1],' ',point[2]
t+=1.0/n
def createMarkSphere(curve_list):
curve = curve_list[0]
domain = rs.CurveDomain(curve)
t = domain[1] / 2.0
point = rs.EvaluateCurve(curve, t)
mark_collision = rs.AddSphere(point, 40)
rs.ObjectColor(mark_collision, [255, 0, 0])
return mark_collision
def space(self, density):
space = []
density = int(density)
if rs.IsCurve(self.guid):
domain = rs.CurveDomain(self.guid)
u = (domain[1] - domain[0]) / (density - 1)
for i in range(density):
space.append(domain[0] + u * i)
elif rs.IsPolyCurve(self.guid):
rs.EnableRedraw(False)
segments = rs.ExplodeCurves(self.guid)
for segment in segments:
domain = rs.CurveDomain(segment)
u = (domain[1] - domain[0]) / (density - 1)
for i in range(density):
space.append(domain[0] + u * i)
rs.DeleteObjects(segments)
rs.EnableRedraw(True)
else:
raise Exception('Object is not a curve.')
return space
def periods_ofcurve(curve, n):
domain = rs.CurveDomain(curve)
cpoint_list = []
point0 = rs.EvaluateCurve(curve, domain[0])
point1 = rs.EvaluateCurve(curve, domain[1])
#rs.AddPoints( [ point0, point1 ] )
for i in range(n + 1):
d = domain[1] * (i) / n
point_lower = rs.EvaluateCurve(curve, d - a)
point_upper = rs.EvaluateCurve(curve, d + a)
cpoint_list.append(point_lower)
cpoint_list.append(point_upper)
return cpoint_list
def curvePlnrNormalAtEnds(crv):
up = (0, 0, 1)
dom = rs.CurveDomain(crv)
t0 = dom[0]
t1 = dom[1]
pln0 = rs.CurvePerpFrame(crv, t0)
pln1 = rs.CurvePerpFrame(crv, t1)
n0 = rs.VectorCrossProduct(pln0.ZAxis, up)
n1 = rs.VectorCrossProduct(pln1.ZAxis, up)
return n0, n1
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 splitLine(line):
#obtain the curve (line) minimum and maximum (domain)
lineDomain = rs.CurveDomain(line)
min = lineDomain[0]
max = lineDomain[1]
OneThird = (max - min) / 3
TwoThird = (max - min) * 2 / 3
StartLine = rs.TrimCurve(line, (min, min + OneThird), False)
EndLine = rs.TrimCurve(line, (min + TwoThird, max))
SplitLine = (StartLine, EndLine)
#return the array of two lines
return SplitLine
def iterativePanel(lengthPanel):
#aux elements
crvBase = rs.GetObject("Iterative mode, Select curve to be use as rail", rs.filter.curve)
#domain for split the curve into equal parts
domain = rs.CurveDomain(crvBase)
t = domain[1]/2.0
crvSplit = rs.SplitCurve(crvBase, t)
#building the core
pEnd = rs.DivideCurveEquidistant(crvSplit[1], lengthPanel, True)
for i in range (len(pEnd)-1):
#rs.AddCircle(pEnd[i], 5) #Just fot testing
panel = rs.AddLine(pEnd[i], pEnd[i+1])
def projectPtOnSrf(attractorPt, targetSrf, pt):
r = rs.AddLine(attractorPt, pt)
r = rs.ScaleObject(r, attractorPt, (10, 10, 10))
dom = rs.CurveDomain(r)
crv = rs.coercecurve(r)
srf = rs.coercesurface(targetSrf).ToNurbsSurface()
inv = Interval(dom[0], dom[1])
rs.DeleteObject(r)
xobj = Intersection.CurveSurface(crv, inv, srf, 0.1, 1)
return xobj[0].PointB
def createMidPointFromCurve(curve):
split_num = 2
point_list = []
domain = rs.CurveDomain(curve)
t = (domain[1] - domain[0]) / split_num
for int in range(split_num):
dt = t * int
point = rs.EvaluateCurve(curve, dt)
point_list.append(point)
# 直線の中心点を求める
line = rs.AddLine(point_list[0], point_list[1])
mid_point = rs.CurveMidPoint(line)
return mid_point
def splitlines(lines, count):
#temp list and clear input list
templines = lines
lines = []
pts = []
#make sure we have a way to break the recursion
if count == 0:
return 1
else:
for line in templines:
#get properties of the line (endpts, length, direction, domain)
stpt = rs.CurveStartPoint(line)
endpt = rs.CurveEndPoint(line)
length = rs.Distance(stpt, endpt)
dir1 = rs.VectorCreate(endpt, stpt)
crvdomain = rs.CurveDomain(line)
#parameters for midpt and pts 1/3 and 2/3 along the line
t0 = crvdomain[1] / 2.0
t1 = crvdomain[1] / 3.0
t2 = t1 * 2
midpt = rs.EvaluateCurve(line, t0)
ptatonethird = rs.EvaluateCurve(line, t1)
ptattwothird = rs.EvaluateCurve(line, t2)
midpt = rs.AddPoint(midpt)
#call get normal function
normal = getnormal(stpt, endpt)
#move midpt perpendicular to line at 1/3 the length of the line
scaled = rs.VectorScale(normal, 0.3333)
rs.MoveObject(midpt, scaled)
#create the 4 newlines and add them to the list
newline1 = rs.AddLine(stpt, ptatonethird)
newline2 = rs.AddLine(ptatonethird, midpt)
newline3 = rs.AddLine(midpt, ptattwothird)
newline4 = rs.AddLine(ptattwothird, endpt)
lines.append(newline1)
lines.append(newline2)
lines.append(newline3)
lines.append(newline4)
#create a list of objects to delete
cleanup = []
cleanup.append(line)
cleanup.append(midpt)
rs.DeleteObjects(cleanup)
#don't forget to decrement the count otherwise infinite loop
count = count - 1
return splitlines(lines, count)
