def create_pipe(self, point_n, point_p):
outer_point_n = self.create_scaled_point(point_n, self.PIPE_SCALAR)
outer_point_p = self.create_scaled_point(point_p, self.PIPE_SCALAR)
inner_point_n = self.create_scaled_point(point_n,
self.INNER_PIPE_SCALAR)
inner_point_p = self.create_scaled_point(point_p,
self.INNER_PIPE_SCALAR)
opl = rs.AddPolyline([outer_point_p, self.middle_point, outer_point_n])
ipl = rs.AddPolyline([inner_point_p, self.middle_point, inner_point_n])
o_pipe = rs.AddPipe(opl, 0, self.CIRCLE_WIDTH, 1, 1)
i_pipe = rs.AddPipe(ipl, 0, self.CIRCLE_INNER_WIDTH, 1, 1)
return rs.BooleanUnion([o_pipe, i_pipe])
def modify_input(filename):
# Import object from file
join_string = str(input_directory + filename)
combined_string = '!_Import ' + '"' + join_string + '"'
rs.Command(combined_string)
# Get all objects imported
objs = rs.LastCreatedObjects(select=False)[0]
# Close curve
closed_curve = rs.CloseCurve(objs, 0.5)
rs.DeleteObject(objs)
# Rebuild curve to create smoother shape
rs.RebuildCurve(closed_curve, 3, 100)
# Pipe figure with radius of 0.25
piped = rs.AddPipe(closed_curve, 0, 0.4)[0]
rs.MoveObject(piped, [0, 0, 0])
bounding_pts = rs.BoundingBox([piped], view_or_plane=rs.WorldXYPlane())
maxX = 0
minX = 0
minY = 0
minZ = 0
for pt in bounding_pts:
if pt[0] < minX:
minX = pt[0]
if pt[0] > maxX:
maxX = pt[0]
if pt[1] < minY:
minY = pt[1]
if pt[2] < minZ:
minZ = pt[2]
rect = rs.AddRectangle(rs.WorldXYPlane(), abs(maxX - minX), 3.0)
# Move rect up 1/2 of diameter of circle used to pipe
# Potentially use solid but smaller in height rect
# Select function in rhino module could allow us to select objects so that the export works.
rs.MoveObject(rect, [minX, minY - 3.0, minZ + 0.4])
piped_rect = rs.AddPipe(rect, 0, 0.4)
rs.DeleteObject(closed_curve)
rs.DeleteObject(rect)
rs.SelectObjects([piped, piped_rect])
rs.Command("_-Export " + output_directory + filename + '.stl' +
" _Enter _Tolerance=.001 _Enter")
def renderhistory(self):
"""
draws a curve through all the positions
in my history list
"""
proj_points_new = []
circle1 = []
#ADD CURVE
for i in range(len(self.proj_points)):
if i % 10 == 0:
if self.proj_points[i] is not None:
proj_points_new.append(self.proj_points[i])
try:
self.crv1 = rs.AddCurve(proj_points_new, 3)
except:
pass
#ADD SWEEP GEOMETRY
#print (len(self.z_distances))
#self.crv1_start = rs.CurveStartPoint(self.crv1)
#divide_crv = rs.DivideCurve(self.crv1, (len(self.z_distances))
#print divide_crv
#proj_pipe = rs.AddPipe(self.crv1,(len(self.z_distances)),self.z_distances, cap=2)
#crv1_lenght = rs.CurveLength(self.crv1)
#print crv1_lenght
try:
proj_pipe = rs.AddPipe(self.crv1, 0, .25, cap=2)
except:
pass
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 right():
r_curve = rs.CopyObject(curve, [0, 0, b_lst[1]])
rs.AddPipe(r_curve, 0, b_lst[2], cap=1)
rs.DeleteObjects(r_curve)
pts = [rs.EvaluateCurve(curve, t) for t in ref_pts]
for i in range(b_lst[3]):
base = rs.PointAdd(pts[i], [0, 0, b_lst[1]])
rs.AddCylinder(pts[i], base, b_lst[4])
def modify_input(filename):
# Import object from file
join_string = str(input_directory + filename)
combined_string = '!_Import ' + '"' + join_string + '"'
rs.Command(combined_string)
# Get all objects imported
objs = rs.LastCreatedObjects(select=False)[0]
# Close curve
closed_curve = rs.CloseCurve(objs, 0.5)
rs.DeleteObject(objs)
# Rebuild curve to create smoother shape
rs.RebuildCurve(closed_curve, 3, 100)
# Pipe figure with radius of 0.25
piped = rs.AddPipe(closed_curve, 0, 0.4)[0]
rs.MoveObject(piped, [0, 0, 0])
bounding_pts = rs.BoundingBox([piped], view_or_plane=rs.WorldXYPlane())
maxX = 0
minX = 0
minY = 0
minZ = 0
for pt in bounding_pts:
if pt[0] < minX:
minX = pt[0]
if pt[0] > maxX:
maxX = pt[0]
if pt[1] < minY:
minY = pt[1]
if pt[2] < minZ:
minZ = pt[2]
rect = rs.AddRectangle(rs.WorldXYPlane(), abs(maxX - minX), 3.0)
rs.MoveObject(rect, [minX, minY - 3.0, minZ])
rs.AddPipe(rect, 0, 0.4)
rs.DeleteObject(closed_curve)
rs.DeleteObject(rect)
export_string = '!_Export ' + '"' + str(output_directory + filename) + '"'
rs.Command(export_string)
def g():
"""
receives:
theta = degree of line ( 0 < theta < 45 )
num = number of pattern ( 0 < num < 15 )
works:
draw wire
returns:
None
"""
r = 10
sp = rs.AddSphere((0, 0, 0), r)
box = []
for x in rs.frange(-r, r, 0.1):
for y in rs.frange(-r, r, 0.1):
if r**2 > x**2 + y**2:
z = ma.sqrt(abs(r**2 - x**2 - y**2))
box.append((x, y, z))
for y in rs.frange(-r, r, 0.1):
if r**2 > x**2 + y**2:
z = ma.sqrt(abs(r**2 - x**2 - y**2))
box.append((x, -y, -z))
ll = len(box)
rbox = []
for i in range(0, ll):
r = rd.random()
if r < 0.01:
rbox.append(box[i])
box2 = []
box2.append(rd.sample(box, 300))
box3 = []
"""
for i in range(0,100):
if i == 0:
dis=[]
dis2=[]
for k in range(1,100):
x = box2[0][0][0]
y = box2[0][0][1]
z = box2[0][0][2]
xx = box2[0][k][0]
yy = box2[0][k][1]
zz = box2[0][k][2]
d = (x-xx)**2 + (y-yy)*2 + (z-zz)**2
dis.append(d)
dis2.append(d)
box2.remove(box2[0][0])
dis.sort()
n = dis2.index(dis[-1])
k = box2[n]
box2.remove(k)
"""
curve = rs.AddCurve(rbox, 2)
rs.AddPipe(curve, 0, 0.05, True)
def drawpipes(self):
#do not try to make a curve if the list only contains one point
if self.trailID != "imnotacurveyet!":
#delete variable
rs.DeleteObject(self.trailID)
rs.DeleteObject(self.pipes)
self.trailID = rs.AddCurve(self.trailEndPts, 3)
#self.pipes = rs.AddPipe(self.trailID,0,(0.3+2*rnd.random()))
#for pipe in self.trailID:
r = 0.1 + 1 * rnd.random() # pipe radio
R = r * 150
self.pipes = rs.AddPipe(self.trailID, 0, r)
#rs.HideObjects(curves)
rs.ObjectColor(self.pipes, (R % 255, (R + 150) % 255, (R + 75) % 255))
def drawTime():
FPS = 30
last_time = time.time()
global t
t = 0
curves = []
# whatever the loop is...
while True:
# draw animation
t += 1
# pause so that the animation runs at 30 fps
new_time = time.time()
# see how many milliseconds we have to sleep for
# then divide by 1000.0 since time.sleep() uses seconds
sleep_time = ((1000.0 / FPS) - (new_time - last_time)) / 1000.0
if sleep_time > 0:
time.sleep(sleep_time)
last_time = new_time
run()
print t
if t > 108:
for k in pts:
curves.append(rs.AddCurve(k.ptList))
rs.EnableRedraw(False)
for crv in curves:
rs.AddPipe(crv, [0,0.5,1], [4,1,4], cap=2)
for ln in lns:
rs.AddPipe(ln, 0, 1, cap=2)
rs.EnableRedraw(True)
break
escape_test()
def output_frame (filename):
join_string = str(input_directory + filename)
combined_string = '!_Import ' + '"' + join_string + '"'
rs.Command(combined_string)
# Get all objects imported
objs = rs.LastCreatedObjects(select=False)[0]
# Close curve
closed_curve = rs.CloseCurve(objs, 0.5)
rs.DeleteObject(objs)
# Rebuild curve to create smoother shape
rs.RebuildCurve(closed_curve, 3, 100)
# Pipe figure with radius of 0.25
piped = rs.AddPipe(closed_curve,0,pipe_diameter)[0]
rs.MoveObject(piped, [0,0,0])
bounding_pts = rs.BoundingBox([piped], view_or_plane=rs.WorldXYPlane())
maxX = 0
minX = 0
minY = 0
minZ = 0
for pt in bounding_pts:
if pt[0] < minX:
minX = pt[0]
if pt[0] > maxX:
maxX = pt[0]
if pt[1] < minY:
minY = pt[1]
if pt[2] < minZ:
minZ = pt[2]
epsilon = 0.5
center = 0
one = [center - (box_width / 2),minY-epsilon,-1 * pipe_diameter]
two = [center - (box_width / 2),minY-epsilon,pipe_diameter]
three = [center + (box_width / 2),minY-epsilon,pipe_diameter]
four = [center + (box_width / 2),minY-epsilon,-1 * pipe_diameter]
five = [center - (box_width / 2),minY+epsilon,-1 * pipe_diameter]
six = [center - (box_width / 2),minY+epsilon,pipe_diameter]
seven = [center + (box_width / 2),minY+epsilon,pipe_diameter]
eight = [center + (box_width / 2),minY+epsilon,-1 * pipe_diameter]
bowx = rs.AddBox([two, three, four, one, six, seven, eight, five])
def draw_graph(vertices, edges, loop_size=1.0, spindle_size=1.0, node_radius=0.0, line_radius=0.0, key_to_colour={}):
"""Draw a graph in Rhino as grouped points and lines with optional element size and node colouring.
Loops for edges (u, u) and parallel edges for multiple edges (u, v) and/or (v, u) are allowed.
Parameters
----------
vertices : dict
A dictionary of vertex keys pointing to point coordinates.
edges : list
A list of tuples of pairs of vertex indices.
loop_size : float, optional
Rough size of the loops due to edges (u, u).
Default value is 1.0.
spindle_size : float, optional
Rough size of the spindles due to mutiple edges (u, v) and/or (v, u).
Default value is 1.0.
node_radius : float, optional
Node radius representing the vertices. If equal to 0.0, a point is added, else a sphere.
Default value is 1.0.
line_radius : float, optional
Line radius representing the edges. If equal to 0.0, a line is added, else a pipe.
Default value is 1.0.
key_to_colour : dict, optional
An optional dictonary with vertex keys pointing to RGB colours.
Returns
-------
group : Rhino group
A Rhino group with the list of points or sphere surfaces of the vertices, and the list of the list of curves or pipe surfaces of the edges.
"""
# nodes as points or spheres with optional colours
nodes = []
for key, xyz in vertices.items():
nodes.append(rs.AddPoint(xyz) if node_radius == 0.0 else rs.AddSphere(xyz, node_radius))
if key in key_to_colour:
rs.ObjectColor(nodes[-1], key_to_colour[key])
# curves
curves = []
while len(edges) > 0:
crvs = []
u0, v0 = edges.pop()
# count occurences in case of multiple parallel edges
n = 1
for u, v in edges:
if (u == u0 and v == v0) or (u == v0 and v == u0):
edges.remove((u, v))
n += 1
# if not loop edge
if u0 != v0:
start = vertices[u0]
end = vertices[v0]
# rough spindle of parallel edges based on third offset point
mid = midpoint_line([start, end])
direction = cross_vectors(normalize_vector(subtract_vectors(end, start)), [0.0, 0.0, 1.0])
for i in range(n):
k = (float(i) / float(n) * spindle_size) - spindle_size / 2.0 * (float(n) - 1.0) / float(n)
dir_mid = add_vectors(mid, scale_vector(direction, k))
crvs.append(rs.AddInterpCurve([start, dir_mid, end], degree=3))
# if loop edge
else:
xyz0 = vertices[u0]
x0, y0, z0 = xyz0
# rough loop based on three additional points
xyz1 = [x0 + loop_size / 2.0, y0 - loop_size / 2.0, z0]
xyz2 = [x0 + loop_size, y0, z0]
xyz3 = [x0 + loop_size / 2.0, y0 + loop_size / 2.0, z0]
crvs += [rs.AddInterpCurve([xyz0, xyz1, xyz2, xyz3, xyz0], degree=3) for i in range(n)]
# spread if multiple loops
for i, crv in enumerate(crvs):
rs.RotateObject(crv, [x0, y0, z0], 360 * float(i) / float(n))
# pipe if non-null radius is specified
if line_radius != 0.0:
pipes = [rs.AddPipe(crv, 0, line_radius) for crv in crvs]
rs.DeleteObjects(crvs)
crvs = pipes
curves += crvs
# output group
group = rs.AddGroup()
rs.AddObjectsToGroup(nodes + curves, group)
return group
1] != 0.0 and final_arr[bone][frame][
2] != 0.0: # do not consider values at origin
if final_arr[bone][frame][
2] != 0.0: # do not consider values with z = 0
if lastFrame == 0 or rs.Distance(
final_arr[bone][frame],
final_arr[bone][lastFrame]) > threshold:
if pipe_bool == 'p':
rs.AddPoint(final_arr[bone][frame])
else:
linePoints.append(final_arr[bone][frame])
lastFrame = frame
if pipe_bool != 'p':
curveids[bone] = rs.AddCurve(linePoints)
if pipe_bool == 's':
rs.AddPipe(curveids[bone], 0, pipe_size)
else:
linePoints = []
lastFrame = 0
for frame in range(0, row_count): # for each frame of this bone
if final_arr[b][frame][0] != 0.0 and final_arr[b][frame][
1] != 0.0 and final_arr[b][frame][
2] != 0.0: # do not consider values at origin
if final_arr[b][frame][
2] != 0.0: # do not consider values with z = 0
if lastFrame == 0 or rs.Distance(
final_arr[b][frame],
final_arr[b][lastFrame]) > threshold:
if pipe_bool == 'p':
rs.AddPoint(final_arr[b][frame])
def handrailGen(self, sender, e):
flip = self.flipC.Checked
hType = self.handrailTypeC.SelectedIndex
handrailOffset = int(self.handrailOffsetC.Value) * scale
tread = int(self.treadC.Value) * scale
riser = int(self.riserC.Value) * scale
numSteps = int(self.numStepsC.Value)
hEndLength = int(self.handrailExtensionC.Value) * scale
pipeDiameter = int(self.handrailDiameterC.Value) * scale
hHeight = int(self.handrailHeightC.Value) * scale
topLine = rs.AddLine(line[0], line[1])
rs.ObjectName(topLine, "BC6#DT5LCQX*#8r97Tquf5gNF")
topPoint = line[0]
genHandrail = self.genHandrailBool.Checked
rs.EnableRedraw(False)
if genHandrail == False:
iteration = rs.ObjectsByName(
"qe7g&G5LzXEvbudtPT8xCxQbisusFVqCPqMsiHK2jc")
if iteration:
rs.DeleteObjects(iteration)
rs.EnableRedraw(True)
if genHandrail == True:
# Delete any existing iteration
iteration = rs.ObjectsByName(
"qe7g&G5LzXEvbudtPT8xCxQbisusFVqCPqMsiHK2jc")
if iteration:
rs.DeleteObjects(iteration)
# get perp line - length of stair
t = rs.CurveClosestPoint(topLine, topPoint)
planeNormal = rs.CurveNormal(topLine)
tangent = rs.CurveTangent(topLine, t)
if flip == False:
curveNormal = rs.VectorCrossProduct(planeNormal, tangent)
else:
curveNormal = rs.VectorReverse(
rs.VectorCrossProduct(planeNormal, tangent))
# Get guide curve
scaledV = rs.VectorReverse(
rs.VectorScale(curveNormal, tread*numSteps))
ptGuide1 = rs.AddPoint(line[0])
ptGuide2 = rs.CopyObject(ptGuide1, scaledV)
rs.MoveObjects([ptGuide1, ptGuide2], [
0, 0, (riser*numSteps)*-1])
curve = rs.AddCurve([ptGuide1, ptGuide2])
# Get vector for step run
vectorRun = rs.VectorCreate(
topPoint, topPoint + curveNormal * tread)
# Setup curves for handrail
curve1 = curve
curve2 = rs.MoveObject(rs.CopyObject(curve1, rs.VectorCreate(line[1],
rs.CurveStartPoint(curve1))), [0, 0, (riser * numSteps)*-1])
midPoint = rs.CurveMidPoint(userCurve)
# Main slanted handrail curve
pt1 = rs.MoveObject(rs.MoveObject(rs.CurveStartPoint(curve1), vectorRun), [
0, 0, hHeight + (riser*numSteps)])
pt2 = rs.MoveObject(rs.MoveObject(
rs.CurveEndPoint(curve1), vectorRun), [0, 0, hHeight])
mainCurve = rs.AddCurve([pt1, pt2])
# Top leveled handrail curve at 300mm standard DDA
pt3 = rs.CopyObject(pt1, rs.VectorReverse(
rs.VectorScale(rs.VectorUnitize(vectorRun), hEndLength)))
topCurve = rs.AddCurve([pt1, pt3])
# Bottom leveled handrail curve at 300mm standard DDA
pt4 = rs.CopyObject(pt2, rs.VectorScale(
rs.VectorUnitize(vectorRun), hEndLength))
bottomCurve = rs.AddCurve([pt2, pt4])
# Start list of construction geometry for later cleanup
hGeoList = [curve1, curve2, pt1, pt2, mainCurve, pt3, topCurve,
pt4, bottomCurve, ptGuide1, ptGuide2, curve, topLine]
# IF STATEMENTS FOR HANDRAIL TYPE
# 1 180 degree, no return
if hType == 0:
# Lower Handrail return
hpt1 = rs.CopyObject(pt4, [0, 0, (pipeDiameter * 2) * -1])
hpt2 = rs.MoveObject(rs.CopyObject(
pt4, [0, 0, pipeDiameter * -1]), rs.VectorScale(rs.VectorUnitize(vectorRun), pipeDiameter))
lowerH = rs.AddArc3Pt(pt4, hpt1, hpt2)
# Upper Handrail return
hpt3 = rs.CopyObject(pt3, [0, 0, (pipeDiameter * 2) * -1])
hpt4 = rs.MoveObject(rs.CopyObject(pt3, [0, 0, pipeDiameter * -1]), rs.VectorReverse(
rs.VectorScale(rs.VectorUnitize(vectorRun), pipeDiameter)))
upperH = rs.AddArc3Pt(pt3, hpt3, hpt4)
# Draw leg upper
lpt1 = rs.CurveMidPoint(topCurve)
lpt2 = rs.CopyObject(lpt1, [0, 0, hHeight*-1])
lCurveUpper = rs.AddCurve([lpt1, lpt2])
# Draw leg lower
lpt3 = rs.CopyObject(pt2, [0, 0, hHeight*-1])
lCurveLower = rs.AddCurve([pt2, lpt3])
# Make vectors to move handrails into place
moveShort = rs.VectorScale(userVector, handrailOffset)
moveLong = rs.VectorScale(
userVector, rs.CurveLength(userCurve) - (handrailOffset*2))
# Join, offset skeleton
hCurve = rs.JoinCurves(
[mainCurve, topCurve, bottomCurve, lowerH, upperH])
hCurve1 = rs.CopyObject(hCurve, moveShort)
lCurveUpper1 = rs.CopyObject(lCurveUpper, moveShort)
lCurveLower1 = rs.CopyObject(lCurveLower, moveShort)
# Pipe skeleton
pipe1 = rs.AddPipe(
hCurve1, 0, pipeDiameter/2, blend_type=0, cap=1)
pipe2 = rs.AddPipe(
lCurveUpper1, 0, pipeDiameter/2, blend_type=0, cap=1)
pipe3 = rs.AddPipe(
lCurveLower1, 0, pipeDiameter/2, blend_type=0, cap=1)
# form list of generated geo
handrailGeo1 = [pipe1, pipe2, pipe3]
# Name geo for deletion
for i in handrailGeo1:
rs.ObjectName(
i, "qe7g&G5LzXEvbudtPT8xCxQbisusFVqCPqMsiHK2jc")
# copy
handrailGeo2 = rs.CopyObjects(handrailGeo1, moveLong)
# Cleanup construction linework
hGeoList.extend([hpt1, hpt2, lowerH, hpt3, hpt4, upperH, lpt2, lpt3, lCurveLower, hCurve, hCurve1,
lCurveUpper1, lCurveLower1, lCurveUpper])
rs.DeleteObjects(hGeoList)
rs.EnableRedraw(True)
# 2 180 degree, full return
if hType == 1:
rs.EnableRedraw(False)
# Lower handrail return
hpt1 = rs.CopyObject(pt4, [0, 0, (hEndLength/3)*-2])
hpt2 = rs.CopyObject(pt2, [0, 0, (hEndLength/3)*-2])
hCurve11 = rs.AddPolyline([pt4, hpt1, hpt2])
lowerH = rs.JoinCurves([bottomCurve, hCurve11])
# Upper handrail return
hpt3 = rs.CopyObject(pt3, [0, 0, (hEndLength/3)*-2])
hpt4 = rs.CopyObject(rs.CurveMidPoint(
topCurve), [0, 0, (hEndLength/3)*-2])
hCurve2 = rs.AddPolyline([pt3, hpt3, hpt4])
upperH = rs.JoinCurves([topCurve, hCurve2])
# Draw leg upper
lpt1 = rs.CurveMidPoint(topCurve)
lpt2 = rs.CopyObject(lpt1, [0, 0, hHeight*-1])
lCurveUpper = rs.AddCurve([lpt1, lpt2])
# Draw leg lower
lpt3 = rs.CopyObject(pt2, [0, 0, hHeight*-1])
lCurveLower = rs.AddCurve([pt2, lpt3])
# Make vectors to move handrails into place
moveShort = rs.VectorScale(userVector, handrailOffset)
moveLong = rs.VectorScale(
userVector, rs.CurveLength(userCurve) - (handrailOffset*2))
# Pipe skeleton move
hCurve1 = rs.JoinCurves([lowerH, upperH, mainCurve])
rs.MoveObjects(
[hCurve1, lCurveUpper, lCurveLower], moveShort)
# Pipe
pipe1 = rs.AddPipe(
hCurve1, 0, pipeDiameter/2, blend_type=0, cap=1)
pipe2 = rs.AddPipe(
lCurveUpper, 0, pipeDiameter/2, blend_type=0, cap=1)
pipe3 = rs.AddPipe(
lCurveLower, 0, pipeDiameter/2, blend_type=0, cap=1)
handrailGeo1 = [pipe1, pipe2, pipe3]
# Name geo for deletion
for i in handrailGeo1:
rs.ObjectName(
i, "qe7g&G5LzXEvbudtPT8xCxQbisusFVqCPqMsiHK2jc")
# Move and copy into position
handrailGeo2 = rs.CopyObjects(handrailGeo1, moveLong)
# Cleanup
hGeoList.extend([hpt1, hpt2, hCurve11, lowerH, hpt3, hpt4, hCurve2, upperH, lpt2, lCurveUpper, lpt3,
lCurveLower, hCurve1])
rs.DeleteObjects(hGeoList)
rs.EnableRedraw(True)
# 3 Ground triangle return
if hType == 2:
rs.EnableRedraw(False)
# Draw leg upper
lpt1 = rs.CurveMidPoint(topCurve)
lpt2 = rs.CopyObject(lpt1, [0, 0, hHeight*-1])
lCurveUpper = rs.AddCurve([lpt1, lpt2])
# Draw leg lower
lpt3 = rs.CopyObject(pt2, [0, 0, hHeight*-1])
lCurveLower = rs.AddCurve([pt2, lpt3])
# Lower Return
lowerH = rs.AddCurve([pt4, lpt3])
# Upper Return
upperH = rs.AddCurve([pt3, lpt2])
# Make vectors to move handrails into place
moveShort = rs.VectorScale(userVector, handrailOffset)
moveLong = rs.VectorScale(
userVector, rs.CurveLength(userCurve) - (handrailOffset*2))
# Join Curves and move
hCurve = rs.JoinCurves(
[mainCurve, topCurve, bottomCurve, lowerH, upperH])
rs.MoveObjects(
[hCurve, lCurveUpper, lCurveLower], moveShort)
# pipe
pipe1 = rs.AddPipe(hCurve, 0, pipeDiameter /
2, blend_type=0, cap=1)
pipe2 = rs.AddPipe(
lCurveUpper, 0, pipeDiameter/2, blend_type=0, cap=1)
pipe3 = rs.AddPipe(
lCurveLower, 0, pipeDiameter/2, blend_type=0, cap=1)
handrailGeo1 = [pipe1, pipe2, pipe3]
# Name geo for deletion
for i in handrailGeo1:
rs.ObjectName(
i, "qe7g&G5LzXEvbudtPT8xCxQbisusFVqCPqMsiHK2jc")
# move and copy into place
handrailGeo2 = rs.CopyObjects(handrailGeo1, moveLong)
# Cleanup
hGeoList.extend(
[lpt2, lCurveUpper, lpt3, lCurveLower, lowerH, upperH, hCurve, topLine])
rs.DeleteObjects(hGeoList)
rs.EnableRedraw(True)
# 4 Ground return
if hType == 3:
rs.EnableRedraw(False)
# Draw leg upper
lpt1 = rs.CurveMidPoint(topCurve)
lpt2 = rs.CopyObject(lpt1, [0, 0, hHeight*-1])
lCurveUpper = rs.AddCurve([lpt1, lpt2])
# Draw leg lower
lpt3 = rs.CopyObject(pt2, [0, 0, hHeight*-1])
lCurveLower = rs.AddCurve([pt2, lpt3])
# Lower Return
hpt1 = rs.CopyObject(pt4, [0, 0, hHeight*-1])
hCurve1 = rs.AddCurve([pt4, hpt1])
# Upper Return
hpt2 = rs.CopyObject(pt3, [0, 0, hHeight*-1])
hCurve2 = rs.AddCurve([pt3, hpt2])
# Join curves
hCurve = rs.JoinCurves(
[mainCurve, topCurve, bottomCurve, hCurve1, hCurve2])
# Get Vectors
moveShort = rs.VectorScale(userVector, handrailOffset)
moveLong = rs.VectorScale(
userVector, rs.CurveLength(userCurve) - (handrailOffset*2))
# move
rs.MoveObjects(
[hCurve, lCurveUpper, lCurveLower], moveShort)
# Pipe
pipe1 = rs.AddPipe(hCurve, 0, pipeDiameter /
2, blend_type=0, cap=1)
pipe2 = rs.AddPipe(
lCurveUpper, 0, pipeDiameter/2, blend_type=0, cap=1)
pipe3 = rs.AddPipe(
lCurveLower, 0, pipeDiameter/2, blend_type=0, cap=1)
handrailGeo1 = [pipe1, pipe2, pipe3]
# Name geo for deletion
for i in handrailGeo1:
rs.ObjectName(
i, "qe7g&G5LzXEvbudtPT8xCxQbisusFVqCPqMsiHK2jc")
# move and copy into place
handrailGeo2 = rs.CopyObjects(handrailGeo1, moveLong)
# Clean up
hGeoList.extend([lpt2, lCurveUpper, lpt3, lCurveLower,
hpt1, hCurve1, hpt2, hCurve2, hCurve, topLine])
rs.DeleteObjects(hGeoList)
rs.EnableRedraw(True)
# 5 Wall return
if hType == 4:
rs.EnableRedraw(False)
# Draw leg upper
lpt1 = rs.CurveMidPoint(topCurve)
lpt2 = rs.CopyObject(lpt1, [0, 0, hHeight*-1])
lCurveUpper = rs.AddCurve([lpt1, lpt2])
# Draw leg lower
lpt3 = rs.CopyObject(pt2, [0, 0, hHeight*-1])
lCurveLower = rs.AddCurve([pt2, lpt3])
# get vectors
vector1 = rs.VectorScale(rs.VectorUnitize(
rs.VectorReverse(userVector)), handrailOffset)
vector2 = rs.VectorScale(
userVector, rs.CurveLength(userCurve))
# Lower Return
hpt1 = rs.CopyObject(pt4, vector1)
hCurve1 = rs.AddCurve([pt4, hpt1])
# Upper Return
hpt2 = rs.CopyObject(pt3, vector1)
hCurve2 = rs.AddCurve([pt3, hpt2])
# Join main curves
hCurveMain1 = rs.JoinCurves(
[mainCurve, topCurve, bottomCurve])
# Get Vectors
moveShort = rs.VectorScale(userVector, handrailOffset)
moveLong = rs.VectorScale(
userVector, rs.CurveLength(userCurve) - handrailOffset)
# Copy hanrail 2
hCurveMain2 = rs.CopyObject(hCurveMain1, moveLong)
hCurve3 = rs.CopyObject(hCurve1, vector2)
hCurve4 = rs.CopyObject(hCurve2, vector2)
lCurveUpper2 = rs.CopyObject(lCurveUpper, moveLong)
lCurveLower2 = rs.CopyObject(lCurveLower, moveLong)
# Join curves
hCurveJoined1 = rs.JoinCurves(
[hCurve1, hCurve2, hCurveMain1])
hCurveJoined2 = rs.JoinCurves(
[hCurveMain2, hCurve3, hCurve4, ])
# Pipe
pipe1 = rs.AddPipe(
hCurveJoined1, 0, pipeDiameter/2, blend_type=0, cap=1)
pipe2 = rs.AddPipe(
lCurveLower, 0, pipeDiameter/2, blend_type=0, cap=1)
pipe3 = rs.AddPipe(
lCurveUpper, 0, pipeDiameter/2, blend_type=0, cap=1)
pipe4 = rs.AddPipe(
hCurveJoined2, 0, pipeDiameter/2, blend_type=0, cap=1)
pipe5 = rs.AddPipe(
lCurveUpper2, 0, pipeDiameter/2, blend_type=0, cap=1)
pipe6 = rs.AddPipe(
lCurveLower2, 0, pipeDiameter/2, blend_type=0, cap=1)
handrailGeo1 = [pipe1, pipe2, pipe3,
pipe3, pipe4, pipe5, pipe6]
# Name geo for deletion
for i in handrailGeo1:
rs.ObjectName(
i, "qe7g&G5LzXEvbudtPT8xCxQbisusFVqCPqMsiHK2jc")
# Move handrail 1 into place
rs.MoveObjects([pipe1, pipe2, pipe3], moveShort)
# Cleanup
hGeoList.extend([lpt2, lCurveUpper, lpt3, lCurveLower, hpt1, hCurve1, hpt2, hCurve2, hCurveMain1, hCurveMain2, hCurve3,
hCurve4, lCurveUpper2, lCurveLower2, hCurveJoined1, hCurveJoined2])
rs.DeleteObjects(hGeoList)
rs.EnableRedraw(True)
d = rs.Distance(pts_gcrv1[i], pts_gcrv2[i])
sf = -d * 0.3 # shear factor
nz1 = pts_gcrv1[i][2] #n = new # z = coordinate
nx1 = pts_gcrv1[i][0] + sf # x = coordinate
ny1 = pts_gcrv1[i][1] # y = coordinate
npts_gcrv1 = (nx1, ny1, nz1)
spts_list1.append(npts_gcrv1)
nz2 = pts_gcrv2[i][2] #n = new # z = coordinate
nx2 = pts_gcrv2[i][0] - sf # x = coordinate
ny2 = pts_gcrv2[i][1] # y = coordinate
npts_gcrv2 = (nx2, ny2, nz2)
spts_list2.append(npts_gcrv2)
print("TEST", "Point added")
scrv1 = rs.AddInterpCurve(spts_list1)
scrv2 = rs.AddInterpCurve(spts_list2)
pts_scrv1 = rs.DivideCurve(scrv1, div)
pts_scrv2 = rs.DivideCurve(scrv2, div)
rs.AddLoftSrf([gcrv1, scrv1])
rs.AddLoftSrf([gcrv2, scrv2])
#add the pipe for outer frame
pipe_frame1 = rs.AddPipe(scrv1, 0, rad)
pipe_frame2 = rs.AddPipe(scrv2, 0, rad)
import rhinoscriptsyntax as rs
#get 2 curves & store them in list
crvs = rs.GetObjects("select 2 curves")
crv1 = crvs[0]
crv2 = crvs[1]
div = 25 #no of points the curve is divided
rad1 = 0.25 #radius for the internal connections
rad2 = rad1 * 2 #radius fore the frame
#divide the curves and store the points in a list or 2 lists
pts1 = rs.DivideCurve(crv1, div)
pts2 = rs.DivideCurve(crv2, div)
#makes the line between points and the internal pipe
for i in range(len(pts1)):
if rs.Distance(pts1[i], pts2[i]) > 0:
lines = rs.AddLine(pts1[i], pts2[i])
pipe = rs.AddPipe(lines, 0, rad1)
else:
continue
#add the pipe for outer frame
pipe_frame1 = rs.AddPipe(crv1, 0, rad2)
pipe_frame2 = rs.AddPipe(crv2, 0, rad2)
for nghd in data:
# if nghd['name'] != 'Central Oakland':
# continue
# uncomment the above to try out one nghd
border_points = nghd['border']
curve = rs.AddPolyline(border_points)
surface = rs.AddPlanarSrf(curve)
extrusion_line = rs.AddLine((0,0,0), (0,0,3))
solid = rs.ExtrudeSurface(surface, extrusion_line)
rs.DeleteObjects([curve, surface, extrusion_line])
for pipe in nghd['pipes']:
p0 = pipe[0]
p1 = pipe[1]
pipe_line = rs.AddLine((p0[0], p0[1], -.5), (p1[0], p1[1], 3.5))
pipe = rs.AddPipe(pipe_line, 0, 0.5, cap=2)
rs.DeleteObject(pipe_line)
new_solid = None
try:
new_solid = rs.BooleanDifference([solid], [pipe])
except:
print "a boolean difference failed in " + nghd['name']
rs.DeleteObject(pipe)
continue
if new_solid == None:
rs.DeleteObject(pipe)
continue # boolean difference failed, just skip one pipe
else:
solid = new_solid
rad1 = 0.15 #radius for the downward structure
rad2 = rad1 * 2 #radius fore the frame
gpts_list1 = [] # list of new points for crv 1
gpts_list2 = [] # list of new points for crv 2
#makes the line between points
for i in range(len(pts_crv1)):
nz1 = pts_crv1[i][2] - gravity #n = new # z = coordinate
nx1 = pts_crv1[i][0] # x = coordinate
ny1 = pts_crv1[i][1] # y = coordinate
npts_crv1 = (nx1, ny1, nz1)
gpts_list1.append(npts_crv1)
gline1 = rs.AddLine(pts_crv1[i], npts_crv1) #gravity line
pipe_crv1 = rs.AddPipe(gline1, 0, rad1)
nz2 = pts_crv2[i][2] - gravity #n = new # z = coordinate
nx2 = pts_crv2[i][0] # x = coordinate
ny2 = pts_crv2[i][1] # y = coordinate
npts_crv2 = (nx2, ny2, nz2)
gpts_list2.append(npts_crv2)
gline2 = rs.AddLine(pts_crv2[i], npts_crv2) #gravity line
pipe_crv2 = rs.AddPipe(gline2, 0, rad1)
gcrv1 = rs.AddInterpCurve(gpts_list1)
gcrv2 = rs.AddInterpCurve(gpts_list2)
rs.AddPipe(gcrv1, 0, rad2)
rs.AddPipe(gcrv2, 0, rad2)
#Platform of the base
rs.CurrentLayer("Surface")
rs.AddLoftSrf([L1, L2])
#Definition of parabola points
rs.CurrentLayer("Points")
for i in range(Ndiv + 1):
x = Points1[i][0]
P = [x, 0, Amp*(x-L)*(x + L)*(-1/10)]
Points3.append(rs.AddPoint(P))
#Vertical lines btw Points1(base) and Points3 (Points form parabola)
rs.CurrentLayer("Columns")
for i in range(1, Ndiv):
A_line = rs.AddLine(Points1[i], Points3[i])
pipe = rs.AddPipe(A_line, 0, r1,blend_type=0, cap=0, fit=False)
rs.DeleteObject(A_line)
rs.CopyObject(pipe, (0,W,0))
rs.DeleteObject(path)
#Diagonal stiffeners btw Points1(base) and Points3(Parabola)
rs.CurrentLayer("Diagonals")
for i in range(Ndiv-1):
A_line = rs.AddLine(Points1[i], Points3[i+1])
pipe = rs.AddPipe(A_line, 0, r1,blend_type=0, cap=0, fit=False)
rs.DeleteObject(A_line)
rs.CopyObject(pipe, (0,W,0))
#Top pipes of the bridge
rs.CurrentLayer("Diagonals")
def pipe_lines(self):
self.pipes = []
for i in range(0, len(self.lines)):
self.pipes.append(rs.AddPipe(self.lines[i], 0, 0.25))
rs.DeleteObjects(self.lines)
def makePipe(lineID):
pipe = rs.AddPipe(lineID, 0, 0.1, cap=1)
return pipe
x = random.uniform(-100, x_range)
y = random.uniform(-100, y_range)
z = random.uniform(-100, z_range)
pt = [x, y, z]
return pt
point1 = rs.AddPoint(-100, 0, 0)
point2 = rs.AddPoint(100, 0, 0)
#cloud = rs.PointAdd(point1, point2)
#cloud = rs.AddPoints(point1)
cloud = (point1, point2)
line = rs.AddLine(point1, point2)
pipe = rs.AddPipe(line, 0, 4)
all_points = []
for i in range(0, 100):
pt = rs.AddPoint(place_pts(100, 100, 100))
index = rs.PointArrayClosestPoint(cloud, pt)
cp = cloud[index]
vect = rs.VectorCreate(cp, pt)
#move = rs.MoveObject(pt,vect)
#vector = rs.VectorCreate(index, pt)
#index_points = rs.PointArrayClosestPoint(pipe_points, pt)
#vector = rs.VectorCreate(index_points, pt)
#rs.VectorCreate()
#unit_vector = rs.VectorUnitize(vector)
#new_pt = rs.MoveObject(pt, unit_vector)
def main():
# get our curves
profile, cross = get_two_curves()
if profile is None or cross is None:
return
##################################################
# get bounding box for cross section
cross_bbox = rs.BoundingBox([cross])
cmin, cmax = box_to_points(cross_bbox)
cz_range = cmax[2] - cmin[2]
cz = 0.5 * (cmax[2] + cmin[2])
c_ctr, _ = rs.CurveAreaCentroid(cross)
# make sure it's planar in XY
if cz_range > 1e-9:
print 'cross section curve should be planar in XY plane'
return
##################################################
# get bounding box for profile
profile_bbox = rs.BoundingBox([profile])
# make sure it's planar in in YZ
pmin, pmax = box_to_points(profile_bbox)
px_range = pmax[0] - pmin[0]
if px_range > 1e-9:
print 'profile curve should be planar in YZ plane'
return
##################################################
# get the point closest to the center for the
# cross-section curve
r, pc = get_inscribed_radius(cross, c_ctr)
##################################################
# get the range of z-values for the profile curve
_, _, z0 = pmin
_, _, z1 = pmax
##################################################
# build list of rings and list of points
points = []
ring_pipes = []
# for each level
for i in range(num_levels):
# get the Z value of the ith plane
u = float(i) / (num_levels-1)
z = z0 + u*(z1 - z0)
# build the i'th plane
plane = rs.PlaneFromNormal([0, 0, z], [0, 0, 1], [1, 0, 0])
# find out where the plane intersects the profile curve
intersect = rs.PlaneCurveIntersection(plane, profile)
# there should be exactly one intersection of type 1 (point)
if intersect is None or len(intersect) > 1 or intersect[0][0] != 1:
print 'bad intersection'
return
# get the intersection point
pi = intersect[0][1]
# get the desired XY radius at this z value
ri = abs(pi[1])
# we need to set up some transformations:
# translate cross section curve down to z=0
T1 = rs.XformTranslation(mz.vec_mul(list(c_ctr), -1.0))
# scale it along XY by the ratio of radii
S1 = rs.XformScale([ri/r, ri/r, 1.0])
# scale a piped cross section along Z by a vertical scale factor
S2 = rs.XformScale([1.0, 1.0, ring_vscale])
# translate piped cross section up to our desired z value
T2 = rs.XformTranslation([0, 0, z])
# scale and translate cross section curve
ci = rs.TransformObject(cross, rs.XformMultiply(S1, T1), copy=True)
# pipe it
ring = rs.AddPipe(ci, [0, 1], [ring_rad, ring_rad])
# scale vertically and transform up
ring = rs.TransformObject(ring, rs.XformMultiply(T2, S2))
# delete the copy of the cross section curve
rs.DeleteObject(ci)
# add to list of ring pipes
ring_pipes.append(ring)
# create a rotation by the i'th angle
angle_i_deg = i*360.0/num_sides
Ri = rs.XformRotation2(angle_i_deg, [0, 0, 1], [0, 0, 0])
# transform the closest point by rotation and scale
pci = rs.PointTransform(pc,
rs.XformMultiply(rs.XformMultiply(Ri, T2), S1))
# add to list of points
points.append(pci)
# we have built up a list of points for a single spiral of struts to connect,
# now we need to pipe them all together and do the ArrayPolar thing around
# the z axis
# first build a single spiral of struts
strut_pipes = []
for i0 in range(num_levels-1):
i1 = i0+1
p0 = points[i0]
p1 = points[i1]
l01 = rs.AddLine(p0, p1)
pipe = rs.AddPipe(l01, [0, 1], [strut_rad, strut_rad], cap=2)
rs.DeleteObject(l01)
strut_pipes.append(pipe)
# then array polar around Z axis
all_strut_pipes = []
all_strut_pipes += strut_pipes
for j in range(1, num_sides):
angle_j_deg = j*360.0/num_sides
Rj = rs.XformRotation2(angle_j_deg, [0, 0, 1], [0, 0, 0])
all_strut_pipes += rs.TransformObjects(strut_pipes, Rj, copy=True)
# now just select all the objects we created
rs.SelectObjects(ring_pipes + all_strut_pipes)
# done!
print 'yay'
points1.append(w1.getLocation())
w2.step()
points2.append(w2.getLocation())
parameterCounter = 0.0
parameterCounter1 = 0.0
parameterCounter2 = 0.0
for point in points:
tempRadius = random.uniform(.05,.25)
tempRadius1 = random.uniform(.05,.25)
tempRadius2 = random.uniform(.05,.25)
radii.append(tempRadius)
radii1.append(tempRadius)
radii2.append(tempRadius)
parameters.append(parameterCounter)
parameters1.append(parameterCounter)
parameters2.append(parameterCounter)
parameterCounter += 1/len(points)
parameterCounter1 += 1/len(points)
parameterCounter2 += 1/len(points)
curve = rs.AddCurve(points)
curve1 = rs.AddCurve(points1)
curve2 = rs.AddCurve(points2)
rs.AddPipe(curve, parameters, radii, 1, 2, False)
rs.AddPipe(curve1, parameters1, radii1, 1, 2, False)
rs.AddPipe(curve2, parameters2, radii2, 1, 2, False)
def AddLine(start, ends, radius, index):
line = rs.AddLine(start, ends)
pipe = rs.AddPipe(line, 0, radius)
draw(pipe, index)
return line
def output_frame(filename):
global box_height
global box_width
global pipe_diameter
# Import object from file
join_string = str(input_directory + filename)
combined_string = '!_Import ' + '"' + join_string + '"'
rs.Command(combined_string)
# Get all objects imported
objs = rs.LastCreatedObjects(select=False)[0]
# Close curve
closed_curve = rs.CloseCurve(objs, 0.5)
rs.DeleteObject(objs)
# Rebuild curve to create smoother shape
rs.RebuildCurve(closed_curve, 3, 100)
# Pipe figure with radius of 0.25
piped = rs.AddPipe(closed_curve, 0, pipe_diameter)[0]
rs.MoveObject(piped, [0, 0, 0])
bounding_pts = rs.BoundingBox([piped], view_or_plane=rs.WorldXYPlane())
maxX = 0
minX = 0
minY = 0
minZ = 0
for pt in bounding_pts:
if pt[0] < minX:
minX = pt[0]
if pt[0] > maxX:
maxX = pt[0]
if pt[1] < minY:
minY = pt[1]
if pt[2] < minZ:
minZ = pt[2]
epsilon = 0.5
center = 0
one = [
center - (box_width / 2) - box_height, minY - epsilon,
-1 * pipe_diameter
]
two = [
center - (box_width / 2) - box_height, minY - epsilon, pipe_diameter
]
three = [
center + (box_width / 2) + box_height, minY - epsilon, pipe_diameter
]
four = [
center + (box_width / 2) + box_height, minY - epsilon,
-1 * pipe_diameter
]
five = [
center - (box_width / 2) - box_height, minY + epsilon,
-1 * pipe_diameter
]
six = [
center - (box_width / 2) - box_height, minY + epsilon, pipe_diameter
]
seven = [
center + (box_width / 2) + box_height, minY + epsilon, pipe_diameter
]
eight = [
center + (box_width / 2) + box_height, minY + epsilon,
-1 * pipe_diameter
]
bowx = rs.AddBox([two, three, four, one, six, seven, eight, five])
# rect = rs.AddRectangle(rs.WorldXYPlane(), box_width, box_height)
#rect = rs.AddRectangle(rs.WorldXYPlane(), box_width, box_height)
# Potentially use solid but smaller in height rect
# rs.MoveObject(rect, [minX, minY - 3.0, minZ + pipe_diameter])
# piped_rect = rs.AddPipe(rect,0,pipe_diameter)
rs.DeleteObject(closed_curve)
# rs.DeleteObject(rect)
rs.SelectObjects([piped, bowx])
rs.Command("_-Export " + output_directory + filename + '.stl' +
" _Enter _Tolerance=.001 _Enter")
Poly_top = rs.CopyObject(Poly_base, (0, 0, H))
#Returns Curve Control Points
Points1 = rs.CurvePoints(Poly_base)
Points2 = rs.CurvePoints(Poly_top)
#Construct the legs
rs.CurrentLayer("Legs")
#loop for lines which will be legs
for i in range(N):
A_lines = rs.AddLine(Points1[i], Points2[i]) #lines for the pipes
#Add pipes
pipe = rs.AddPipe(A_lines, 0, radius_pipes, blend_type=0, cap=1, fit=False)
#Append each pipe to Legs
Legs.append(pipe)
#rs.DeleteObjects([A_lines, Poly_base, Poly_top])
#Create group
rs.AddGroup("Legs")
rs.AddObjectsToGroup(Legs, "Legs")
#Construct the table top, draw offset curve
offset_crv = rs.OffsetCurve(Poly_top,
Cen_top,
-(offset_dist),
normal=None,
name_dot = rs.AddTextDot(value, point_list[i][j])
rs.ObjectLayer(name_dot, new_layer)
else:
# convert to string to float
value = float(value)
if(value > 0):
value = value * factor
# select vector
vec_coord = norm_list[i][j]
print(vec_coord)
# scale vector with data from team
vec = rs.VectorScale(vec_coord, value + 0.1 )
if(rs.VectorLength(vec) < 0.1):
# unitize vector
vec_unit = rs.VectorUnitize(vec)
vec = rs.VectorScale(vec_unit, 0.2)
print(point_list[i][j])
# copy point
start_point = rs.AddPoint(point_list[i][j])
end_point = rs.CopyObject(start_point, vec)
# create a line
line = rs.AddLine(point_list[i][j], end_point)
pipe = rs.AddPipe(line, [0.0, 1.0], [4, 4], cap = 1)
rs.DeleteObjects([start_point, end_point, line])
rs.ObjectLayer(pipe, new_layer)
rs.EnableRedraw = True
