def draw_triangle(triangle, color):
point1 = triangle[0]
point2 = triangle[1]
point3 = triangle[2]
seg1 = LineSegs()
seg1.setColor(color[0], color[1], color[2], 1)
seg1.setThickness(3)
seg1.draw_to(point1[0], 0, point1[1]) # x, z, y
seg1.draw_to(point2[0], 0, point2[1]) # x, z, y
node1 = seg1.create()
nodes.append(node1)
seg2 = LineSegs()
seg2.setColor(color[0], color[1], color[2], 1)
seg2.setThickness(3)
seg2.draw_to(point2[0], 0, point2[1]) # x, z, y
seg2.draw_to(point3[0], 0, point3[1]) # x, z, y
node2 = seg2.create()
nodes.append(node2)
seg3 = LineSegs()
seg3.setColor(color[0], color[1], color[2], 1)
seg3.setThickness(3)
seg3.draw_to(point3[0], 0, point3[1]) # x, z, y
seg3.draw_to(point1[0], 0, point1[1]) # x, z, y
node3 = seg3.create()
nodes.append(node3)
def plot_xy_vs_t(self):
then = self.now
if self.now == 0:
then = time.time()
self.now = time.time()
#print self.now
dt = (self.now - then) / 10
joy_in = self.js.getEvents()
if joy_in:
#print type(joy_in)
for event_name in joy_in:
#print event_name
event = joy_in[event_name]
#print event
#print type(event)
#print inspect.getmembers(event, predicate=inspect.ismethod)
event_mag = event.getMagnitude()
if event_name == 'moveForward':
y_mag = event_mag
#print('forward', y_mag)
self.y_mag = (y_mag * self.gain) - self.offset
#print('forward', self.y_mag)
elif event_name == 'moveBackward':
y_mag = -event_mag
#print('backward', y_mag)
self.y_mag = (y_mag * self.gain) - self.offset
#print('backward', self.y_mag)
elif event_name == 'turnRight':
x_mag = event_mag
#print('right', x_mag)
self.x_mag = (x_mag * self.gain) + self.offset
#print('right', self.x_mag)
elif event_name == 'turnLeft':
x_mag = -event_mag
#print('left', x_mag)
self.x_mag = (x_mag * self.gain) + self.offset
#print('left', self.x_mag)
plot_x = LineSegs()
plot_x.setThickness(2.0)
plot_x.setColor(Vec4(1, 1, 0, 1))
plot_x.moveTo(self.time, 0, self.old_x)
plot_y = LineSegs()
plot_y.setThickness(2.0)
plot_y.setColor(Vec4(1, 0, 0, 1))
plot_y.moveTo(self.time, 0, self.old_y)
self.time += dt
#print('dt', dt)
#print('time', self.time)
plot_x.drawTo(self.time, 0, self.x_mag)
node = base.render2d.attach_new_node(plot_x.create(True))
self.plot.append(node)
plot_y.drawTo(self.time, 0, self.y_mag)
node = base.render2d.attach_new_node(plot_y.create(True))
self.plot.append(node)
self.old_x = self.x_mag
self.old_y = self.y_mag
if self.time > 1:
self.clear_plot()
def plot_xy_vs_t(self):
then = self.now
if self.now == 0:
then = time.time()
self.now = time.time()
#print self.now
dt = (self.now - then) / 10
joy_in = self.js.getEvents()
if joy_in:
#print type(joy_in)
for event_name in joy_in:
#print event_name
event = joy_in[event_name]
#print event
#print type(event)
#print inspect.getmembers(event, predicate=inspect.ismethod)
event_mag = event.getMagnitude()
if event_name == 'moveForward':
y_mag = event_mag
#print('forward', y_mag)
self.y_mag = (y_mag * self.gain) - self.offset
#print('forward', self.y_mag)
elif event_name == 'moveBackward':
y_mag = -event_mag
#print('backward', y_mag)
self.y_mag = (y_mag * self.gain) - self.offset
#print('backward', self.y_mag)
elif event_name == 'turnRight':
x_mag = event_mag
#print('right', x_mag)
self.x_mag = (x_mag * self.gain) + self.offset
#print('right', self.x_mag)
elif event_name == 'turnLeft':
x_mag = -event_mag
#print('left', x_mag)
self.x_mag = (x_mag * self.gain) + self.offset
#print('left', self.x_mag)
plot_x = LineSegs()
plot_x.setThickness(2.0)
plot_x.setColor(Vec4(1, 1, 0, 1))
plot_x.moveTo(self.time, 0, self.old_x)
plot_y = LineSegs()
plot_y.setThickness(2.0)
plot_y.setColor(Vec4(1, 0, 0, 1))
plot_y.moveTo(self.time, 0, self.old_y)
self.time += dt
#print('dt', dt)
#print('time', self.time)
plot_x.drawTo(self.time, 0, self.x_mag)
node = base.render2d.attach_new_node(plot_x.create(True))
self.plot.append(node)
plot_y.drawTo(self.time, 0, self.y_mag)
node = base.render2d.attach_new_node(plot_y.create(True))
self.plot.append(node)
self.old_x = self.x_mag
self.old_y = self.y_mag
if self.time > 1:
self.clear_plot()
def createMoveVis(self):
# Instance each selected map object to the vis root
for obj in base.selectionMgr.selectedObjects:
instRoot = NodePath("instRoot")
inst = obj.np.instanceTo(instRoot)
instRoot.wrtReparentTo(self.toolVisRoot)
self.xformObjects.append((obj, instRoot, inst))
# Show an infinite line along the axis we are moving the object
# if we are using the 3D view
if self.widget.activeAxis:
axis = self.widget.activeAxis.axisIdx
segs = LineSegs()
col = Vec4(0, 0, 0, 1)
col[axis] = 1.0
segs.setColor(col)
p = Point3(0)
p[axis] = -1000000
segs.moveTo(p)
p[axis] = 1000000
segs.drawTo(p)
self.axis3DLines = self.toolRoot.attachNewNode(segs.create())
self.axis3DLines.setLightOff(1)
self.axis3DLines.setFogOff(1)
self.widget.stash()
def __init__(self):
""" """
TQGraphicsNodePath.__init__(self)
ls = LineSegs()
ls.setThickness(1)
# X axis
ls.setColor(1.0, 0.0, 0.0, 1.0)
ls.moveTo(0.0, 0.0, 0.0)
ls.drawTo(1.0, 0.0, 0.0)
# Y axis
ls.setColor(0.0, 1.0, 0.0, 1.0)
ls.moveTo(0.0, 0.0, 0.0)
ls.drawTo(0.0, 1.0, 0.0)
# Z axis
ls.setColor(0.0, 0.0, 1.0, 1.0)
ls.moveTo(0.0, 0.0, 0.0)
ls.drawTo(0.0, 0.0, 1.0)
geomnode = ls.create()
self.set_p3d_nodepath(NodePath(geomnode))
self.setLightOff(1)
def load_bbone(self, structure, node):
for chain in structure.get_chains():
carr = np.random.rand(3, 1)
ccolor = float(carr[0]), float(carr[1]), float(carr[2]), 1.0
can_atoms = [
atom for atom in chain.get_atoms()
if atom.get_name() == 'CA' or atom.get_name() == 'N'
]
can_coordinates = [atom.coord for atom in can_atoms]
for atom in can_atoms:
x, y, z = atom.coord
id = atom.get_id()
a = loader.loadModel("data/atom_sphere")
a.setPos(x, y, z)
a.reparentTo(pnode)
a.setColor(ccolor)
a.setScale(vrad(id) / 2.5)
lines = LineSegs()
lines.setColor(ccolor)
lines.moveTo(can_coordinates[0][0], can_coordinates[0][1],
can_coordinates[0][2])
for i in range(len(can_atoms))[1:]:
lines.drawTo(can_coordinates[i][0], can_coordinates[i][1],
can_coordinates[i][2])
lines.setThickness(6)
lnode = lines.create()
linenp = NodePath(lnode)
linenp.reparentTo(pnode)
node.flattenStrong()
def move_map_avatar(self, move, stop):
# print move
# avatar is mapped assuming c_range of 0.5. What do I need to
# change to use a different c_range? c_range of one is twice
# the
if move:
avt = LineSegs()
avt.setThickness(1)
avt.setColor(1, 1, 1)
# print 'last', self.last_avt
avt.move_to(self.last_avt[0], -5, self.last_avt[1])
# print 'move', move
new_move = [i + (j * self.avt_factor) for i, j in zip(self.last_avt, move)]
# new_move = [i + j for i, j in zip(self.last_avt, move)]
# would it be better to have a local stop condition?
if stop[0]:
new_move[0] = self.last_avt[0]
# print 'stop x', self.last_avt[0]
if stop[1]:
new_move[1] = self.last_avt[1]
# print 'stop y', self.last_avt[1]
# print 'new', new_move
self.last_avt = [new_move[0], new_move[1]]
avt.draw_to(new_move[0], -5, new_move[1])
self.map_avt_node.append(self.render2d.attach_new_node(avt.create()))
# print self.map_avt_node[-1]
# can't let too many nodes pile up
if len(self.map_avt_node) > 299:
# removing the node does not remove the object from the list
for i, j in enumerate(self.map_avt_node):
j.removeNode()
if i > 49:
break
del self.map_avt_node[0:50]
class LineEffects():
def __init__(self):
self.linesegs = LineSegs("lines")
self.bullet = None
def remove_bullet(self):
if self.bullet:
self.bullet.detach_node()
def draw_bullet(self, a, b, color):
if color == 1:
color = (1,0,1,1)
elif color == 2:
color = (0,1,1,1)
else:
color = (1,1,1,1)
self.linesegs.set_color(color)
a = a.get_pos(render)
self.linesegs.move_to(a)
self.linesegs.draw_to(b)
lines = self.linesegs.create()
self.bullet = render.attach_new_node(lines)
impact = base.icons["impact"]
impact = impact.copy_to(self.bullet)
impact.set_pos(b)
def checkCollisions(self, task):
sensorPoints = []
self.sensorDistances = []
for queue in self.sensorCollisionHandlers:
if queue.getNumEntries() > 0:
queue.sortEntries()
entry = queue.getEntry(0)
sensorPoint = entry.getSurfacePoint(entry.getFromNodePath())
sensorPoints.append(sensorPoint)
tmp = sensorPoint - Vec3(0.0, 0.0, self.sensorHeight)
self.sensorDistances.append(tmp.length())
# DEBUG
tmp = self.car.find("sensorsSegs")
if not tmp.isEmpty():
tmp.removeNode()
if self.debugMode:
sensorSegs = LineSegs("sensorsSegs")
sensorSegs.setColor(1.0, 0.45, 0.0)
sensorSegs.setThickness(4)
for point in sensorPoints:
sensorSegs.moveTo(Point3(0.0, 0.0, self.sensorHeight))
sensorSegs.drawTo(point)
sensorNode = sensorSegs.create()
self.car.attachNewNode(sensorNode)
return task.cont
def show_window(self, target_pos):
# draw line around target representing how close the subject has to be looking to get reward
# print('show window around square', square_pos)
tolerance = self.plot_variables[
self.text_dict['Tolerance']] / self.deg_per_pixel
# print 'tolerance in pixels', tolerance
# print 'square', square[0], square[2]
eye_window = LineSegs()
eye_window.setThickness(2.0)
eye_window.setColor(1, 0, 0, 1)
angle_radians = radians(360)
for i in range(50):
a = angle_radians * i / 49
y = tolerance * sin(a)
x = tolerance * cos(a)
eye_window.drawTo((x + target_pos[0], 55, y + target_pos[1]))
# draw a radius line
# eye_window.moveTo(square[0], 55, square[2])
# eye_window.drawTo(square[0], 55, square[2] + self.plot_variables[self.text_dict['Tolerance']])
# print 'distance drawn', self.distance((square[0], square[2]), (square[0], square[2] + self.plot_variables[self.text_dict['Tolerance']]))
# True optimizes the line segments, which sounds useful
node = self.base.render.attachNewNode(eye_window.create(True))
node.show(BitMask32.bit(0))
node.hide(BitMask32.bit(1))
self.eye_window.append(node)
def plot_eye_trace(self, first_eye):
# print 'plot trace'
# if plotting too many eye positions, things slow down and
# python goes into lala land. Never need more than 500, and
# last 300 is definitely plenty, so every time it hits 500,
# get rid of first 200.
if len(self.eye_nodes) > 500:
# print('get rid of eye nodes', len(self.eye_nodes))
# Since this just removes the node, but doesn't delete
# the object in the list, can do this in a for loop,
for index in range(200):
self.eye_nodes[index].removeNode()
# now get rid of the empty nodes in eye_nodes
# print('new length', len(self.eye_nodes))
self.eye_nodes = self.eye_nodes[200:]
# print('new length', len(self.eye_nodes))
eye = LineSegs()
# eye.setThickness(2.0)
eye.setThickness(2.0)
# print 'last', last_eye
# print 'now', self.current_eye_data
eye.moveTo(first_eye[0], 55, first_eye[1])
for data_point in self.current_eye_data:
eye.drawTo(data_point[0], 55, data_point[1])
# print('plotted eye', eye_data_to_plot)
node = self.base.render.attachNewNode(eye.create(True))
node.show(BitMask32.bit(0))
node.hide(BitMask32.bit(1))
self.eye_nodes.append(node)
def drawBBox(self, scnObj):
ls = LineSegs()
x, y, z = scnObj.pos
rx, rz, ry = scnObj.radius
ls.setThickness(5)
ls.setColor(1, 0.4, 0.0, 0.3)
ls.moveTo(x, y, z)
ls.drawTo(x + rx, y + ry, z + rz)
ls.drawTo(x + rx, y - ry, z + rz)
ls.drawTo(x - rx, y - ry, z + rz)
ls.drawTo(x - rx, y + ry, z + rz)
ls.drawTo(x + rx, y + ry, z + rz)
ls.moveTo(x, y, z)
ls.drawTo(x + rx, y + ry, z - rz)
ls.drawTo(x + rx, y - ry, z - rz)
ls.drawTo(x - rx, y - ry, z - rz)
ls.drawTo(x - rx, y + ry, z - rz)
ls.drawTo(x + rx, y + ry, z - rz)
linegeomn = ls.create(dynamic=False)
np = self.render.attachNewNode(linegeomn)
scnObj.setNodePath(
np) # Rotation should occure ere, TODO but maybe it shouldnt
def drawLineSegments(self,
scnObjs): #Point will be origin of line segments
ls = LineSegs()
ls.setThickness(5)
ind = 0
for scnobj in scnObjs:
point = scnobj.pos
a0 = scnobj.a0
a1 = scnobj.a1
a2 = scnobj.a2
#Draw th new threes
ls.setColor(1, 0, 0, 0.7)
ls.moveTo(float(point[0]), float(point[1]), float(point[2]))
ls.drawTo(float(point[0] + a0[0]), point[1] + float(a0[1]),
point[2] + float(a0[2]))
ls.setColor(0, 1, 0, 0.7)
ls.moveTo(float(point[0]), float(point[1]), float(point[2]))
ls.drawTo(float(point[0] + a1[0]), point[1] + float(a1[1]),
point[2] + float(a1[2]))
ls.setColor(0, 0, 1, 0.7)
ls.moveTo(float(point[0]), float(point[1]), float(point[2]))
ls.drawTo(float(point[0] + a2[0]), point[1] + float(a2[1]),
point[2] + float(a2[2]))
#ls.setColor(1,0,0,0.7)
ind += 1
linegeomn = ls.create(dynamic=False) # Creates a geomnode
nodePath = self.render.attachNewNode(linegeomn)
self.linesegs.append(nodePath)
def draw_multiselect_box(self, task):
if base.mouseWatcherNode.isButtonDown(MouseButton.one()):
self.multi_select = True
self.select_box.remove()
ls = LineSegs()
ls.move_to(self.box_x, self.box_y, 1)
ls.draw_to(self.model.getX(), self.box_y, 1)
ls.draw_to(self.model.getX(), self.model.getY(), 1)
ls.draw_to(self.box_x, self.model.getY(), 1)
ls.draw_to(self.box_x, self.box_y, 1)
node = ls.create()
#text = TextNode('text')
#text.setText(str(self.box_x)+","+str(self.box_y)+"\n"+str(self.model.getX())+","+str(self.model.getY()))
#textnp = NodePath(text)
#textnp.setPos(self.box_x,self.box_y,1)
#textnp.setHpr(0,-90,0)
#textnp.setScale(20.0)
self.select_box = NodePath(node)
#textnp.reparentTo(self.select_box)
self.select_box.reparentTo(render)
return task.cont
else:
self.select_box.hide()
taskMgr.add(self.task_select_check, "updatePicker")
return task.done
def plot_xy(self):
joy_in = self.js.getEvents()
if joy_in:
#print type(joy_in)
for event_name in joy_in:
#print event_name
event = joy_in[event_name]
#print event
#print type(event)
#print inspect.getmembers(event, predicate=inspect.ismethod)
event_mag = event.getMagnitude()
if event_name == 'moveForward':
self.y_mag = event_mag
print('forward', self.y_mag)
elif event_name == 'moveBackward':
self.y_mag = -event_mag
print('backward', self.y_mag)
elif event_name == 'turnRight':
self.x_mag = event_mag
print('right', self.x_mag)
elif event_name == 'turnLeft':
self.x_mag = -event_mag
print('left', self.x_mag)
plot_xy = LineSegs()
plot_xy.setThickness(2.0)
plot_xy.setColor(Vec4(1, 1, 0, 1))
plot_xy.moveTo(self.old_x, 0, self.old_y)
plot_xy.drawTo(self.x_mag, 0, self.y_mag)
base.render2d.attach_new_node(plot_xy.create(True))
self.old_x = self.x_mag
self.old_y = self.y_mag
def getUnitCone():
global UnitCone
if not UnitCone:
segs = LineSegs('unitCone')
dist = 1
points = [
Vec3(-dist, 1, 0),
Vec3(0, 1, dist),
Vec3(0, 1, -dist),
Vec3(dist, 1, 0)
]
for point in points:
segs.moveTo(Vec3(0))
segs.drawTo(point)
vertices = LEUtils.circle(0, 0, dist, 64)
for i in range(len(vertices)):
x1, y1 = vertices[i]
x2, y2 = vertices[(i + 1) % len(vertices)]
pFrom = Vec3(x1, 1, y1)
pTo = Vec3(x2, 1, y2)
segs.moveTo(pFrom)
segs.drawTo(pTo)
UnitCone = NodePath(segs.create())
UnitCone.setAntialias(AntialiasAttrib.MLine)
UnitCone.setLightOff(1)
UnitCone.setFogOff(1)
UnitCone.hide(DirectRender.ShadowCameraBitmask
| DirectRender.ReflectionCameraBitmask)
return UnitCone
def gen_linesegs(linesegs, thickness=0.001, rgba=[0, 0, 0, 1]):
"""
gen linsegs -- non-continuous segs are allowed
:param linesegs: [[pnt0, pn1], [pnt0, pnt1], ...], pnti 1x3 nparray, defined in local 0 frame
:param rgba:
:param thickness:
:param refpos, refrot: the local coordinate frame where the pnti in the linsegs are defined
:return: a geomtric model
author: weiwei
date: 20161216, 20201116
"""
M_TO_PIXEL = 3779.53
# Create a set of line segments
ls = LineSegs()
ls.setThickness(thickness * M_TO_PIXEL)
ls.setColor(rgba[0], rgba[1], rgba[2], rgba[3])
for p0p1tuple in linesegs:
ls.moveTo(p0p1tuple[0][0], p0p1tuple[0][1], p0p1tuple[0][2])
ls.drawTo(p0p1tuple[1][0], p0p1tuple[1][1], p0p1tuple[1][2])
# Create and return a node with the segments
lsnp = NodePath(ls.create())
lsnp.setTransparency(TransparencyAttrib.MDual)
lsnp.setLightOff()
ls_sgm = StaticGeometricModel(lsnp)
return ls_sgm
def draw(self, start, end):
segs = LineSegs()
segs.set_color(*self.color)
segs.moveTo(start._vec) # access to a protected member
segs.drawTo(end._vec) # access to a protected member
segs_node = segs.create()
self.lines += [render.attachNewNode(segs_node)]
def draw_trails(self):
# draw trails
# self.trails = []
for i, ball in enumerate(self.box.particles):
trail = []
# for j in range(self.box.trail):
for j in range(MAX_TRAILS):
line = LineSegs(f"trail[{i},{j}]")
color = [c / 255 for c in ball.color]
line.setColor(*color, 1)
# line.setColor(0.3, 0.3, 0.3, 1)
line.moveTo((0, 0, 0))
line.drawTo((0, 1, 0))
line.setThickness(1)
node = line.create()
nodepath = NodePath(node)
# nodepath.reparentTo(self.render)
nodepath.reparentTo(self.boxnode)
# nodepath.reparentTo(ball.object)
# nodepath.setColor(0,0.5,0,1)
trail.append(nodepath)
self.trails.append(trail)
return self.box.particles
def update_LFP(self, dt, last_lfp, lfp_trace, offset, gen_lfp):
# lfp data is taken at 1000Hz, and dt is the number of seconds since
# the last frame was flipped, so plot number of points = dt * 1000
lfp = LineSegs()
lfp.setThickness(1.0)
#print('points to plot', int(dt * 1000))
#self.lfp_test += int(dt * 1000)
#print('points so far', self.lfp_test)
for i in range(int(dt * 1000)):
try:
last_lfp.append((next(gen_lfp) * self.lfp_gain) + offset)
#last_lfp_x += 0.05
# only plotting 200 data points at a time
while len(last_lfp) > 3500:
last_lfp.pop(0)
except StopIteration:
#print('done with lfp')
break
if lfp_trace:
lfp_trace[0].removeNode()
lfp_trace.pop(0)
lfp.moveTo(self.start_x_trace, 55, last_lfp[0])
x = self.start_x_trace
for i in last_lfp:
x += .1
lfp.drawTo(x, 55, i)
node = self.base.pixel2d.attachNewNode(lfp.create())
lfp_trace.append(node)
def createCurve(self):
self.curve = []
self.progress = 0
self.showCurve = True
lineThickness = 2
ls = LineSegs("LogSpiral")
ls.setThickness(lineThickness)
iteration_count = 10001
step_delta = 0.001
curve_length = step_delta * iteration_count
for index in np.arange(1 + (curve_length * self.truncate_percentage),
curve_length, step_delta):
# Calculate curve point position
spiral_x = self.radius_scale * self.a * pow(
math.e, self.k * index) * math.cos(index)
spiral_y = self.radius_scale * self.a * pow(
math.e, self.k * index) * math.sin(index)
spiral_z = self.height_scale * self.height_scale * math.log(
index, math.e) + self.lower_bound
if (self.showCurve): ls.drawTo(spiral_x, spiral_y, spiral_z)
self.curve.append(Vec3(spiral_x, spiral_y, spiral_z))
self.curve.reverse()
if (self.curve_segment != None): self.curve_segment.removeNode()
node = ls.create(dynamic=False)
body = BulletRigidBodyNode("lsRB")
bodyNP = self.worldNP.attachNewNode(body)
self.curve_segment = bodyNP.attachNewNode(node)
if (not self.show_curve): self.curve_segment.hide()
def createAxesCross(name, size, has_labels):
def createAxisLine(label, color, draw_to):
coords.setColor(color)
coords.moveTo(0, 0, 0)
coords.drawTo(draw_to)
# Put the axis' name in the tip
if label != "":
text = TextNode(label)
text.setText(label)
text.setTextColor(color)
axis_np = coords_np.attachNewNode(text)
else:
axis_np = coords_np.attachNewNode("")
axis_np.setPos(draw_to)
return axis_np
coords_np = NodePath(name)
coords = LineSegs()
coords.setThickness(2)
axis_x_np = createAxisLine("X" if has_labels else "", Color3D.RED, (size, 0, 0))
axis_y_np = createAxisLine("Y" if has_labels else "", Color3D.GREEN, (0, size, 0))
axis_z_np = createAxisLine("Z" if has_labels else "", Color3D.BLUE, (0, 0, size))
np = coords.create(True)
coords_np.attachNewNode(np)
return coords_np, axis_x_np, axis_y_np, axis_z_np
def create_line_seg(panda3d):
print("Draw LineSeg")
line = LineSegs()
print(LineSegs)
line.setThickness(4)
print(coredata["start"])
x0, y0, z0 = coredata["start"]
x1, y1, z1 = app.work_plane_mouse
line.setColor(1.0, 0.0, 0.0, 1.0)
line.moveTo(x0, y0, z0)
line.drawTo(x1, y1, z1)
coredata["line"] = line
node = line.create(dynamic=True)
node_path = NodePath(node)
node_path.reparentTo(panda3d.render)
coredata["line_node"] = node_path
return line, node
def makeGizmoAxis(self, axis, text, textOffset=1.1):
color = Vec4(0, 0, 0, 1)
color[axis] = 1
pos = Vec3(0, 1, 0)
if axis == 1:
pos[1] = -pos[1]
if axis == 1:
textOffset = -textOffset
direction = Vec3(0)
direction[axis] = 1
segs = LineSegs()
segs.setColor(color)
segs.moveTo(Point3(0))
segs.drawTo(pos)
np = self.np.attachNewNode(segs.create())
np.lookAt(direction)
tn = TextNode('gizmoAxis%iText' % axis)
tn.setTextColor(color)
tn.setAlign(TextNode.ACenter)
tn.setText(text)
tnnp = np.attachNewNode(tn.generate())
tnnp.setY(textOffset)
tnnp.setBillboardPointEye()
tnnp.setScale(0.5)
return np
def makeBulletRicochet(self, dgi):
pos = CIGlobals.getVec3(dgi)
dir = CIGlobals.getVec3(dgi)
scale = dgi.getFloat64()
start = (0, 0, 0)
end = dir * scale
from panda3d.core import LineSegs, Vec4
from direct.interval.IntervalGlobal import Sequence, Func, Parallel
lines = LineSegs()
lines.setColor(Vec4(1, 1, 1, 1))
lines.setThickness(1)
lines.moveTo(start)
lines.drawTo(end)
np = render.attachNewNode(lines.create())
np.setLightOff(1)
np.setPos(pos)
Sequence(
Parallel(np.posInterval(0.1, pos + end, pos),
np.scaleInterval(0.1, (0.001, 0.001, 0.001), (1, 1, 1))),
Func(np.removeNode)).start()
import random
soundDir = "sound/weapons/ric{0}.wav"
soundIdx = random.randint(1, 5)
CIGlobals.emitSound(soundDir.format(soundIdx), pos)
def add_line(self, start_p: Union[Vec3, Tuple], end_p: Union[Vec3, Tuple], color, thickness: float):
line_seg = LineSegs("interface")
line_seg.setColor(*color)
line_seg.moveTo(start_p)
line_seg.drawTo(end_p)
line_seg.setThickness(thickness)
NodePath(line_seg.create(False)).reparentTo(self.render)
def make_circle(self, angle_deg=360):
ls = LineSegs()
angle_radians = np.deg2rad(angle_deg)
# assume visual angle is approximately the same for x and y,
# which probably is not true, maybe need to change
#radius = 1 * Positions().visual_angle()[0]
res = [1024, 768]
# Screen size
screen = [1337, 991]
v_dist = 1219
# number of visual angles want circle radius to be
# (so twice this is the x and y of the square)
angle = 0.25
# visual angle returns degrees per pixel, so invert since
# we want pixel per degree
deg_per_pixel = visual_angle(screen, res, v_dist)
x_radius = angle * 1 / deg_per_pixel[0]
y_radius = angle * 1 / deg_per_pixel[0]
for i in range(50):
a = angle_radians * i / 49
y = y_radius * np.sin(a)
#print y
x = x_radius * np.cos(a)
#print x
ls.drawTo(x, self.depth, y)
#node = ls.create()
node = self.base.render.attachNewNode(ls.create(True))
return NodePath(node)
def plot_xy(self):
joy_in = self.js.getEvents()
if joy_in:
#print type(joy_in)
for event_name in joy_in:
#print event_name
event = joy_in[event_name]
#print event
#print type(event)
#print inspect.getmembers(event, predicate=inspect.ismethod)
event_mag = event.getMagnitude()
if event_name == 'moveForward':
self.y_mag = event_mag
print('forward', self.y_mag)
elif event_name == 'moveBackward':
self.y_mag = -event_mag
print('backward', self.y_mag)
elif event_name == 'turnRight':
self.x_mag = event_mag
print('right', self.x_mag)
elif event_name == 'turnLeft':
self.x_mag = -event_mag
print('left', self.x_mag)
plot_xy = LineSegs()
plot_xy.setThickness(2.0)
plot_xy.setColor(Vec4(1, 1, 0, 1))
plot_xy.moveTo(self.old_x, 0, self.old_y)
plot_xy.drawTo(self.x_mag, 0, self.y_mag)
base.render2d.attach_new_node(plot_xy.create(True))
self.old_x = self.x_mag
self.old_y = self.y_mag
def create(self, s):
segs = LineSegs( )
segs.setThickness( 2.0 )
segs.setColor( Vec4(1,0,0,1) )
segs.moveTo( s.points[0] )
for p in s.points[1:]:
segs.drawTo( p )
return segs.create( )
def plot_zero_lines(self):
plot_zero = LineSegs()
plot_zero.setThickness(2.0)
plot_zero.setColor(Vec4(1, 0, 1, 1))
plot_zero.moveTo(-1, 0, self.x_mag)
plot_zero.drawTo(1, 0, self.x_mag)
plot_zero.moveTo(-1, 0, self.y_mag)
plot_zero.drawTo(1, 0, self.y_mag)
base.render2d.attach_new_node(plot_zero.create(True))
def draw_line(self,p,col):
line = LineSegs()
line.setColor(col[0],col[1],col[2], 1)
line.setThickness(2)
line.moveTo(p[0],p[1],0)
line.drawTo(p[2],p[3],0)
line_node = line.create()
node_path = NodePath(line_node)
node_path.reparentTo(render)
def _drawActualDroneLine(self):
self.actualDroneLineNP.removeNode()
ls = LineSegs()
# ls.setThickness(1)
ls.setColor(0.0, 0.0, 0.0, 1.0)
ls.moveTo(self.getPos())
ls.drawTo(self.actualDronePosition)
node = ls.create()
self.actualDroneLineNP = self.base.render.attachNewNode(node)
def _drawSetpointLine(self):
self.setpointNP.removeNode()
ls = LineSegs()
# ls.setThickness(1)
ls.setColor(1.0, 1.0, 1.0, 1.0)
ls.moveTo(self.getPos())
ls.drawTo(self.setpoint)
node = ls.create()
self.setpointNP = self.base.render.attachNewNode(node)
def make_circle(self, radius, center, color=None):
circle = LineSegs()
circle.setThickness(2.0)
if not color:
circle.setColor(1, 1, 0, 1)
else:
circle.setColor(color)
angle_radians = radians(360)
# print alpha_pos
for i in range(50):
a = angle_radians * i / 49
y = radius * sin(a)
x = radius * cos(a)
circle.drawTo((x + center[0], self.drawing_layer, y + center[2]))
if not color:
self.alpha_circle_node.append(self.base.render.attachNewNode(circle.create()))
else:
self.base.render.attachNewNode(circle.create())
def _drawVelocityLine(self):
self.velocityLineNP.removeNode()
ls = LineSegs()
# ls.setThickness(1)
ls.setColor(0.0, 0.0, 1.0, 1.0)
ls.moveTo(self.getPos())
ls.drawTo(self.getPos() + self.getVel())
node = ls.create()
self.velocityLineNP = self.base.render.attachNewNode(node)
def _drawForceLine(self):
self.forceLineNP.removeNode()
ls = LineSegs()
# ls.setThickness(1)
ls.setColor(0.0, 1.0, 0.0, 1.0)
ls.moveTo(self.getPos())
ls.drawTo(self.getPos() + self.rigidBody.getTotalForce() * 0.2)
node = ls.create()
self.forceLineNP = self.base.render.attachNewNode(node)
def plot_zero_lines(self):
plot_zero = LineSegs()
plot_zero.setThickness(2.0)
plot_zero.setColor(Vec4(1, 0, 1, 1))
plot_zero.moveTo(-1, 0, self.x_mag)
plot_zero.drawTo(1, 0, self.x_mag)
plot_zero.moveTo(-1, 0, self.y_mag)
plot_zero.drawTo(1, 0, self.y_mag)
base.render2d.attach_new_node(plot_zero.create(True))
def draw_edge(self,e,e_color):
line_drawer = LineSegs('line_drawer')
line_drawer.setColor(e_color)
line_drawer.setThickness(1.5)
line_drawer.moveTo(e.v1.pos)
line_drawer.drawTo(e.v2.pos)
edge_node = line_drawer.create()
rendered_edge = self.render_root.attachNewNode(edge_node)
self.render_nodes['edge_'+str(e.ID)] = rendered_edge
def draw(self, start, end):
if self.car.fsm.getCurrentOrNextState() != 'Results':
if self.car.name == game.player_car.name:
segs = LineSegs()
segs.set_color(*self.color)
segs.moveTo(start)
segs.drawTo(end)
segs_node = segs.create()
self.gnd_lines += [render.attachNewNode(segs_node)]
def drawLineSeg(self, loader, parent, start, end):
lines = LineSegs()
lines.setThickness(5.0)
lines.setColor(VBase4(1, 0.5, 0.5, 1.0))
lines.moveTo(start)
lines.drawTo(end)
np = parent.attachNewNode(lines.create())
np.setDepthWrite(True)
np.setDepthTest(True)
def fire_laser(self, panda3dworld, entity_id):
now = globalClock.getRealTime()
if now - self.last_time_laser_fired < self.laser_reload_time:
if defines.ENTITIES[entity_id]["CATEGORY"] == "ship":
panda3dworld.keys["fire"] = 0
elif defines.ENTITIES[entity_id]["CATEGORY"] == "ship2":
panda3dworld.keys["p2fire"] = 0
else:
self.last_time_laser_fired = now
pos = defines.ENTITIES[entity_id]["NODE"].getPos()
angle = 360 - defines.ENTITIES[entity_id]["NODE"].getR()
# print angle
start_pos_x = pos.x + 0.5 * cos(angle * pi / 180)
start_pos_y = pos.z + 0.5 * sin(angle * pi / 180)
pos_x = pos.x + 10 * cos(angle * pi / 180)
pos_y = pos.z + 10 * sin(angle * pi / 180)
callback = test_laser_collision(start_pos_x, start_pos_y, pos_x, pos_y)
if callback.hit:
pos_x = callback.point.x
pos_y = callback.point.y
for contact_id, entity in defines.ENTITIES.items():
if entity["BODY"].fixtures[0] == callback.fixture:
if (
entity["CATEGORY"] == "ship"
or entity["CATEGORY"] == "ship2"
or entity["CATEGORY"] == "asteroid"
):
entity["SHIELD"] -= 10
elif entity["CATEGORY"] == "bullet":
defines.ENTITIES[contact_id]["NODE"].removeNode()
defines.ENTITIES[contact_id]["PHYSIC_NODE"].removeNode()
defines.world.DestroyBody(defines.ENTITIES[contact_id]["BODY"])
del defines.ENTITIES[contact_id]
ls = LineSegs("lines")
ls.setColor(1, 1, 1, 1)
ls.drawTo(start_pos_x, 55, start_pos_y)
ls.drawTo(pos_x, 55, pos_y)
laser = ls.create(False)
laserPath = render.attachNewNode(laser)
laserPath.setBin("unsorted", 0)
laserPath.setDepthTest(False)
sound = base.loader.loadSfx("sounds/laser.ogg")
sound.setVolume(0.2)
sound.play()
taskMgr.doMethodLater(0.05, remove_laser_task, "remove laser", extraArgs=[laserPath], appendTask=True)
defines.ENTITIES[entity_id]["ENERGY"] -= 5
if defines.ENTITIES[entity_id]["CATEGORY"] == "ship":
panda3dworld.keys["fire"] = 0
elif defines.ENTITIES[entity_id]["CATEGORY"] == "ship2":
panda3dworld.keys["p2fire"] = 0
def plot_border(self):
border = LineSegs()
border.setThickness(2.0)
corner = self.win_size/100 * 5/6
#print('corner', corner)
border.move_to(corner, 25, corner)
border.draw_to(corner, 25, -corner)
border.draw_to(-corner, 25, -corner)
border.draw_to(-corner, 25, corner)
border.draw_to(corner, 25, corner)
self.base.render.attach_new_node(border.create(True))
def create_lines(joints, color, thickness=5.0):
for node, parent in joints:
if parent is not None:
lines = LineSegs()
lines.setThickness(thickness)
lines.setColor(color)
lines.moveTo(0, 0, 0)
lines.drawTo(node.getPos(parent))
np = parent.attachNewNode(lines.create())
np.setDepthWrite(True)
np.setDepthTest(True)
def draw_cross(self, deg_per_pixel):
cross = LineSegs()
cross.setThickness(2.0)
# cross hair is 1/2 degree visual angle,
# so go 1/4 on each side
dist_from_center = 0.25 / deg_per_pixel
cross.moveTo(0 + dist_from_center, 55, 0)
cross.drawTo(0 - dist_from_center, 55, 0)
cross.moveTo(0, 55, 0 - dist_from_center)
cross.drawTo(0, 55, 0 + dist_from_center)
self.x_node = self.base.render.attachNewNode(cross.create(True))
self.x_node.hide()
def plot_match_square(self, corners):
print 'plot match square'
print corners
match = LineSegs()
match.setThickness(1.5)
match.setColor(0, 0, 0)
match.move_to(corners[0][0], -5, corners[1][0])
match.draw_to(corners[0][1], -5, corners[1][0])
match.draw_to(corners[0][1], -5, corners[1][1])
match.draw_to(corners[0][0], -5, corners[1][1])
match.draw_to(corners[0][0], -5, corners[1][0])
# print self.render2d
self.match_square = self.render2d.attach_new_node(match.create())
def frame_loop(self, task):
dt = task.time - task.last
task.last = task.time
plot_x = LineSegs()
plot_x.setThickness(2.0)
plot_x.setColor(Vec4(1, 1, 0, 1))
plot_x.moveTo(self.time, 55, self.old_x)
plot_y = LineSegs()
plot_y.setThickness(2.0)
plot_y.moveTo(self.time, 55, self.old_y)
self.time += dt
plot_x.drawTo(self.time, 55, self.x_mag)
plot_y.drawTo(self.time, 55, self.y_mag)
self.old_x = self.x_mag
self.old_y = self.y_mag
node = render.attachNewNode(plot_x.create())
self.plot.append(node)
node = render.attachNewNode(plot_y.create())
self.plot.append(node)
if self.time > 20:
self.clear_plot()
return task.cont
def draw(self, subdiv = 1000):
""" Draws a quick and cheesy visualization of the Mopath using
LineSegs. Returns the NodePath representing the drawing. """
ls = LineSegs('mopath')
p = Point3()
for ti in range(subdiv):
t = float(ti) / float(subdiv) * self.maxT
tp = self.calcTime(t)
self.xyzNurbsCurve.getPoint(tp, p)
ls.drawTo(p)
return NodePath(ls.create())
def __init__(self):
BareBonesEditor.__init__(self)
camera.setPos( 0.0, 0.0, 50.0)
camera.lookAt(0)
# hole1 = HorseShoeCentered()
# hole2 = SquareOffCenter()
# holes = []
# holes.append(hole1)
# holes.append(hole2)
#
# map10 = SquareMap10x10()
# mapWholes = []
# mapWholes.append(map10)
# mapWholes.append(holes)
# for i in mapWholes:
# print "mapWholes", i
#
# mesh_trilator = makeTriMesh(mapWholes[0], mapWholes[1]) # , holes) ############
mapThrs = TheirMap()
# for i in mapThrs:
# print "mapThrs", i
mesh_trilator = makeTriMesh(mapThrs[0], mapThrs[1]) # , holes) ###########
aLst = AdjacencyList(mesh_trilator[1])
# for i in aLst.aLst:
# print i
indsNP = drawInds(aLst.adjLst) # put text on each triangle
indsNP.setPos(0, 0, .2)
indsNP.setColor(0, 1, 1, 1)
mapNP = render.attachNewNode(mesh_trilator[0])
wireNP = render.attachNewNode('wire')
wireNP.setPos(0, 0, .1)
wireNP.setColor(1, 0, 0, 1)
wireNP.setRenderMode(RenderModeAttrib.MWireframe, .5, 0)
mapNP.instanceTo(wireNP)
# aStar = TriangulationAStar(aLst.adjLst, Point3(-11, -11, 0), Point3(11, 11, 0))aLst.adjLst[11].getCenter()
aStar = TriangulationAStarR(aLst.adjLst, Point3(-11, 11, 0), aLst.adjLst[17].getCenter(), radius=.55)
path = aStar.AStar()
print "\n\nEND PATH\n", path
# https://www.panda3d.org/manual/index.php?title=Putting_your_new_geometry_in_the_scene_graph&diff=prev&oldid=6303
linesegs = LineSegs("lines")
linesegs.setColor(0, 0, 1, 1)
linesegs.setThickness(5)
for p in path:
linesegs.drawTo(p)
node = linesegs.create(False)
nodePath = render.attachNewNode(node)
nodePath.setZ(.15)
def line_small_lakes(self):
for l in range(len(small_lake_lines)):
line = LineSegs()
line.setColor(0,0,0, 1)
line.setThickness(2)
for n in range(len(small_lake_lines[l])):
x = (small_lake_nodes[small_lake_lines[l][n]]["x"]-map_center[0])*amplification
y = (small_lake_nodes[small_lake_lines[l][n]]["y"]-map_center[1])*amplification
if n == 0:
line.moveTo(x,y,0)
else:
line.drawTo(x,y,0)
line_node = line.create()
node_path = NodePath(line_node)
node_path.reparentTo(render)
def __make_border__(cls, parent, thickness, color, l, r , b, t):
moveto_drawto = (
((l,0,t), (l,0,b)),
((r,0,t), (r,0,b)),
((l,0,b), (r,0,b)),
((l,0,t), (r,0,t)),
)
for moveto, drawto in moveto_drawto:
Border = LineSegs()
Border.setThickness(thickness)
Border.setColor(*color)
Border.moveTo(*moveto)
Border.drawTo(*drawto)
b = parent.attachNewNode(Border.create())
b.setBin(*cls.DRAW_ORDER['border'])
def line_border(self):
line = LineSegs()
line.setColor(0,0,0, 1)
line.setThickness(5)
x1 = (175.152-map_center[0])*amplification
x2 = (177.358-map_center[0])*amplification
y1 = (-38.808-map_center[1])*amplification
y2 = (-37.462-map_center[1])*amplification
line.moveTo(x1,y1,0)
line.drawTo(x1,y2,0)
line.drawTo(x2,y2,0)
line.drawTo(x2,y1,0)
line.drawTo(x1,y1,0)
line_node = line.create()
node_path = NodePath(line_node)
node_path.reparentTo(render)
def selection_ring_create(self, segments = 16,size = 1.0):
ls = LineSegs()
ls.setThickness(2)
ls.setColor(0.8,0.8,0.8)
radians = deg2Rad(360)
for i in range(segments+1):
a = radians * i / segments
y = math.sin(a)*size
x = math.cos(a)*size
ls.drawTo(x, y, 0.2)
node = ls.create()
return NodePath(node)
def _createDebugLine(self, points, connectToEnd=False):
""" Helper for visualizing the light bounds.
Draws a line trough all points. When connectToEnd is true,
the last point will get connected to the first point. """
segs = LineSegs()
segs.setThickness(1.0)
segs.setColor(Vec4(1, 1, 0, 1))
segs.moveTo(points[0])
for point in points[1:]:
segs.drawTo(point)
if connectToEnd:
segs.drawTo(points[0])
return NodePath(segs.create())
def draw_floor_plane(self,size,granularity):
line_drawer = LineSegs('grid_line_drawer')
line_drawer.setColor(0.0,0.0,0.0,1.0)
line_drawer.setThickness(1.0)
for i in range(-size,size+1,granularity):
line_drawer.moveTo(Vec3(float(i),float(-size),0.0))
line_drawer.drawTo(Vec3(float(i),float(size),0.0))
for i in range(-size,size+1,granularity):
line_drawer.moveTo(Vec3(float(-size),float(i),0.0))
line_drawer.drawTo(Vec3(float(size),float(i),0.0))
edge_node = line_drawer.create()
rendered_edges = render.attachNewNode(edge_node)
rendered_edges.setTransparency(TransparencyAttrib.MAlpha)
rendered_edges.setAlphaScale(0.5)
return 0
def walkJointHierarchy(self, actor, part, parentNode = None, indent = ""):
if isinstance(part, CharacterJoint):
np = actor.exposeJoint(None, 'modelRoot', part.getName())
if parentNode and parentNode.getName() != "root":
lines = LineSegs()
lines.setThickness(3.0)
lines.setColor(random.random(), random.random(), random.random())
lines.moveTo(0, 0, 0)
lines.drawTo(np.getPos(parentNode))
lnp = parentNode.attachNewNode(lines.create())
lnp.setBin("fixed", 40)
lnp.setDepthWrite(False)
lnp.setDepthTest(False)
parentNode = np
for child in part.getChildren():
self.walkJointHierarchy(actor, child, parentNode, indent + " ")
def draw_path(self, current_position, path):
from panda3d.core import LineSegs, Vec4, Vec3
path = [Vec3(*v) for v in path]
segments = LineSegs()
segments.set_thickness(2.0)
segments.set_color((1, 1, 0, 1))
segments.move_to(current_position)
for point in path:
segments.draw_to(point)
if self._path_node:
self._path_node.remove_node()
node = segments.create()
self._path_node = render.attach_new_node(node)
self._replan_timer = Timer(1.5)
self._replan_timer.on_target = self._replan
def task_mouse_place(self,task):
if base.mouseWatcherNode.isButtonDown(MouseButton.one()):
self.placing_object = True
self.place_pos = (self.anchor_x,self.anchor_y)
self.line_dir.remove()
ls = LineSegs()
ls.move_to(self.anchor_x,self.anchor_y,1)
ls.draw_to(self.model.getX(),self.model.getY(),1)
node = ls.create()
angle1 = math.atan2(self.anchor_y - self.anchor_y,self.anchor_x - self.anchor_x+50)
angle2 = math.atan2(self.anchor_y - self.model.getY(),self.anchor_x - self.model.getY());
final_angle = angle1-angle2;
self.model.setHpr(final_angle,0,0)
self.line_dir = NodePath(node)
self.line_dir.reparentTo(render)
return task.again
else:
self.line_dir.hide()
taskMgr.add(self.task_mouse_press_check, "checkMousePress")
return task.done
def update_avt_p(self, t_time):
avt = LineSegs()
avt.setThickness(5)
avt.setColor(self.avatar_color[0], self.avatar_color[1], self.avatar_color[2])
group_avatar = []
while self.avatar_pt[-1] < t_time:
group_avatar.append(self.avatar_pos.pop())
# print points
self.avatar_pt.pop()
if not self.avatar_pt:
break
# print('positions', group_avatar)
if group_avatar:
avt.moveTo(self.last_avt[0], self.drawing_layer, self.last_avt[1])
self.last_avt = [i * self.scale_factor for i in group_avatar[0]]
for i in group_avatar:
# print(i[0], i[1], i[2])
pos = [j * self.scale_factor for j in i]
avt.drawTo(pos[0], self.drawing_layer, pos[1])
self.avatar_node.append(self.base.render.attachNewNode(avt.create()))
def show_window(self):
# draw line around target representing how close the subject has to be looking to get reward
# print('show window around square', square_pos)
photo_window = LineSegs()
photo_window.setThickness(2.0)
photo_window.setColor(1, 0, 0, 1)
photo_window.moveTo(self.tolerance[0], 55, self.tolerance[1])
# print photo_window.getCurrentPosition()
# photo_window.drawTo(self.tolerance[0], 55, -self.tolerance[1] - 100)
photo_window.drawTo(self.tolerance[0], 55, -self.tolerance[1])
# print photo_window.getCurrentPosition()
# photo_window.drawTo(-self.tolerance[0], 55, -self.tolerance[1] - 100)
photo_window.drawTo(-self.tolerance[0], 55, -self.tolerance[1])
# print photo_window.getCurrentPosition()
photo_window.drawTo(-self.tolerance[0], 55, self.tolerance[1])
# print photo_window.getCurrentPosition()
photo_window.drawTo(self.tolerance[0], 55, self.tolerance[1])
# print photo_window.getCurrentPosition()
node = self.base.render.attachNewNode(photo_window.create(True))
node.show(BitMask32.bit(0))
node.hide(BitMask32.bit(1))
self.photo_window.append(node)
def __init__(self):
ShowBase.__init__(self)
#BareBonesEditor.__init__(self)
PanditorDisableMouseFunc()
camera.setPos( 0.0, 0.0, 50.0)
camera.lookAt(0.0)
PanditorEnableMouseFunc()
# mapThrs = TheirMap()
mapThrs = CrossWithHole()
print mapThrs[1]
mesh_trilator = makeTriMesh(mapThrs[0], mapThrs[1]) # , holes) ###########
aLst = AdjacencyList(mesh_trilator[1])
indsNP = drawInds(aLst.adjLst) # put text on each triangle
indsNP.setPos(0.0, 0.0, .2)
indsNP.setColor(0.0, 1.0, 1.0, 1.0)
mapNP = render.attachNewNode(mesh_trilator[0])
wireNP = render.attachNewNode('wire')
wireNP.setPos(0.0, 0.0, .1)
wireNP.setColor(1.0, 0.0, 0.0, 1)
wireNP.setRenderMode(RenderModeAttrib.MWireframe, .5, 0)
mapNP.instanceTo(wireNP)
aStar = TriangulationAStarR(aLst.adjLst, Point3(0.0, -5.0, 0.0), Point3(0.0, 5.5, 0.0), radius=0.0)
# aStar = TriangulationAStarR(aLst.adjLst, Point3(aLst.adjLst[17].getCenter() + Point3(5, 0, 0)), Point3(0, 11, 0), radius=.55)
# aStar = TriangulationAStarR(aLst.adjLst, Point3(-5, 4, 0), Point3(aLst.adjLst[17].getCenter() + Point3(5, 0, 0)), radius=.55)
path = aStar.AStar()
print "\n\nEND PATH\n", path
# https://www.panda3d.org/manual/index.php?title=Putting_your_new_geometry_in_the_scene_graph&diff=prev&oldid=6303
linesegs = LineSegs("lines")
linesegs.setColor(0, 0, 1, 1)
linesegs.setThickness(5)
for p in path:
linesegs.drawTo(p)
node = linesegs.create(False)
nodePath = render.attachNewNode(node)
nodePath.setZ(.15)
