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 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 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 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)