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 __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 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 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, root: NodePath) -> None:
self.__roots = [root]
self.__draw_nps = []
self.__circles = []
self.__thicknesses = [2.5]
self.__line_segs = LineSegs()
self.__line_segs.set_thickness(2.5)
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 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 __init__(self, parentNodePath):
self.mainNodePath = NodePath("Lines")
self.mainNodePath.reparentTo(parentNodePath)
self.lineSegs = LineSegs()
self.lineSegs.setThickness(1)
self.lineNodePaths = []
self.points = []
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 _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 _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 _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 _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 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 __init__(self):
self.cardmaker = CardMaker("card")
self.linesegs = LineSegs("line")
self.pointmaker = PointMaker("point")
self.shapes = {}
self.make_lod()
self.pointmaker.add()
self.shapes["Point"] = self.pointmaker.wrap_up()
self.pointmaker.new()
def draw(self, subdiv=1000):
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, manager, number):
"""
Initialises the drone as a bullet and panda object.
:param manager: The drone manager creating this very drone.
"""
self.manager = manager # Drone manager handling this drone
self.base = manager.base # Simulation
self.crazyflie = None # object of real drone, if connected to one
self.debug = False # If debugging info should be given
self.in_flight = False # If currently in flight
self.number = number # Number of drone in list
# Every drone has its own vector to follow if an avoidance manouver has to be done
self.avoidance_vector = LVector3f(random.uniform(-1, 1),
random.uniform(-1, 1),
random.uniform(-1, 1)).normalize()
# Create bullet rigid body for drone
drone_collision_shape = BulletSphereShape(self.COLLISION_SPHERE_RADIUS)
self.drone_node_bullet = BulletRigidBodyNode("RigidSphere")
self.drone_node_bullet.addShape(drone_collision_shape)
self.drone_node_bullet.setMass(self.RIGID_BODY_MASS)
# Set some values for the physics object
self.drone_node_bullet.setLinearSleepThreshold(
self.LINEAR_SLEEP_THRESHOLD)
self.drone_node_bullet.setFriction(self.FRICTION)
self.drone_node_bullet.setLinearDamping(self.LINEAR_DAMPING)
# Attach to the simulation
self.drone_node_panda = self.base.render.attachNewNode(
self.drone_node_bullet)
# ...and physics engine
self.base.world.attachRigidBody(self.drone_node_bullet)
# Add a model to the drone to be actually seen in the simulation
drone_model = self.base.loader.loadModel(
"models/drones/drone_florian.egg")
drone_model.setScale(0.2)
drone_model.reparentTo(self.drone_node_panda)
# Set the position and target position to their default (origin)
default_position = LPoint3f(0, 0, 0)
self.drone_node_panda.setPos(default_position)
self.target_position = default_position
# Create a line renderer to draw a line from center to target point
self.line_creator = LineSegs()
# Then draw a default line so that the update function works as expected (with the removal)
self.target_line_node = self.base.render.attachNewNode(
self.line_creator.create(False))
# Create node for text
self.drone_text_node_panda = None
def render_sight(self):
ls = procedural_sight(LineSegs(), True, False)
ls = procedural_sight(ls, False, False)
ls.setThickness(3)
self.sight_clear_node = ls.create()
ls = procedural_sight(LineSegs(), True, True)
ls = procedural_sight(ls, False, True)
ls.setThickness(3)
self.sight_engaged_node = ls.create()
self.sight_clear_np = NodePath(self.sight_clear_node)
self.sight_clear_np.setColorScale(0, 0.5, 0, 1.0)
self.sight_engaged_np = NodePath(self.sight_engaged_node)
self.sight_engaged_np.setColorScale(GG)
self.sight_clear_np.reparentTo(render2d)
self.sight_engaged_np.reparentTo(render2d)
self.sight_engaged_np.hide()
def draw_path(self,path):
if self.vis:
self.vis.removeNode()
l=LineSegs()
l.setColor(1,0,0,1)
l.setThickness(2)
l.moveTo(path[0])
for point in path:
l.drawTo(point)
self.vis=render.attachNewNode(l.create())
self.vis.setZ(0.5)
def drawHilbertCurve(pts): # 2n + c
for p in range(len(pts) - 1): # n
seg = LineSegs() # c
seg.setThickness(3) # c
seg.draw_to(pts[p][0], 0, pts[p][2]) # c
seg.draw_to(pts[p + 1][0], 0, pts[p + 1][2]) # c
node = seg.create() # c
nodes.append(node) # c
for node in nodes: # n
base.aspect2d.attach_new_node(node) # c
def __init__(self, widget, axis):
TransformWidgetAxis.__init__(self, widget, axis)
segs = LineSegs()
segs.setThickness(2)
vertices = LEUtils.circle(0, 0, 1, 64)
for i in range(len(vertices)):
x1, y1 = vertices[i]
x2, y2 = vertices[(i + 1) % len(vertices)]
segs.moveTo(x1, 0, y1)
segs.drawTo(x2, 0, y2)
self.axisCircle = self.attachNewNode(segs.create())
self.axisCircle.setAntialias(AntialiasAttrib.MLine)
def drawWheelBase(self):
wheelSegs = LineSegs("wheelBase")
wheelSegs.setThickness(5)
wheelSegs.moveTo(self.wheelFront + Vec3(0.0, 5.0, 1.44))
wheelSegs.drawTo(self.wheelFront + Vec3(0.0, -5.0, 1.44))
wheelSegs.moveTo(self.wheelBack + Vec3(0.0, 5.0, 1.44))
wheelSegs.drawTo(self.wheelBack + Vec3(0.0, -5.0, 1.44))
wheelNode = wheelSegs.create()
wheelNodePath = self.car.attachNewNode(wheelNode)
return wheelNodePath
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 __init__(self,
name: str = 'cube_mesh',
wireframe_thickness: float = 5) -> None:
self.name = name
self.__vertex_data_format = GeomVertexFormat.getV3n3()
self.__vertex_data = GeomVertexData(name, self.__vertex_data_format,
Geom.UHStatic)
self.geom = Geom(self.__vertex_data)
self.__triangles = GeomTriangles(Geom.UHStatic)
self.__triangle_data = self.__triangles.modifyVertices()
self.__vertex = GeomVertexWriter(self.__vertex_data, 'vertex')
self.__normal = GeomVertexWriter(self.__vertex_data, 'normal')
self.__face_count = 0
def add_face(face: Face) -> None:
self.__make_face(face)
self.__make_face(Face.LEFT)
self.__make_face(Face.RIGHT)
self.__make_face(Face.BACK)
self.__make_face(Face.FRONT)
self.__make_face(Face.BOTTOM)
self.__make_face(Face.TOP)
self.__triangles.close_primitive()
self.geom.add_primitive(self.__triangles)
def is_connected(x, y, z, x1, y1, z1):
return (abs(x - x1) == 1 and abs(y - y1) != 1 and abs(z - z1) != 1) or \
(abs(x - x1) != 1 and abs(y - y1) == 1 and abs(z - z1) != 1) or \
(abs(x - x1) != 1 and abs(y - y1) != 1 and abs(z - z1) == 1)
ls = LineSegs()
ls.set_thickness(wireframe_thickness)
arr_x = [0, 0, 0, 0, 1, 1, 1, 1]
arr_y = [0, 0, 1, 1, 1, 1, 0, 0]
arr_z = [0, -1, -1, 0, 0, -1, -1, 0]
for pos1 in range(len(arr_x) - 1):
for pos2 in range(pos1, len(arr_x)):
x = arr_x[pos1]
y = arr_y[pos1]
z = arr_z[pos1]
x1 = arr_x[pos2]
y1 = arr_y[pos2]
z1 = arr_z[pos2]
if (is_connected(x, y, z, x1, y1, z1)):
ls.move_to(x, y, z)
ls.draw_to(x1, y1, z1)
self.__wireframe_node = ls.create()
def redraw_wps(self):
if not hasattr(self.mediator, 'phys'): return # first frame, refactor
if not self.mediator.phys.waypoints: return
# it may be invoked on track's destruction
if self.wp_np: self.wp_np.remove_node()
segs = LineSegs()
for w_p in self.mediator.phys.waypoints:
for dest in w_p.prevs:
segs.moveTo(w_p.pos)
segs.drawTo(dest.pos)
segs_node = segs.create()
self.wp_np = render.attach_new_node(segs_node)
def createGrid(self):
segs = LineSegs()
segs.setThickness(4.0)
segs.setColor(Vec4(1, 1, 0, 0.3))
for i in xrange(self.level.maxX):
segs.moveTo(i + 1, 0, utils.GROUND_LEVEL)
segs.drawTo(i + 1, self.level.maxY, utils.GROUND_LEVEL + 0.02)
for j in xrange(self.level.maxY):
segs.moveTo(0, j + 1, utils.GROUND_LEVEL)
segs.drawTo(self.level.maxX, j + 1, utils.GROUND_LEVEL + 0.02)
self.grid = NodePath(segs.create())
self.grid.setTransparency(TransparencyAttrib.MAlpha)
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_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())
