def get_dist(pt,poly):
# find closest point on axis curve
param = rs.CurveClosestPoint(axis, pt)
# get plane perpendicular to curve
ck,pl = axis.PerpendicularFrameAt(param)
# part responsible for flat end caps
# if distance from point to plane is bigger than 0,
# return that distance
pp = rs.PlaneClosestPoint(pl,pt)
d2 = rs.Distance(pt,pp)
if d2>0.01:
return d2
# else change the basis of the polygon from world xy
# to that plane to check for distance and inside/outside
pm = (param-axis.Domain[0])/(axis.Domain[1]-axis.Domain[0])
wxy = rs.WorldXYPlane()
tf = rg.Transform.PlaneToPlane(wxy,pl)
ang = sa + pm*(ea-sa)
tr = rg.Transform.Rotation(ang, pl.Normal, pl.Origin)
tpts = rs.CurvePoints(poly)
for p in tpts:
p.Transform(tf)
p.Transform(tr)
ply = rs.AddPolyline(tpts)
prm = rs.CurveClosestPoint(ply,pt)
cp = rs.EvaluateCurve(ply,prm)
d = rs.Distance(pt,cp)
# if the point is inside the curve, reverse the distance
bln = rs.PointInPlanarClosedCurve(pt,ply,pl)
if bln:
d *= -1
return d
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 squareSect(crv,width,height):
sections=[]
divPts=rs.DivideCurve(crv,10)
keep=True
for i in range(len(divPts)):
param=rs.CurveClosestPoint(crv,divPts[i])
tan=rs.CurveTangent(crv,param)
plane=rs.PlaneFromNormal(divPts[i],tan)
sect=rs.AddRectangle(plane,width,height)
cpt=rs.CurveAreaCentroid(sect)[0]
vec=rs.VectorCreate(divPts[i],cpt)
sect=rs.MoveObject(sect,vec)
if i>0:
if testAlign(sect,oldSect)==False:
sect=align(sect,oldSect,divPts[i],tan)
oldSect=sect
sections.append(sect)
branch=rs.AddLoftSrf(sections,None,None,2,0,0,False)
edges=rs.DuplicateEdgeCurves(branch)
if width>height:
testVal=height
else:
testVal=width
for i in range(len(edges)):
testPt=rs.CurveMidPoint(edges[i])
for j in range(len(edges)):
param=rs.CurveClosestPoint(edges[j],testPt)
pt=rs.EvaluateCurve(edges[j],param)
if rs.Distance(pt,testPt)<testVal/6:
keep=False
rs.DeleteObjects(sections)
rs.DeleteObjects(edges)
return branch
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 grow(self, side):
newBranches = []
if len(self.branches) == 0:
self.startBranch()
for i in range(len(self.branches)):
self.pullBranch(self.branches[i])
axis01 = self.findAxis(self.branches[i].end01)
axis02 = self.findAxis(self.branches[i].end02)
if rs.VectorAngle(self.branches[i].axis,
axis01) < 60 and side == 1:
param = rs.CurveClosestPoint(self.path, self.branches[i].end01)
dist = rs.Distance(self.branches[i].end01,
rs.EvaluateCurve(self.path, param))
tan = rs.CurveTangent(self.path, param)
newBranches.append(
branch(self.branches[i].end01, self.branches[i].vec01,
self.ang, axis01))
if rs.VectorAngle(self.branches[i].axis,
axis02) < 60 and side == 2:
param = rs.CurveClosestPoint(self.path, self.branches[i].end02)
dist = rs.Distance(self.branches[i].end02,
rs.EvaluateCurve(self.path, param))
tan = rs.CurveTangent(self.path, param)
vecAng = rs.VectorAngle(self.branches[i].vec02, tan)
vec = rs.VectorRotate(self.branches[i].vec02, -vecAng / 5,
axis02)
newBranches.append(
branch(self.branches[i].end02, self.branches[i].vec02,
self.ang, axis02))
self.branches = []
self.branches.extend(newBranches)
return self.branches
def curvy_stairs(curve, start_pt, end_pt, stair_width, steps, plinth_lst,
bannister_lst):
ref = rs.OffsetCurve(
curve, [1, 0, 0],
stair_width) # create the second curve to guide the stair
ref_pts = [n * 1 / steps for n in range(steps + 1)
] # guide points to divide up the curve
left_pts = [rs.EvaluateCurve(curve, t)
for t in ref_pts] # guide points on input curve
right_pts = [rs.EvaluateCurve(ref, t)
for t in ref_pts] #guide points on the offset curve
height = end_pt[2] - start_pt[2] #stair height
rise = [0, 0, height / steps] # a vector
for i in range(steps):
#draw rise
v_ver = [
left_pts[i], right_pts[i],
rs.PointAdd(right_pts[i], rise),
rs.PointAdd(left_pts[i], rise)
]
rs.AddSrfPt(v_ver)
#draw run
v_hori = [v_ver[3], v_ver[2], right_pts[i + 1], left_pts[i + 1]]
rs.AddSrfPt(v_hori)
#draw sides
s1 = rs.AddLine(left_pts[i], rs.PointAdd(left_pts[i], rise))
s2 = rs.AddLine(rs.PointAdd(left_pts[i], rise), left_pts[i + 1])
s3 = rs.AddSubCrv(curve, rs.CurveClosestPoint(curve, left_pts[i]),
rs.CurveClosestPoint(curve, left_pts[i + 1]))
rs.AddEdgeSrf([s1, s2, s3])
rs.DeleteObjects([s1, s2, s3])
s1 = rs.AddLine(right_pts[i], rs.PointAdd(right_pts[i], rise))
s2 = rs.AddLine(rs.PointAdd(right_pts[i], rise), right_pts[i + 1])
s3 = rs.AddSubCrv(ref, rs.CurveClosestPoint(ref, right_pts[i]),
rs.CurveClosestPoint(ref, right_pts[i + 1]))
rs.AddEdgeSrf([s1, s2, s3])
rs.DeleteObjects([s1, s2, s3])
s1 = rs.AddLine(left_pts[0], right_pts[0])
s2 = rs.AddLine(left_pts[-1], right_pts[-1])
rs.AddEdgeSrf([s1, curve, s2, ref])
rs.DeleteObjects([s1, s2])
if plinth_lst[0]:
curvy_plinth(curve, ref, stair_width, plinth_lst)
if bannister_lst[0]:
curvy_bannister(curve, ref, stair_width, bannister_lst)
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 get_inscribed_radius(curve, origin=(0,0,0)):
# find out how many segments in this curve
nsegs = rs.PolyCurveCount(curve)
# record closest distance & point
best_r = None
best_point = None
# for each curve segment
for seg in range(nsegs):
# get the curve parameter (i.e. input to spline function) that
# approaches the origin most closely for this segment.
param = rs.CurveClosestPoint(curve, origin, seg)
# evaluate the curve at that parameter to get 3D point location
point = rs.EvaluateCurve(curve, param)
# get the displacement from the origin
point = mz.vec_sub(list(point), origin)
# get length
r = mz.vec_length(point)
# update best
if best_r is None or r < best_r:
best_r = r
best_point = point
# return distance & point
return best_r, best_point
def get_dist(p, j):
param = rs.CurveClosestPoint(axis[j], p)
cp = rs.EvaluateCurve(axis[j], param)
dv = map_values(param, axis[j].Domain[0], axis[j].Domain[1], 0, 1)
r = (1 - dv) * start_radius[j] + dv * end_radius[j]
d = rs.Distance(p, cp) - r
return d
def WindowLeftDistance():
# Find midpoint of window left line
midpoint_windowLeft = rs.CurveMidPoint(window_leftLine[1])
# Find closest point in curve window left
parameterLeftLine = rs.CurveClosestPoint(window_leftLine[1],
midpoint_windowLeft)
# Find curve window left Tangent
windowLeft_Tangent = rs.CurveTangent(window_leftLine[1], parameterLeftLine)
# find window left normal plane
windowLeft_plane = rs.PlaneFromNormal(midpoint_windowLeft,
windowLeft_Tangent)
# find start and end points of ground line
points_ll = []
start_ll = bbox[0]
end_ll = bbox[3]
points_ll.append(start_ll)
points_ll.append(end_ll)
#find point on Surface Left line
point_SurfLeftLine = rs.LinePlaneIntersection(points_ll, windowLeft_plane)
#point_SurfLeftLine = rs.AddPoint(point_SurfLeftLine)
Window_leftDistance = rs.Distance(midpoint_windowLeft, point_SurfLeftLine)
return Window_leftDistance
def depressCrvs(srf, crvs, paths, startPt, radius, sd):
newCrvs = []
for i in range(len(crvs)):
divPts = rs.DivideCurve(crvs[i], 400)
for j in range(len(divPts)):
path = rs.PointClosestObject(divPts[j], paths)[0]
param = rs.CurveClosestPoint(path, divPts[j])
close = rs.EvaluateCurve(path, param)
srfParam = rs.SurfaceClosestPoint(srf, close)
vec = rs.SurfaceNormal(srf, srfParam)
dist = rs.Distance(close, divPts[j])
vec = rs.VectorUnitize(vec)
border = 1
entry = 1
if j > len(divPts) / 2:
border = rs.Distance(rs.CurveEndPoint(crvs[i]), divPts[j])
else:
border = rs.Distance(rs.CurveStartPoint(crvs[i]), divPts[j])
if border < sd * 3:
border = border / (sd * 3)
else:
border = 1
entryDist = rs.Distance(startPt, divPts[j])
if entryDist < sd * 10:
entry = entryDist / (sd * 10)
else:
entry = 1
if dist < sd * 2:
val = radius * (bellCrv(dist, sd))
divPts[j] = rs.PointAdd(divPts[j], vec * val * border * entry)
newCrvs.append(rs.AddCurve(divPts))
return divPts
def SillHeight():
# Find mid point of sill line
midpointSill = rs.CurveMidPoint(window_sillLine[1])
#midpointSill = rs.AddPoint(midpointSill)
# Find closest point in curve
parameterSill = rs.CurveClosestPoint(window_sillLine[1], midpointSill)
# Find curve Tangent
sill_Tangent = rs.CurveTangent(window_sillLine[1], parameterSill)
# find normal plane
sill_plane = rs.PlaneFromNormal(midpointSill, sill_Tangent)
# find start and end points of ground line
points_gl = []
start_gl = rs.CurveStartPoint(groundLine[1])
end_gl = rs.CurveEndPoint(groundLine[1])
points_gl.append(start_gl)
points_gl.append(end_gl)
#find point on ground line
pointGroundLine = rs.LinePlaneIntersection(points_gl, sill_plane)
#pointGroundLine = rs.AddPoint(pointGroundLine)
sill_Height = rs.Distance(midpointSill, pointGroundLine)
return sill_Height
def __init__(self, point, rotation, Course):
#self.brickWidth = brickWidth
self.brickCenter = point
self.brickRotation = rotation
self.Course = Course
# self.courseCurve = curve
self.curveParameter = rs.CurveClosestPoint(Course.getCurve(), point)
def distance(self):
Udomain = rs.SurfaceDomain(self.strsrf, 0)
Vdomain = rs.SurfaceDomain(self.strsrf, 1)
stepU = (Udomain[1] - Udomain[0]) / self.intu
stepV = (Vdomain[1] - Vdomain[0]) / self.intv
#PLOT POINTS ON SURFACE)
for i in range(self.intu + 1):
for j in range(self.intv + 1):
#define u and v in terms of step values and i and j
u = Udomain[0] + stepU * i
v = Vdomain[0] + stepV * j
point = rs.EvaluateSurface(self.strsrf, u, v)
crvParam = rs.CurveClosestPoint(self.Crv, point)
crvPoints = rs.EvaluateCurve(self.Crv, crvParam)
if rs.Distance(point, crvPoints) < 400:
self.dis[(i, j)] = rs.Distance(point, crvPoints)
else:
self.dis[(i, j)] = 1300
return self.dis
def depressCrvs(crvs, paths, startPt, radius, sd):
newCrvs = []
for i in range(len(crvs)):
divPts = rs.DivideCurve(crvs[i], 100)
if i < len(crvs) - 1:
cntPt01 = centerCrv(crvs[i])
cntPt02 = centerCrv(crvs[i + 1])
horVec = rs.VectorCreate(cntPt01, cntPt02)
for j in range(len(divPts)):
path = rs.PointClosestObject(divPts[j], paths)[0]
param = rs.CurveClosestPoint(path, divPts[j])
close = rs.EvaluateCurve(path, param)
dist = rs.Distance(close, divPts[j])
tan = rs.CurveTangent(crvs[i], param)
vec = [0, 0, -1] #rs.VectorCrossProduct(horVec,tan)
testVec = rs.VectorCreate(cntPt01, divPts[j])
if rs.VectorDotProduct(vec, testVec) < 0:
rs.VectorReverse(vec)
vec = rs.VectorUnitize(vec)
border = 1
entry = 1
if j > len(divPts) / 2:
border = rs.Distance(rs.CurveEndPoint(crvs[i]), divPts[j])
else:
border = rs.Distance(rs.CurveStartPoint(crvs[i]), divPts[j])
if border < sd * 3:
border = border / (sd * 3)
entryDist = rs.Distance(startPt, divPts[j])
if entryDist < sd * 10:
entry = entryDist / (sd * 10)
if dist < sd * 2:
val = radius * (bellCrv(dist, sd))
divPts[j] = rs.PointAdd(divPts[j], vec * val * border * entry)
newCrvs.append(rs.AddCurve(divPts))
return divPts
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 get_distance(self,x,y,z):
p = rs.CreatePoint(x,y,z)
param=rs.CurveClosestPoint(self.c, p)
cp=rs.EvaluateCurve(self.c,param)
dv = map_values(param,self.c.Domain[0],self.c.Domain[1],0,1)
r = (1-dv)*self.r1 + dv*self.r2
d = rs.Distance(p,cp) - r
return d
def EdgeVectors(srf, pts):
crvs = rs.DuplicateEdgeCurves(srf)
edgeVectors = []
for pt in pts:
closestIndex = 0
closestDist = 99999
for i, crv in enumerate(crvs):
tempPt = rs.EvaluateCurve(crv, rs.CurveClosestPoint(crv, pt))
dist = rs.Distance(pt, tempPt)
if dist < closestDist:
closestDist = dist
closestIndex = i
tempPt = rs.EvaluateCurve(crvs[closestIndex], rs.CurveClosestPoint(crvs[closestIndex], pt))
rs.AddLine(tempPt, pt)
edgeVectors.append(rs.VectorCreate(tempPt, pt))
return edgeVectors
def is_point_on_curve(curve_guid, point_xyz):
geom_key = geometric_key(point_xyz)
t = rs.CurveClosestPoint(curve_guid, point_xyz)
pt_on_crv = rs.EvaluateCurve(curve_guid, t)
geom_key_pt_on_crv = geometric_key(pt_on_crv)
if geom_key == geom_key_pt_on_crv:
return True
else:
return False
def rampIntersection(route1, route2, width):
edges = []
offSeg1 = offsetLine(route1, width / 2)
offSeg2 = offsetLine(route2, width / 2)
test1 = rs.CurveCurveIntersection(offSeg1, offSeg2)
if (test1 == None):
side1 = False
else:
side1 = True
offSeg3 = offsetLine(route1, -width / 2)
offSeg4 = offsetLine(route2, -width / 2)
rs.ObjectColor(offSeg3, [255, 0, 0])
rs.ObjectColor(offSeg4, [255, 0, 0])
test2 = rs.CurveCurveIntersection(offSeg3, offSeg4)
if (test2 == None):
side2 = False
else:
side2 = True
if (side1):
pivotPt = rs.LineLineIntersection(offSeg1, offSeg2)[0]
perpPt1 = rs.EvaluateCurve(offSeg3,
rs.CurveClosestPoint(offSeg3, pivotPt))
perpPt2 = rs.EvaluateCurve(offSeg4,
rs.CurveClosestPoint(offSeg4, pivotPt))
edges.append(rs.AddLine(pivotPt, perpPt1))
edges.append(rs.AddLine(pivotPt, perpPt2))
elbowPt = rs.LineLineIntersection(offSeg3, offSeg4)[0]
else:
pivotPt = rs.LineLineIntersection(offSeg3, offSeg4)[0]
perpPt1 = rs.EvaluateCurve(offSeg1,
rs.CurveClosestPoint(offSeg1, pivotPt))
perpPt2 = rs.EvaluateCurve(offSeg2,
rs.CurveClosestPoint(offSeg2, pivotPt))
edges.append(rs.AddLine(pivotPt, perpPt1))
edges.append(rs.AddLine(pivotPt, perpPt2))
elbowPt = rs.LineLineIntersection(offSeg1, offSeg2)[0]
rs.DeleteObject(offSeg1)
rs.DeleteObject(offSeg2)
rs.DeleteObject(offSeg3)
rs.DeleteObject(offSeg4)
landing = rs.AddPolyline([pivotPt, perpPt1, elbowPt, perpPt2, pivotPt])
return edges, landing
def tangents(self, points):
tangents = []
if rs.IsPolyCurve(self.guid):
pass
elif rs.IsCurve(self.guid):
for point in points:
param = rs.CurveClosestPoint(self.guid, point)
vector = list(rs.CurveTangent(self.guid, param))
tangents.append((point, vector))
else:
raise RhinoCurveError('object is not a curve')
return tangents
def tangents(self, points):
tangents = []
if rs.IsPolyCurve(self.guid):
pass
elif rs.IsCurve(self.guid):
for point in points:
param = rs.CurveClosestPoint(self.guid, point)
vector = list(rs.CurveTangent(self.guid, param))
tangents.append(vector)
else:
raise Exception('Object is not a curve.')
return tangents
def offset_vector(self, point, cross_section_index, point_index):
modulo = len(self.point_lists[cross_section_index])
closest_point = rs.CurveClosestPoint(
self.cross_sections[cross_section_index], point)
crv = rs.CurveCurvature(self.cross_sections[cross_section_index],
closest_point)
crvTangent = crv[1]
crvPerp = rs.VectorUnitize(crv[4])
unit_vector = rs.VectorUnitize(crvTangent)
return [
rs.VectorScale(unit_vector, 0.205),
rs.VectorReverse(rs.VectorCrossProduct(crvTangent, crvPerp))
]
def spiral_stairs(curve, center, start_pt, end_pt, stair_width, steps,
plinth_lst, bannister_lst):
height = end_pt[2] - start_pt[2]
cen = rs.AddLine(center, rs.PointAdd(center, [0, 0, height]))
cen_e = rs.CurveEndPoint(cen)
ref_pts = [n * 1 / steps for n in range(steps + 1)]
outer_pts = [rs.EvaluateCurve(curve, t) for t in ref_pts]
inner_pts = [[cen_e[0], cen_e[1], cen_e[2] * t] for t in ref_pts]
print(inner_pts)
rise = [0, 0, height / steps]
for i in range(steps):
#draw rise
v_ver = [
outer_pts[i], inner_pts[i],
rs.PointAdd(inner_pts[i], rise),
rs.PointAdd(outer_pts[i], rise)
]
rs.AddSrfPt(v_ver)
#draw run
v_hori = [v_ver[3], v_ver[2], outer_pts[i + 1]]
rs.AddSrfPt(v_hori)
#draw sides
s1 = rs.AddLine(outer_pts[i], rs.PointAdd(outer_pts[i], rise))
s2 = rs.AddLine(rs.PointAdd(outer_pts[i], rise), outer_pts[i + 1])
s3 = rs.AddSubCrv(curve, rs.CurveClosestPoint(curve, outer_pts[i]),
rs.CurveClosestPoint(curve, outer_pts[i + 1]))
rs.AddEdgeSrf([s1, s2, s3])
rs.DeleteObjects([s1, s2, s3])
if plinth_lst[0]:
curvy_plinth(curve, None, stair_width, plinth_lst)
if bannister_lst[0]:
curvy_bannister(curve, None, stair_width, bannister_lst)
def findBrickPlacements(closestBricks, index):
global BrickList
#get midpoint of bricks
midPoint = closestBricks[0].getMidpoint3D(closestBricks[1])
print closestBricks[0].getTributaryMidpoint3D(closestBricks[1])
#get closest point on line to this midpoint
closestParam = rs.CurveClosestPoint(ContourCurves[index], midPoint)
closestMidPoint = rs.EvaluateCurve(ContourCurves[index], closestParam)
#rotate brick
rotation = 0
newBrick = Brick3D(closestMidPoint, rotation, CourseList[index])
return newBrick
def multiLineCurve():
"""
--- --- --- --- --- --- --- --- --- --- ---
-------------------------------------------
--- --- --- --- --- --- --- --- --- --- ---
this script divides a curve by length and adds dashes to either side of the curve, grouped per curve / polyline
limitation: does not accomodate at corners (to avoid ccx issues)
www.studiogijs.nl
"""
curves = rs.GetObjects("select curves to change into multiline-style",4, preselect=True)
if not curves:
return
s=sc.sticky['scale'] if sc.sticky.has_key('scale') else 20
scale = rs.GetReal("scale of the multiline curve", s, 5, 100)
if not scale:
return
sc.sticky['scale']=scale
rs.EnableRedraw(False)
for curve in curves:
lines=[]
if rs.CurveLength(curve)>scale:
pts = rs.DivideCurveLength(curve, scale)
for pt in pts:
t=rs.CurveClosestPoint(curve, pt)
vec = rs.CurveTangent(curve, t)*scale/5
line = rs.AddLine(pt-vec, pt+vec)
trans = rs.VectorRotate(vec, 90, [0,0,1])
trans/=2
line_copy = rs.CopyObject(line, trans)
trans = -trans
lines.append(line_copy)
rs.MoveObject(line, trans)
lines.append(line)
group = rs.AddGroup()
rs.AddObjectsToGroup(lines, group)
rs.AddObjectsToGroup(curve, group)
rs.SelectObjects(lines)
rs.SelectObjects(curves)
rs.EnableRedraw(True)
def move_point_down(self, point, cross_section_index, point_index):
if (cross_section_index > 0):
offset_vectors = self.offset_vector(point, cross_section_index,
point_index)
normal = rs.VectorReverse(offset_vectors[0])
scaled_offset = rs.VectorScale(rs.VectorUnitize(offset_vectors[1]),
3)
new_point = rs.PointAdd(point, normal)
return [
rs.PointAdd(new_point, scaled_offset),
rs.PointAdd(new_point, rs.VectorReverse(scaled_offset))
]
else:
curve = self.cross_sections[cross_section_index]
parameter = rs.CurveClosestPoint(curve, point)
tangent = rs.CurveTangent(curve, parameter)
unit_vector = rs.VectorUnitize(tangent)
scale_vector = rs.VectorReverse(rs.VectorScale(unit_vector, 2))
return [rs.PointAdd(point, scale_vector)]
def findBrickPlacement(closestBricks, index):
global BrickList
#get midpoint of bricks
midPoint = closestBricks[0].getMidpoint3D(closestBricks[1])
#get closest point on line to this midpoint
closestParam = rs.CurveClosestPoint(ContourCurves[index], midPoint)
closestPoint = rs.EvaluateCurve(ContourCurves[index], closestParam)
closestBrickDistCurve = closestBricks[0].getDistanceOnCurve(
closestBricks[1])
#rotate brick none, for now
rotation = 0
newBrick = Brick3D(closestPoint, rotation, CourseList[index])
return newBrick
def baseBranch(mesh,start,vec,ang,length,gen):
end=rs.PointAdd(start,vec*length)
end=rs.MeshClosestPoint(mesh,end)[0]
branch1=rs.AddLine(start,end)
projBranch1=rs.PullCurveToMesh(mesh,branch1)
branches=[projBranch1]
stored=branches
newBranches=[]
i=0
count=0
while i < gen:
i=i+1
for branch in branches:
end=rs.CurveEndPoint(branch)
param=rs.CurveClosestPoint(branch,end)
vec=rs.CurveTangent(branch,param)
vec=rs.VectorUnitize(vec)
index=rs.MeshClosestPoint(mesh,end)[1]
norm=rs.MeshFaceNormals(mesh)[index]
vec=rs.VectorRotate(vec,ang,norm)
start=rs.PointAdd(end,vec*length)
start=rs.MeshClosestPoint(mesh,start)[0]
newBranch=rs.AddLine(end,start)
pulledBranch=rs.PullCurveToMesh(mesh,newBranch)
rs.DeleteObject(newBranch)
newBranches.append(pulledBranch)
vec=rs.VectorRotate(vec,-2*ang,norm)
start=rs.PointAdd(end,vec*length)
start=rs.MeshClosestPoint(mesh,start)[0]
newBranch=rs.AddLine(end,start)
pulledBranch=rs.PullCurveToMesh(mesh,newBranch)
rs.DeleteObject(newBranch)
if rs.Distance(start,rs.CurveEndPoint(pulledBranch))<length/2:
newBranches.append(pulledBranch)
branches=newBranches
stored.extend(branches)
newBranches=[]
count=count+1
#for i in range(len(stored)):
# squareSect(stored[i],1,1)
print count
return stored
