def orientObjAlongPolyPts(obj, pts, basePoint=(0, 0, 0), baseVect=(0, 1, 0)):
print('orient obj along poly points')
up = (0, 0, 1)
generatedObjects = []
for i in range(0, len(pts) - 1):
if i < (len(pts) - 2):
p0 = pts[i]
p1 = pts[i + 1]
p2 = pts[i + 2]
v1 = rs.VectorUnitize(p1 - p0)
v2 = rs.VectorUnitize(p2 - p1)
n1 = rs.VectorCrossProduct(v1, up)
n2 = rs.VectorCrossProduct(v2, up)
mid = rs.VectorAdd(n1, n2)
n = rs.VectorUnitize(mid)
else:
p0 = pts[i]
p1 = pts[i + 1]
v1 = rs.VectorUnitize(p1 - p0)
n = rs.VectorCrossProduct(v1, up)
rs.AddLine(p1, p1 + n)
a = rs.VectorAngle((0, 1, 0), n)
gen = rs.OrientObject(obj, [basePoint, basePoint + baseVect],
[p1, p1 + n], 1)
generatedObjects.append(gen)
#g=rs.AddGroup()
#groupObjects=rs.AddObjectsToGroup(generatedObjects,g)
return generatedObjects
def Moveobj(self, y_c_i):
m_p = rs.CircleCenterPoint(self.circle_obj)
y_p = rs.CircleCenterPoint(y_c_i.circle_obj)
vector_m_y = rs.VectorCreate(y_p, m_p)
vector_y_m = rs.VectorCreate(m_p, y_p)
unit_vec_m_y = rs.VectorUnitize(vector_m_y)
unit_vec_y_m = rs.VectorUnitize(vector_y_m)
radius_1 = rs.CircleRadius(self.circle_obj)
radius_2 = rs.CircleRadius(y_c_i.circle_obj)
dis_1_2 = rs.Distance(m_p, y_p)
dis = dis_1_2 - (radius_1 + radius_2)
move_dis = (dis / 2) / 10
move_vec_m_y = rs.VectorScale(unit_vec_m_y, move_dis)
move_vec_y_m = rs.VectorScale(unit_vec_y_m, move_dis)
# status = self.getStatus(y_c_i)
#
# if(status == 1):
# rs.MoveObject(self.circle_obj,move_vec_m_y)
# rs.MoveObject(y_c_i.circle_obj,move_vec_y_m)
#
# if(status == 2):
# rs.MoveObject(self.circle_obj,move_vec_y_m)
# rs.MoveObject(y_c_i.circle_obj,move_vec_m_y)
rs.MoveObject(self.circle_obj, move_vec_m_y)
rs.MoveObject(y_c_i.circle_obj, move_vec_y_m)
def offset_face(mesh, fkey, t):
cent = mesh.face_centroid(fkey)
vcords = mesh.face_coordinates(fkey, ordered=True)
vkeys = mesh.face_vertices(fkey, ordered=True)
pts = []
vecs = []
keys = [None] * len(vcords)
for i, vcor in enumerate(vcords):
vec1 = rs.VectorUnitize(rs.VectorCreate(vcords[i - 2], vcords[i - 1]))
vec2 = rs.VectorUnitize(rs.VectorCreate(vcords[i], vcords[i - 1]))
vec = rs.VectorAdd(vec1, vec2)
vec = rs.VectorUnitize(vec)
ang = rs.VectorAngle(vec, vec1)
ang = math.radians(ang)
l = t / math.sin(ang)
vec = rs.VectorScale(vec, l)
pt = rs.PointAdd(vcords[i - 1], vec)
keys[i - 1] = mesh.add_vertex(x=pt[0], y=pt[1], z=pt[2])
for i, vkey in enumerate(vkeys):
mesh.add_face([vkeys[i], keys[i], keys[i - 1], vkeys[i - 1]])
mesh.add_face(keys)
del mesh.face[fkey]
def meshSwipPolyAlongPoly(profile, rail):
profile = rs.CopyObject(profile)
pts = rs.CurveEditPoints(rail)
baseVect = Rhino.Geometry.Point3d(0, 1, 0)
meshes = []
for i in range(0, len(pts) - 2):
p0 = pts[i]
p1 = pts[i + 1]
p2 = pts[i + 2]
v1 = rs.VectorUnitize(p1 - p0)
v2 = rs.VectorUnitize(p2 - p1)
rv1 = rs.VectorUnitize(p0 - p1)
vect = p1 - p0
mid = rs.VectorUnitize((rv1 + v2) / 2)
np = p1 + mid
up = p1 + Rhino.Geometry.Point3d(0, 0, 1)
pln = rs.PlaneFromPoints(p1, np, up)
mesh, pjpts = meshExtrudePolyToByVectPlane(profile, vect, pln)
meshes.append(mesh)
rs.DeleteObject(profile)
profile = rs.AddPolyline(pjpts)
mesh = rs.JoinMeshes(meshes, True)
rs.DeleteObject(profile)
return mesh
def mergeCoincidentLines(segments):
"""
removes coincident, consecutive segments
input: List of GUIDs
returns: List of GUIDs
"""
newSegments = []
i = 0
while i < len(segments):
if (i < len(segments) - 1): #if coincident, delete both, add new.
a = rs.VectorCreate(rs.CurveStartPoint(segments[i]),
rs.CurveEndPoint(segments[i]))
b = rs.VectorCreate(rs.CurveStartPoint(segments[i + 1]),
rs.CurveEndPoint(segments[i + 1]))
a = rs.VectorUnitize(a)
b = rs.VectorUnitize(b)
aAng = rs.VectorAngle(a, b)
if (aAng < .00001):
newLine = rs.AddLine(rs.CurveStartPoint(segments[i]),
rs.CurveEndPoint(segments[i + 1]))
rs.DeleteObject(segments[i])
rs.DeleteObject(segments[i + 1])
newSegments.append(newLine)
i = i + 2
else:
newSegments.append(
segments[i]) #if not coincident, add to array
i = i + 1
else:
newSegments.append(segments[i]) #add last seg to array
i = i + 1
return newSegments
def move2PtInside(self, p0, p1, scale0=0.2, scale1=None):
if scale1 is None:
scale1 = scale0
mp = [
(p0[0] + p1[0]) / 2,
(p0[1] + p1[1]) / 2,
(p0[2] + p1[2]) / 2,
]
v0 = rs.VectorCreate(mp, p0)
v1 = rs.VectorCreate(mp, p1)
v0 = rs.VectorScale(rs.VectorUnitize(v0), scale0)
v1 = rs.VectorScale(rs.VectorUnitize(v1), scale1)
v0 = rs.PointAdd(p0, v0)
v1 = rs.PointAdd(p1, v1)
return v0, v1
#eof
#eoc
def LinearDimJoin(object_id0, object_id1):
annotation_object0 = sc.doc.Objects.Find( object_id0 )
dim0 = annotation_object0.Geometry
annotation_object1 = sc.doc.Objects.Find( object_id1 )
dim1 = annotation_object1.Geometry
if isinstance(dim0, Rhino.Geometry.LinearDimension) and isinstance(dim1, Rhino.Geometry.LinearDimension):
_, extensionLine01End, extensionLine02End, arrowhead01End, arrowhead02End, dimlinepoint0, _ = dim0.Get3dPoints()
_, extensionLine11End, extensionLine12End, arrowhead11End, arrowhead12End, dimlinepoint1, _ = dim1.Get3dPoints()
line0 = geo.Line(arrowhead01End, arrowhead02End)
direct0=rs.VectorUnitize(line0.Direction)
line1 = geo.Line(arrowhead11End, arrowhead12End)
direct1=rs.VectorUnitize(line1.Direction)
if rs.IsVectorParallelTo(direct0, direct1 ) != 0 :
param0 = line0.ClosestParameter(line1.From)
param1 = line0.ClosestParameter(line1.To)
paramDictionary = {
0.0 : extensionLine01End,
1.0 : extensionLine02End,
param0 : extensionLine11End,
param1 : extensionLine12End
}
extensionLineList = []
for key in sorted(paramDictionary.keys()):
extensionLineList.append(paramDictionary[key])
distance0 = line0.DistanceTo(extensionLineList[0],False)
distance1 = line1.DistanceTo(extensionLineList[0],False)
if distance0 > distance1:
rs.AddLinearDimension(dim0.Plane, extensionLineList[0], extensionLineList[len(extensionLineList)-1], dimlinepoint0 )
else:
rs.AddLinearDimension(dim1.Plane, extensionLineList[0], extensionLineList[len(extensionLineList)-1], dimlinepoint1 )
rs.DeleteObject(object_id0)
rs.DeleteObject(object_id1)
def accumulationCheck(self):
d12 = self.points[-1].DistanceTo(self.points[-2])
norm0 = rs.VectorUnitize(self.mesh.NormalAt(self.mpos))
# special check when the water drop stops
if d12 == 0.:
self.pop()
self.edgeCheck(norm0)
norm1 = rs.VectorUnitize(
self.mesh.NormalAt(self.mesh.ClosestMeshPoint(self.points[-2],
0.)))
# check accumulation conditions (distance, height and stepsize (in order))
if self.points[-1].Z > self.points[-2].Z or d12 < self.stepsize / 20.:
# verify which case : stuck on an edge or in a basin
if norm0.Z > 0.99 or (norm1 != norm0 and norm1.Z >= 0
and norm0.Z >= 0):
# the water drop is in a basin
self.pop()
self.state = 'finished'
criticalPoints.append(self.pos)
else:
# the water drop is on an edge
self.pop()
self.state = 'off'
edgePoints.append(self.pos)
def randomDir(self, point, plane):
# check if the drop has hit a flat srf and return a random direction if so
if point == self.pos and self.count < 3:
random = r.uniform(0., 2* math.pi)
vect = g.Vector3d(1., 0., 0.) * self.stepsize
vect.Rotate(random, plane.ZAxis)
point = self.mesh.ClosestPoint(self.pos + vect)
return point
# check if the drop is riding verticaly
if rs.VectorUnitize(plane.XAxis).Z > -.5:
return point
random = r.randint(0, 9)
# 3 choices : downward, or two side shifting
if random < 8:
return point
else:
YAxis = rs.VectorUnitize(rs.VectorUnitize(plane.YAxis))
ratio = 0.18
if random == 8:
# first direction is chosen
point = point + YAxis * self.stepsize/5.
return self.mesh.ClosestPoint(point)
if random == 9:
# first direction is chosen
point = point - YAxis * self.stepsize/5.
return self.mesh.ClosestPoint(point)
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 GetSensorPosAndNormal(centerPoint, lineVerts):
assert (len(lineVerts) == 2)
if equalWithAbsErrorVec(centerPoint, lineVerts[0]):
return centerPoint, rs.VectorUnitize(lineVerts[1] - lineVerts[0])
elif equalWithAbsErrorVec(centerPoint, lineVerts[1]):
return centerPoint, rs.VectorUnitize(lineVerts[0] - lineVerts[1])
else:
return None, None
def GetSolidAngle(a,b,c): a = rs.VectorUnitize(a) b = rs.VectorUnitize(b) c = rs.VectorUnitize(c) numer = rs.VectorDotProduct(rs.VectorCrossProduct(a,b),c) denom = 1 + rs.VectorDotProduct(a,b) + rs.VectorDotProduct(b,c) + rs.VectorDotProduct(c,a) angle = 2*math.atan2(numer, denom) return abs(angle)
def divEQCrvToPolyAD(crv,w=900,adjacentCrvs=None):
outpoly=PolyAD()
crvLen=rs.CurveLength(crv)
numDiv=crvLen/w
width=crvLen/round(numDiv)
pts=rs.DivideCurve(crv,numDiv,False,True)
#add to output
outpoly.points=pts
sharedNormals=[None,None]
if adjacentCrvs is not None:
sharedNormals=findSharedbisecNormals(crv,adjacentCrvs)
for i in range(0,len(pts)-2):
up=(0,0,1)
# direct direct_end
# (p0)-v1->(p1)-v2->(p2)
# |n_start |n |n_end
# V V V
p0=pts[i]
p1=pts[i+1]
p2=pts[i+2]
v1=rs.VectorUnitize(p1-p0)
v2=rs.VectorUnitize(p2-p1)
n1=rs.VectorCrossProduct(v1,up)
n2=rs.VectorCrossProduct(v2,up)
mid=rs.VectorAdd(n1,n2)
n=rs.VectorUnitize(mid)
direct=p1-p0
#add to output
outpoly.directions.append(direct)
if i==0:
if sharedNormals[0] is not None: n_start=sharedNormals[0]
else: n_start=rs.VectorCrossProduct(v1,up)
outpoly.normals.append(n_start)
#add to output
outpoly.normals.append(n)
if i==len(pts)-3:
if sharedNormals[1] is not None: n_end=sharedNormals[1]
else: n_end=rs.VectorCrossProduct(v2,up)
outpoly.normals.append(n_end)
direct_end=p2-p1
outpoly.directions.append(direct_end)
return outpoly
def Orthogonal(vecIn):
vecIn = rs.VectorUnitize(vecIn)
# Pick any vector which isn't aligned to the input
otherVec = rs.coerce3dvector((1.0, 0.0, 0.0))
if abs(rs.VectorDotProduct(vecIn, otherVec)) > 0.99:
otherVec = rs.coerce3dvector((0.0, 1.0, 0.0))
# Create a unit length orthogonal to both the other one, and the original one
return rs.VectorUnitize(rs.VectorCrossProduct(vecIn, otherVec))
def BasisFromDirection(direction):
b2 = rs.VectorUnitize(direction)
for b in range(3):
b0 = UnitVector(b)
# At least one unit vector must meet this condition
inner = rs.VectorDotProduct(b0, b2)
if -0.5 < inner <= 0.5:
b0 = rs.VectorUnitize(b0 - b2 * inner)
b1 = rs.VectorCrossProduct(b2, b0)
return [b0, b1, b2]
return UnitBasis()
def getDirtCoef(self):
vectDown = rs.VectorCreate(self.points[-1], self.points[-2])
if vectDown.Length == 0.: print self.count
alpha = math.acos(-rs.VectorUnitize(vectDown).Z) * 180/math.pi
norm = rs.VectorUnitize(self.mesh.NormalAt(self.mpos))
if alpha <= 90 and norm.Z > 0:
coef = 1-(1-(alpha/90)**2)**.5
return coef
if alpha <= 90 and norm.Z <= 0.:
return 0
if alpha > 90:
return 1
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 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 addExtlHandrail(self):
hdrlPtList = []
hdrlEndPt = rs.AddPoint(rs.CurveEndPoint(self.guideCrv))
hdrlStPt = rs.AddPoint(rs.CurveStartPoint(self.guideCrv))
hdrlVec = rs.VectorCreate(hdrlStPt, hdrlEndPt)
projHdrlVec = rs.VectorUnitize([hdrlVec.X, hdrlVec.Y, 0])
#Top Extension
topExtEndPt = rs.CopyObject(hdrlEndPt)
rs.MoveObject(topExtEndPt, rs.VectorScale(projHdrlVec, -.305))
hdrlPtList.append(topExtEndPt)
#Btm Extension (tread length method)
btmExtEndPt = rs.CopyObject(hdrlStPt)
btmPtExtTemp = rs.CopyObject(hdrlStPt)
btmVertPtExtTemp = rs.CopyObject(hdrlStPt)
rs.MoveObject(btmPtExtTemp, hdrlVec)
angledLineTemp = rs.AddLine(hdrlStPt, btmPtExtTemp)
rs.MoveObject(btmVertPtExtTemp, [0, 0, -1])
vertLineTemp = rs.AddLine(btmVertPtExtTemp, hdrlStPt)
rs.MoveObject(vertLineTemp,
rs.VectorScale(projHdrlVec, self.treadLength))
btmExtPt = rs.LineLineIntersection(angledLineTemp, vertLineTemp)[0]
hdrlPtList.append(hdrlEndPt)
hdrlPtList.append(btmExtPt)
#Make and move
hdrlCrv = rs.AddPolyline(hdrlPtList)
rs.MoveObject(hdrlCrv, [0, 0, self.hdrlHeight])
#move away from wall
widthVec = rs.VectorUnitize(
rs.VectorCreate(rs.CurveEndPoint(self.stairWidthEdge),
rs.CurveStartPoint(self.stairWidthEdge)))
rs.MoveObject(hdrlCrv, rs.VectorScale(widthVec, self.hdrlDistFromWall))
#cleanup
rs.DeleteObject(topExtEndPt)
rs.DeleteObject(hdrlEndPt)
rs.DeleteObject(hdrlStPt)
rs.DeleteObject(btmPtExtTemp)
rs.DeleteObject(btmVertPtExtTemp)
rs.DeleteObject(angledLineTemp)
rs.DeleteObject(vertLineTemp)
rs.DeleteObject(btmExtEndPt)
return hdrlCrv
def genIntPoly(self, poly):
cen=rs.CurveAreaCentroid(poly)[0]
pts=rs.CurvePoints(poly)
a=[(pts[0][0]+pts[1][0])/2,(pts[0][1]+pts[1][1])/2,0]
b=[(pts[0][0]+pts[3][0])/2,(pts[0][1]+pts[3][1])/2,0]
vec1=rs.VectorScale(rs.VectorUnitize(rs.VectorCreate(cen,a)),self.d0/2)
vec2=rs.VectorScale(rs.VectorUnitize(rs.VectorCreate(cen,b)),self.d1/2)
p=rs.PointAdd(cen,vec1)
q=rs.PointAdd(cen,-vec1)
r=rs.PointAdd(p,vec2)
u=rs.PointAdd(p,-vec2)
t=rs.PointAdd(q,vec2)
s=rs.PointAdd(q,-vec2)
poly=rs.AddPolyline([r,u,s,t,r])
self.req_poly.append(poly)
def blendcorners(polyline_id, radius):
# Fillets the corners of a polyline (from the McNeel website)
if not polyline_id: return
vertices = rs.PolylineVertices(polyline_id)
if not vertices: return
if radius is None: return
between = lambda a, b: (a + b) / 2.0
newverts = []
for i in range(len(vertices) - 1):
a = vertices[i]
b = vertices[i + 1]
segmentlength = rs.Distance(a, b)
vec_segment = rs.PointSubtract(b, a)
vec_segment = rs.VectorUnitize(vec_segment)
if radius < (0.5 * segmentlength):
vec_segment = rs.VectorScale(vec_segment, radius)
else:
vec_segment = rs.VectorScale(vec_segment, 0.5 * segmentlength)
w1 = rs.PointAdd(a, vec_segment)
w2 = rs.PointSubtract(b, vec_segment)
newverts.append(a)
newverts.append(between(a, w1))
newverts.append(w1)
newverts.append(between(w1, w2))
newverts.append(w2)
newverts.append(between(w2, b))
newverts.append(vertices[len(vertices) - 1])
CrvId = rs.AddCurve(newverts, 5)
rs.DeleteObject(polyline_id)
return CrvId
def CheckRunLengths(runs):
lengthComment = ''
for i, run in enumerate(runs):
dist = rs.Distance(rs.CurveStartPoint(run[0]),
rs.CurveStartPoint(run[1]))
if dist > 360:
lengthComment += 'Run {} requires a landing\n'.format(i + 1)
templine = rs.AddLine(rs.CurveStartPoint(run[0]),
rs.CurveStartPoint(run[1]))
mdPt = rs.CurveMidPoint(templine)
vec = rs.VectorCreate(mdPt, rs.CurveStartPoint(run[0]))
landingCenter = rs.CopyObject(run[0], vec)
vec = rs.VectorScale(rs.VectorUnitize(vec), 30)
upperLine = rs.CopyObject(landingCenter, vec)
vec = rs.VectorReverse(vec)
lowerLine = rs.MoveObject(landingCenter, vec)
rs.DeleteObject(templine)
run.insert(1, lowerLine)
run.insert(2, upperLine)
flatList = []
for item in runs:
for each in item:
flatList.append(each)
pairs = []
for i in range(0, len(flatList), 2):
pairs.append([flatList[i], flatList[i + 1]])
return pairs, lengthComment
def RandomPointInCone(origin, direction, minDistance, maxDistance, maxAngle):
vecTwig = rs.VectorUnitize(direction)
vecTwig = rs.VectorScale(vecTwig, minDistance + random.random()*(maxDistance-minDistance))
MutationPlane = rs.PlaneFromNormal((0,0,0), vecTwig)
vecTwig = rs.VectorRotate(vecTwig, random.random()*maxAngle, MutationPlane[1])
vecTwig = rs.VectorRotate(vecTwig, random.random()*360, direction)
return rs.PointAdd(origin, vecTwig)
def drawQuadTab(self, island):
pntA, pntD = self.get_coordinates(island)
vecA = geom.Vector3d(pntA)
vecD = geom.Vector3d(pntD)
alpha = self.tabAngles[0]
beta = self.tabAngles[1]
lenI = self.tabWidth / math.sin(alpha * math.pi / 180.0)
lenJ = self.tabWidth / math.sin(beta * math.pi / 180.0)
if not self.tabOnLeft:
alpha = -1 * alpha
beta = -1 * beta
vec = vecD.Subtract(vecD, vecA)
vecUnit = rs.VectorUnitize(vec)
vecI = rs.VectorScale(vecUnit, lenI)
vecJ = rs.VectorScale(vecUnit, -lenJ)
vecI = rs.VectorRotate(vecI, alpha, [0, 0, 1])
vecJ = rs.VectorRotate(vecJ, -beta, [0, 0, 1])
vecB = vecA + vecI
vecC = vecD + vecJ
pntB = geom.Point3d(vecB)
pntC = geom.Point3d(vecC)
points = [pntA, pntB, pntC, pntD]
polyGuid = rs.AddPolyline(points)
self.geom.append(polyGuid)
return polyGuid
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 update(self):
print('update')
#delete last generated objects
try:
rs.DeleteObjects(self.generatedObjs)
self.generatedObjs = []
except:
print('exception in delete generated object')
divWidth = 600
crv = self.baseCrv
if not rs.IsObject(crv):
print('crv is not an object')
return
if not rs.IsPolyline(crv):
pts = rs.DivideCurveEquidistant(crv, divWidth)
rail = rs.AddPolyline(pts)
else:
rail = rs.CopyObject(crv)
pts = rs.CurveEditPoints(rail)
if len(pts) < 3:
print('too little points')
return
#find vectors to move and orient the profile
vect = pts[1] - pts[0]
vect = rs.VectorUnitize(vect)
a = rs.VectorAngle(vect, (0, 1, 0)) - 90
#load the component
path = self.loadPath
component = None
try:
component = importComponent(path)
except:
print('exception on importing module')
if component is None:
print('component is None')
return None
#rs.MoveObjects(component.breps,pts[0])
#rs.RotateObjects(component.breps,pts[0],a)
for b in component.breps:
self.generatedObjs.append(b)
oriented = orientObjAlongPolyPts(b, pts)
print('pts count:', len(pts), ' num gen:', len(oriented))
rs.MoveObjects(component.polys, pts[0])
rs.RotateObjects(component.polys, pts[0], a)
for c in component.polys:
self.generatedObjs.append(c)
mesh = meshSwipPolyAlongPoly(c, rail)
self.generatedObjs.append(mesh)
rs.DeleteObject(rail)
print('generated obj count:', len(self.generatedObjs))
rs.AddGroup('gen')
rs.AddObjectsToGroup(self.generatedObjs, 'gen')
def get_edge_vectors(s_brep,length): """gets the direction vectors for extending the edges of the one-surface brep""" edges = s_brep.Edges normal = s_brep.Faces[0].NormalAt(0.5,0.5) midpoints = [] for edge in edges: mp = edge.Domain.Mid midpoints.append(edge.PointAt(mp)) edge_vectors = [] for i, edge in enumerate(edges): #get directions to test moving midpoint start = edge.StartVertex.Location end = edge.EndVertex.Location v = rs.VectorCreate(end,start) xprod1 = Rhino.Geometry.Vector3d.CrossProduct(normal,v) xprod1 = rs.VectorUnitize(xprod1) xprod2 = rs.VectorReverse(xprod1) p1 = edge.PointAt(edge.Domain.Mid) + xprod1 p2 = edge.PointAt(edge.Domain.Mid) + xprod2 print "p1", p1 print "p2", p2 dist1 = distance_to_brep(s_brep,p1) dist2 = distance_to_brep(s_brep,p2) print "dist1", dist1 print "dist2", dist2 if dist1 > dist2: edge_vectors.append(rs.VectorScale(xprod1,length)) else: edge_vectors.append(rs.VectorScale(xprod2,length)) return edge_vectors
def blendcorners():
polyline_id = rs.GetObject("Polyline to blend", 4, True, True)
if not polyline_id: return
vertices = rs.PolylineVertices(polyline_id)
if not vertices: return
radius = rs.GetReal("Blend radius", 1.0, 0.0)
if radius is None: return
between = lambda a, b: (a + b) / 2.0
newverts = []
for i in range(len(vertices) - 1):
a = vertices[i]
b = vertices[i + 1]
segmentlength = rs.Distance(a, b)
vec_segment = rs.PointSubtract(b, a)
vec_segment = rs.VectorUnitize(vec_segment)
if radius < (0.5 * segmentlength):
vec_segment = rs.VectorScale(vec_segment, radius)
else:
vec_segment = rs.VectorScale(vec_segment, 0.5 * segmentlength)
w1 = rs.PointAdd(a, vec_segment)
w2 = rs.PointSubtract(b, vec_segment)
newverts.append(a)
newverts.append(between(a, w1))
newverts.append(w1)
newverts.append(between(w1, w2))
newverts.append(w2)
newverts.append(between(w2, b))
newverts.append(vertices[len(vertices) - 1])
rs.AddCurve(newverts, 5)
rs.DeleteObject(polyline_id)
def MirrorX(lineIn, pIn):
pLine0 = lineIn[0]
pLine1 = lineIn[1]
normal = rs.VectorUnitize(
rs.VectorCrossProduct([0, 0, 1], rs.VectorSubtract(pLine1, pLine0)))
matrix = rs.XformMirror(pLine1, normal)
return rs.PointTransform(pIn, matrix)
def vecRotate(vec, ang, axis):
cos = m.cos(m.pi / 180 * ang)
sin = m.sin(m.pi / 180 * ang)
v = vec
u = rs.VectorUnitize(axis)
#u = [axis[0]/np.linalg.norm(axis),axis[1]/np.linalg.norm(axis),axis[2]/np.linalg.norm(axis)]
R1, R2, R3 = [], [], []
c = 1 - cos
R1.append(cos + m.pow(u[0], 2) * c)
R1.append(u[0] * u[1] * c - u[2] * sin)
R1.append(u[0] * u[2] * c + u[1] * sin)
R2.append(u[1] * u[0] * c + u[2] * sin)
R2.append(cos + m.pow(u[1], 2) * c)
R2.append(u[1] * u[2] * c - u[0] * sin)
R3.append(u[2] * u[0] * c - u[1] * sin)
R3.append(u[2] * u[1] * c + u[0] * sin)
R3.append(cos + m.pow(u[2], 2) * c)
x = v[0] * R1[0] + v[1] * R1[1] + v[2] * R1[2]
y = v[0] * R2[0] + v[1] * R2[1] + v[2] * R2[2]
z = v[0] * R3[0] + v[1] * R3[1] + v[2] * R3[2]
return [x, y, z]
