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 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 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 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 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 ellipse(self, xheight, yheight, direction):
centerPoint = rs.AddPoint(self.point)
if direction == 'right':
centerPoint = rs.MoveObject(
centerPoint,
rs.VectorScale(rs.VectorCreate([1, 0, 0], [0, 0, 0]),
xheight / 2))
if direction == 'left':
centerPoint = rs.MoveObject(
centerPoint,
rs.VectorScale(rs.VectorCreate([-1, 0, 0], [0, 0, 0]),
xheight / 2))
if direction == 'top':
centerPoint = rs.MoveObject(
centerPoint,
rs.VectorScale(rs.VectorCreate([0, 1, 0], [0, 0, 0]),
xheight / 2))
if direction == 'bottom':
centerPoint = rs.MoveObject(
centerPoint,
rs.VectorScale(rs.VectorCreate([0, -1, 0], [0, 0, 0]),
xheight / 2))
newEllipse = rs.AddCircle(centerPoint, xheight / 2)
yScaleFactor = yheight / xheight
rs.ScaleObject(newEllipse, self.point, [1, yScaleFactor, 0])
rs.DeleteObject(centerPoint)
return (newEllipse)
def transformMatrix():
obj_ids = rs.GetObjects("Select object(s) from which to create matrix", 0,
True, True)
if obj_ids is None: return
box = rs.BoundingBox(obj_ids)
if not isinstance(box, list): return
origin = rs.PointDivide(rs.PointAdd(box[0], box[6]), 2)
endpt = rs.GetPoint("To point")
newpt = [1, 1, 1]
translation1 = rs.VectorCreate(endpt, newpt)
translation2 = rs.VectorCreate(translation1, origin)
copied_obj_ids = rs.CopyObjects(obj_ids, translation2)
for obj in copied_obj_ids:
matrix = []
degrees = 90.0 # Some angle
radians = math.radians(degrees)
c = math.cos(radians)
s = math.sin(radians)
matrix.append([c, -s, 0, 0])
matrix.append([s, c, 0, 0])
matrix.append([0, 0, 1, 0])
matrix.append([0, 0, 0, 1])
pprint.pprint(matrix)
rs.ScaleObject(obj, newpt, [3, 1, -9])
plane = rs.ViewCPlane()
pprint.pprint(plane)
rs.RotateObject(obj, newpt, uniform(0, 360), plane.XAxis)
rs.RotateObject(obj, newpt, uniform(0, 360), plane.YAxis)
rs.RotateObject(obj, newpt, uniform(0, 360), plane.ZAxis)
def duplicateAndRotate():
obj_ids = rs.GetObjects("Select object(s) to duplicate and rotate", 0,
True, True)
if obj_ids is None: return
box = rs.BoundingBox(obj_ids)
if not isinstance(box, list): return
origin = rs.PointDivide(rs.PointAdd(box[0], box[6]), 2)
endpt = rs.GetPoint("To point")
ndups = rs.GetInteger("Number of duplications")
maxd = rs.GetReal("Max Distance")
translation = rs.VectorCreate(endpt, origin)
for i in range(0, ndups, 1):
xr = random() if random() < 0.5 else -1 * random()
yr = random() if random() < 0.5 else -1 * random()
zr = random() if random() < 0.5 else -1 * random()
newpt = [xr * maxd, yr * maxd, zr * maxd]
translation1 = rs.VectorCreate(endpt, newpt)
translation2 = rs.VectorCreate(translation1, origin)
copied_obj_ids = rs.CopyObjects(obj_ids, translation2)
xyp = rs.WorldXYPlane()
rs.RotateObjects(copied_obj_ids, newpt, random() * 360, xyp[0])
rs.RotateObjects(copied_obj_ids, newpt, random() * 360, xyp[1])
rs.RotateObjects(copied_obj_ids, newpt, random() * 360, xyp[2])
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 __init__(self, _startPoint):
self.location = _startPoint
self.x = random.uniform(-2,2)
self.y = random.uniform(-2,2)
self.z = random.uniform(10,20)
self.velocity = rs.VectorCreate([self.x,self.y,self.z],[0,0,0])
self.acceleration = rs.VectorCreate([0,0,0],[0,0,0])
def DropBlockToSurface():
try:
obj = rs.GetObjects('Select Objects',
rs.filter.curve | rs.filter.instance
| rs.filter.mesh | rs.filter.surface
| rs.filter.subd | rs.filter.light
| rs.filter.polysurface,
preselect=True)
srf = rs.GetObject('Select Surface')
if obj:
if srf:
rs.EnableRedraw(False)
# Check if srf is a mesh, if so convert to Nurb
isMesh = rs.IsMesh(srf)
if isMesh == True:
srf = rs.MeshToNurb(srf)
# For each object send test rays up and down in Z coord
# Move each object to the ray test that hits a srf
for i in obj:
bndBox = rs.BoundingBox(i)
pt1 = bndBox[0]
pt2 = bndBox[2]
crv = rs.AddLine(pt1, pt2)
if crv:
midcrv = rs.CurveMidPoint(crv)
rs.DeleteObject(crv)
ray_pt_up = rs.ShootRay(srf,
midcrv, (0, 0, 1),
reflections=1)
ray_pt_down = rs.ShootRay(srf,
midcrv, (0, 0, -1),
reflections=1)
if ray_pt_up:
vector = rs.VectorCreate(ray_pt_up[1], midcrv)
rs.MoveObject(i, vector)
if ray_pt_down:
vector = rs.VectorCreate(ray_pt_down[1], midcrv)
rs.MoveObject(i, vector)
# deleate any created srf
if isMesh == True:
rs.DeleteObject(srf)
rs.EnableRedraw(True)
except:
print("Failed to execute")
rs.EnableRedraw(True)
return
def tol(self):
# tolerance angle check function
vect1 = rs.VectorCreate(self.points[-2], self.points[-3])
vect2 = rs.VectorCreate(self.points[-1], self.points[-2])
norm = self.mesh.NormalAt(self.mpos)
alpha = g.Vector3d.VectorAngle(vect1, vect2)
if alpha > self.antol and rs.VectorDotProduct(
norm, g.Vector3d(0., 0., 1.)
) < 0: # if the angle between 2 moves larger than tolerance
self.state = 'off' # the waterflow is off the facade
def __init__(self):
self.location = [0, 0, 0]
self.velocity = [0, .1, .1]
self.acceleration = [0, 0, 0]
self.basePoint = [0, 0, 0]
self.vecAcceleration = rs.VectorCreate(self.acceleration,
self.basePoint)
self.vecVelocity = rs.VectorCreate(self.velocity, self.basePoint)
self.mass = 2000
self.g = 0.4
def closest_intersection(self, intersections, point):
closest_intersection = intersections[0][1]
length = rs.VectorLength(rs.VectorCreate(point, closest_intersection))
for i in range(0, len(intersections), 1):
new_length = rs.VectorLength(
rs.VectorCreate(point, intersections[i][1]))
if length > new_length:
length = new_length
closest_intersection = intersections[i][1]
return closest_intersection
def attractor(self, mag):
attrPt = rs.VectorCreate((-800,-700,0) , (0,0,0))
steer = rs.VectorCreate( (0,0,0) , (0,0,0) )
diff = rs.VectorSubtract( attrPt, self.p )
diff = rs.VectorUnitize(diff)
steer = rs.VectorAdd(steer , diff)
steer = rs.VectorScale(steer, mag)
self.a = rs.VectorAdd(self.a, steer)
def setup():
global pts
pts = []
global lns
lns = []
numAG = 36
for i in range(numAG):
p = rs.VectorCreate( rs.AddPoint( 100*math.cos(i*2*math.pi/numAG), 100*math.sin(i*2*math.pi/numAG),0) , rs.AddPoint(0,0,0) )
v = rs.VectorCreate( rs.AddPoint( -randint(2,18),-randint(18,36),randint(-2,26) ) , rs.AddPoint(0,0,0 ) )
run1 = Runner(p, v)
pts.append(run1)
def toldrop(self):
vect1 = rs.VectorCreate(self.points[-2], self.points[-3])
vect2 = rs.VectorCreate(self.points[-1], self.points[-2])
norm = self.mpos.Mesh.NormalAt(self.mpos)
alpha = g.Vector3d.VectorAngle(vect1, vect2)
if alpha > self.antol and rs.VectorDotProduct(
norm, g.Vector3d(0., 0., 1.)
) < 0: # if the angle between 2 moves larger than tolerance
self.state = 'off' # the waterflow is off the facade
alpha = g.Vector3d.VectorAngle(vect2, g.Vector3d(0., 0., -1.))
if alpha > (math.pi / 2 - self.androp) and rs.VectorDotProduct(
norm, g.Vector3d(0., 0.,
1.)) < 0: # if the geometry is too steep
self.state = 'off' # the waterflow is off the facade
def Cremona1(no, nomes, Linhas, countPF, dicPF):
ptos1 = []
dicUp = {}
for i in range(countPF):
if i == 0:
Spt = dicPF[nomes[i]].PointAt(0)
Ept = dicPF[nomes[i]].PointAt(1)
else:
if i == 1:
cond1 = rs.PointCompare(dicPF[nomes[i - 1]].PointAt(0),
dicPF[nomes[i]].PointAt(1), Tol)
cond2 = rs.PointCompare(dicPF[nomes[i - 1]].PointAt(0),
dicPF[nomes[i]].PointAt(0), Tol)
if cond1 or cond2:
pAux3 = Spt
Spt = Ept
Ept = pAux3
if rs.PointCompare(Ept, dicPF[nomes[i]].PointAt(1), Tol):
ptAux1 = dicPF[nomes[i]].PointAt(1)
ptAux2 = dicPF[nomes[i]].PointAt(0)
else:
ptAux1 = dicPF[nomes[i]].PointAt(0)
ptAux2 = dicPF[nomes[i]].PointAt(1)
Ept += (ptAux2 - ptAux1)
F1 = rs.AddLine(Ept, Spt)
#verificar o paralelismo entre F1 no PF e FG
vec1 = rs.VectorCreate(rs.CurveEndPoint(Linhas[-1]),
rs.CurveStartPoint(Linhas[-1]))
vec2 = rs.VectorCreate(Spt, Ept)
if rs.IsVectorParallelTo(vec2, vec1):
print '______Paralelismo______'
#colovcando F1 no dicionario do PF
dicUp[nomes[-1]] = rs.coerceline(F1)
#-cargas e nomenclatura
#teste de tração e compressão
sin1 = TraComp(no, F1, rs.coerceline(Linhas[-1]), nomes[-1])
#valores das cargas
carga1 = rs.CurveLength(F1) * sin1 / Escala
#teste de tensão admissivel
cor1 = teste_elemento(nomes[-1], carga1, Linhas[-1])
#nomenclatura do FG
txt1 = nomes[-1] + ' = ' + str('%.2f' % carga1)
pt1 = rs.coerceline(Linhas[-1]).PointAt(.5)
ptos1 += [pt1, txt1, cor1]
#nomenclatura do PF
pt1 = rs.coerceline(F1).PointAt(.5)
txt1 = nomes[-1]
ptos1 += [pt1, txt1, cor1]
return dicUp, ptos1
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 AngleABC(a, b, c):
"""AngleABC(a, b, c). As if A-B-C made a polyline, measures the clockwise angle
parameters:
a (pt): first pt
b (pt): elbow between A and C.
c (pt): last point
returns:
clockwise angle in degrees
"""
vec1 = rs.VectorCreate(a, b)
vec2 = rs.VectorCreate(c, b)
inner = rs.VectorAngle(vec1, vec2)
det = vec1[0]*vec2[1]-vec1[1]*vec2[0]
if det<0: return inner
else: return 360-inner
def angAttractor(attPt,testPt,baseVec,baseAng,thres,max):
compare=rs.VectorCreate(attPt,testPt)
editAng=rs.VectorAngle(baseVec,compare)
ang=baseAng+(1-setAttractor(attPt,testPt,thres,0))*(editAng-baseAng)
if ang>max:
ang=max
return ang
def goto(self, x, y, z=0):
prevPos = rs.PointCoordinates(self.point)
movement = rs.VectorCreate([x, y, z], prevPos)
rs.MoveObject(self.point, movement)
currentPos = rs.PointCoordinates(self.point)
line = self.drawLine(prevPos, currentPos)
return line
def deflect(self, deflectPoint):
"""
Takes a Point as an input.
Point creates a force field.
The turtle deflects around the point
"""
defPtPos = rs.PointCoordinates(deflectPoint)
prevPos = rs.PointCoordinates(self.point)
deflectVector1 = rs.VectorScale(rs.VectorCreate(prevPos, defPtPos),
0.33)
deflectVector2 = -deflectVector1
deflectVector90_1 = rs.VectorScale(
rs.VectorRotate(deflectVector1, 90, [0, 0, 1]), 0.33)
deflectVector90_2 = -deflectVector90_1
deflectVectorList = [
deflectVector1, deflectVector2, deflectVector90_1,
deflectVector90_2
]
forcePts = []
for i in deflectVectorList:
newPt = rs.CopyObject(deflectPoint)
rs.MoveObject(newPt, i)
forcePts.append(newPt)
gotoPt = rs.PointCoordinates(forcePts[0])
self.goto(gotoPt[0], gotoPt[1])
rs.AddArc3Pt(forcePts[0], forcePts[1], forcePts[2])
rs.AddArc3Pt(forcePts[1], forcePts[0], forcePts[3])
rs.DeleteObjects(forcePts)
def 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 vector_sum(lines, preview=False):
vector_list = []
total_time = 0
total_length = 0
last_feed = 0
for i in range(len(lines)):
point_a = lines[i][:3]
if i == len(lines) - 1: break
point_b = lines[i + 1][:3]
vector = rs.AddLine(point_a, point_b) if preview else rs.VectorCreate(
point_a, point_b)
if preview:
rs.ObjectLayer(vector, LAYER_NAME)
rs.ObjectColor(vector, color_palette["cut"])
vector_list.append(vector)
if len(lines[i]) == 4:
feed = lines[i][-1]
last_feed = feed
vector_length = rs.CurveLength(vector) if preview else rs.VectorLength(
vector)
total_length += vector_length
total_time += (vector_length) / last_feed
return vector_list, round(total_time, 2), round(total_length, 2)
def update(self):
self.vecAcceleration = rs.VectorCreate(self.acceleration,
self.basePoint)
self.vecVelocity = rs.VectorAdd(self.vecVelocity, self.vecAcceleration)
self.location = rs.PointAdd(self.location, self.vecVelocity)
self.acceleration = rs.VectorScale(self.acceleration, 0)
def ChangeLineLength(obj, fixedLengths):
rhobj = rs.coerceline(obj)
stPt = rhobj.PointAt(0)
vec = rs.VectorCreate(rhobj.PointAt(1), stPt)
vec.Unitize()
newEndPt = stPt.Add(stPt, vec*fixedLengths[0])
return rc.Geometry.Line(stPt, newEndPt)
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 __init__(self, pos=[0, 0, 0], heading=[1, 0, 0]):
self.heading = heading
self.point = rs.AddPoint(pos)
self.draw = True
pointPos = rs.PointCoordinates(self.point)
self.direction = rs.VectorCreate(heading, pointPos)
self.lines = []
