def init(): global theMesh, theLight, theCamera, \ theScreen, resolution initializeVAO() glEnable(GL_CULL_FACE) glEnable(GL_DEPTH_TEST) # Add our object # LIGHT theLight = N.array((-0.577, 0.577, 0.577, 0.0),dtype=N.float32) # OBJECT phongshader = makeShader("phongshader.vert","phongshader.frag") verts, elements = readOBJ("suzanne.obj") suzanneVerts = getArrayBuffer(verts) suzanneElements = getElementBuffer(elements) suzanneNum = len(elements) theMesh = coloredMesh(N.array((1.0, 0.5, 1.0, 1.0), dtype=N.float32), suzanneVerts, suzanneElements, suzanneNum, phongshader) # CAMERA width,height = theScreen.get_size() aspectRatio = float(width)/float(height) near = 0.01 far = 100.0 lens = 4.0 # "longer" lenses mean more telephoto theCamera = Camera(lens, near, far, aspectRatio) theCamera.moveBack(6)
def init(): global theMeshes, theLight, theCamera, theScreen, theShader initializeVAO() glEnable(GL_CULL_FACE) glEnable(GL_DEPTH_TEST) # Add our objects # LIGHT theLight = N.array((0.577, 0.577, 0.577, 0.0),dtype=N.float32) # SHADER theShader = makeShader("flattextured.vert", "flattextured.frag") # OBJECT width, height, depth = 3,3,100 magFilter = GL_NEAREST theMeshes = [makeObjects(x,magFilter,width,height,depth, useAniso=y) for y in (False, True) for x in (GL_NEAREST, GL_LINEAR, GL_NEAREST_MIPMAP_NEAREST, GL_LINEAR_MIPMAP_NEAREST, GL_NEAREST_MIPMAP_LINEAR, GL_LINEAR_MIPMAP_LINEAR) ] # CAMERA width, height = theScreen.get_size() aspectRatio = float(width)/float(height) near = 0.01 far = 100.0 lens = 4.0 # "longer" lenses mean more telephoto theCamera = Camera(lens, near, far, aspectRatio) theCamera.moveBack(depth*0.5)
class Level: def __init__(self, fp, engine): self.player = None self.game_objects = [] self.updatable_objects = [] self.platforms = pygame.sprite.OrderedUpdates() width, height = [int(i) for i in fp.readline().strip().split()] objs = gol.load_level(fp.readline().strip()) for obj in objs: obj.setup(self) self.game_objects.extend(objs) for line in fp: line = line.strip() obj = gol.load(line) obj.setup(self) if obj.is_updatable(): self.updatable_objects.append(obj) self.game_objects.append(obj) self.camera = Camera(engine, self) self.updatable_objects.append(self.camera) def update(self, delta): for obj in self.updatable_objects: obj.update(delta) def draw(self, screen): self.camera.draw(screen)
def init(): global theMesh, theLight, theCamera, theScreen initializeVAO() glEnable(GL_CULL_FACE) glEnable(GL_DEPTH_TEST) # Add our objects # LIGHT theLight = N.array((0.577, 0.577, 0.577, 0.0),dtype=N.float32) # OBJECT verts,elements = torus(10.0, 4.0, 128, 32) theMesh = proceduralMesh(N.array((1.0,0.5,0.25,1.0),dtype=N.float32), 100.0, getArrayBuffer(verts), getElementBuffer(elements), len(elements), makeShader("worley.vert", "worley.frag") ) # CAMERA width, height = theScreen.get_size() aspectRatio = float(width)/float(height) near = 0.01 far = 100.0 lens = 4.0 # "longer" lenses mean more telephoto theCamera = Camera(lens, near, far, aspectRatio) theCamera.moveBack(50)
def prob3(filename="StudentEarthData.npz"): """Reconstruct single-pixel camera color data in StudentEarthData.npz using 450, 650, and 850 measurements. Seed NumPy's random number generator with np.random.seed(1337) before each measurement to obtain consistent results. Return a list containing the Euclidean distance between each reconstruction and the color array. """ measures = [250, 400, 550] dist = [] error = [] earth = np.load(filename) faces, vert, C, V = earth['faces'],earth['vertices'], earth['C'], earth['V'] camera = Camera(faces, vert, C) for m in measures: camera.add_lots_pic(m) A, B = camera.returnData() for col in xrange(B.shape[1]): b_hat = B[:,col] A_hat = np.dot(A, V) c = l1Min(A_hat, b_hat) c_hat = np.dot(V, c) if col == 0: c_stack = c_hat else: c_stack = np.column_stack((c_stack, c_hat)) visualizeEarth(faces, vert, c_stack.clip(0,1)) error.append(la.norm(c_stack - C)) visualizeEarth(faces, vert, C) return error
def run(self): print "server running..." s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.bind(self.addr) s.listen(True) conn, addr = s.accept() print "connect succeed." cap = Camera(0, [480, 320], 60) ret, frame = cap.cam.read() encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), 90] while ret: result, imgencode = cv2.imencode(".jpg", frame, encode_param) data = numpy.array(imgencode) string_data = data.tostring() conn.send(str(len(string_data)).ljust(16)) conn.send(string_data) ret, frame = cap.cam.read() if cv2.waitKey(1) & 0xFF == ord("q"): break s.close() cap.release()
def main(): screen = pygame.display.set_mode((WIDTH, HEIGHT)) pygame.display.set_caption("Engine RPG") clock = pygame.time.Clock() #rejilla = load_image('resources/graphics/rejilla.png', True) map_loaded = Map("pruebas.tmx") heroe = Actor(map_loaded) camara = Camera(map_loaded, heroe) inp = Input() while True: time = clock.tick(40) inp.update() salir(inp.get_key_list()) id = heroe.mover(map_loaded, inp) heroe.update(id) camara.update(screen, map_loaded, heroe) camara.show_fps(screen, clock.get_fps()) #screen.blit(rejilla, (0, 0)) pygame.display.flip() return 0
def main(): nx = 200 ny = 100 ns = 100 print ("P3\n",nx," ",ny,"\n255") world = random_scene() lookfrom = Vec3(15,2,5) lookat = Vec3(0,0,0) dist_to_focus = (lookfrom-lookat).length() aperture = 0.125 cam = Camera(lookfrom,lookat,Vec3(0,1,0),20,nx/ny,aperture,dist_to_focus) for j in reversed(range(ny)): for i in range(nx): col = Vec3(0,0,0) for s in range(ns): u = (i+random())/nx v = (j+random())/ny r = cam.get_ray(u,v) p = r.point_at_parameter(2.0) col += color(r,world,0) col /= ns col = Vec3(sqrt(col[0]),sqrt(col[1]),sqrt(col[2])) ir = int(255.99*col[0]) ig = int(255.99*col[1]) ib = int(255.99*col[2]) print (ir," ",ig," ",ib)
def init(): global theMesh, theLight, theCamera, theScreen initializeVAO() glEnable(GL_CULL_FACE) glEnable(GL_DEPTH_TEST) # Add our objects # LIGHT theLight = N.array((0.577, 0.577, 0.577, 0.0),dtype=N.float32) # OBJECT verts, elements = readOBJ("suzanne.obj") print verts[0:4] arrayBuffer = getArrayBuffer(verts) elementBuffer = getElementBuffer(elements) numElements = len(elements) phongShader = makeShader("phongshader.vert", "phongshader.frag") theMesh = coloredMesh(N.array((0,1,1,1),dtype=N.float32), arrayBuffer, elementBuffer, numElements, phongShader ) # CAMERA width, height = theScreen.get_size() aspectRatio = float(width)/float(height) near = 0.01 far = 100.0 lens = 4.0 # "longer" lenses mean more telephoto theCamera = Camera(lens, near, far, aspectRatio) theCamera.moveBack(3)
def run(): WIDTH = 640 HEIGHT = 480 running = True clock = pygame.time.Clock() screen = pygame.display.set_mode( (WIDTH,HEIGHT) ) w = World() c = Camera(screen, (0,0), 3.0, HEIGHT) c.set_world(w) b = BallEntity((100,100), {'radius': 10, 'density': 10, 'restitution': 0.1, 'static': True, 'line-width': 5}) w.add_entity(b) b2 = BallEntity((100,60), {'radius': 20, 'density': 100, 'restitution': 1.0}) w.add_entity(b2) b2.body.SetLinearVelocity((0,40)) base = BoxEntity((20,20), {'width': 100, 'height': 10})#, 'static': True}) w.add_entity(base) while running: screen.fill((255,255,255)) c.draw() pygame.display.flip() w.step(dt) clock.tick(hz)
class MainGameState(object): def __init__(self): self.background = backgrounds.Cave() self.world = World() self.player = Player(self.world, (-100, 52.4)) self.camera = Camera((0, 100.0), tracking=self.player) def update(self, delta): for event in pygame.event.get(): if event.type == QUIT: sys.exit(0) elif event.type == KEYDOWN: if event.key == K_ESCAPE: raise states.StateChange(states.PauseMenuState(self)) self.world.center = self.player.pos self.background.update(delta) self.world.update(delta) self.player.update(delta) self.camera.update(delta) def render(self, screen): self.background.render(screen, self.camera) self.world.render(screen, self.camera) self.player.render(screen, self.camera)
def main(): nx = 200 ny = 100 ns = 100 print("P3\n",nx," ",ny,"\n255") l = [] l.append(Sphere(Vec3(0,0,-1),0.5,Lambertian(Vec3(0.8,0.3,0.3)))) l.append(Sphere(Vec3(0,-100.5,-1),100,Lambertian(Vec3(0.8,0.8,0.0)))) l.append(Sphere(Vec3(1,0,-1),0.5,Metal(Vec3(0.8,0.6,0.2),1.0))) l.append(Sphere(Vec3(-1,0,-1),0.5,Metal(Vec3(0.8,0.8,0.8),0.3))) world = HitableList(l) cam = Camera() for j in reversed(range(ny)): for i in range(nx): col = Vec3(0,0,0) for s in range(ns): u = (i+random())/nx v = (j+random())/ny r = cam.get_ray(u,v) p = r.point_at_parameter(2.0) col += color(r,world,0) col /= ns col = Vec3(sqrt(col[0]),sqrt(col[1]),sqrt(col[2])) ir = int(255.99*col[0]) ig = int(255.99*col[1]) ib = int(255.99*col[2]) print(ir," ",ig," ",ib)
def load_from_file(uri): """Coordinates instantiation of various classes. Ensures that related Photograph, Camera, CameraView, and Label are all instantiated together. """ photo = Photograph(uri) photo.read() Widgets.empty_camera_list.hide() camera_id, camera_name = Camera.generate_id(photo.camera_info) camera = Camera(camera_id) camera.add_photo(photo) CameraView(camera, camera_name) Label(photo) # If the user has selected the lookup method, then the timestamp # was probably calculated incorrectly the first time (before the # timezone was discovered). So call it again to get the correct value. if camera.timezone_method == 'lookup': photo.calculate_timestamp(camera.offset) Widgets.button_sensitivity() return photo
def __init__(self, *args, **kwargs): """Takes arguments of serial port number (0-n) and camera number on daisy chain (1-9), a daisychain of 0 will send commands to all cameras on the port.""" Camera.__init__(self, *args, **kwargs) # Some global values for the rs232 commands self._header = struct.pack('B',0xFF) self._footer = struct.pack('B',0xEF) self.sport = serial.Serial(self.port, # port numbering starts at 0 baudrate = 9600, # bytesize = serial.EIGHTBITS, # parity = serial.PARITY_NONE, # stopbits = serial.STOPBITS_ONE, # timeout = 0.1, # xonxoff = 0, # disablesoftware flow control rtscts = 1) # enable hardware flow control self.port = self._toParm(self.port,1) self.daisychain = self._toParm(int(self.daisychain),1) self._dev = struct.pack('2B', 0x30, 0x30+int(self.daisychain,16)) self.movement_quanta=10 if self.daisychain == "1": # if we're the first camera on the chain: self._startup() # comment out for speedier testing
class Scene(object): def __init__(self): self.camera = Camera() self.entities = [] def render(self): """Draw the scene.""" glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT) glLoadIdentity() # Adjust the scene to match current camera settings. self.camera.adjust() # Set up lighting. light_diffuse = (1, 1, 1, 1) light_position = (0, 5, 0, 1) glLightfv(GL_LIGHT0, GL_AMBIENT, light_diffuse) glLightfv(GL_LIGHT0, GL_POSITION, light_position) glEnable(GL_LIGHTING) glEnable(GL_LIGHT0) for entity in self.entities: entity.render() glFlush() def add(self, entity): """Add a new entity to scene.""" self.entities.append(entity)
def video_registration_fixed(): template = cv2.imread('template.jpg') src = template.copy() markers, bw = find_markers(template) if len(markers) is not 4: print 'cannot find 4 markers in template image' return # open camera cam = Camera(0) if not cam.is_open(): return cv2.namedWindow('demo', cv2.CV_WINDOW_AUTOSIZE) while True: dst = cam.read() merged = img_registration(src, dst, markers) cv2.imshow('demo', merged) key = cv2.waitKey(20) if key == 27: break cv2.destroyAllWindows()
class Level(GameState): def __init__(self,game_ref,delegator_ref): super(Level,self).__init__(game_ref,delegator_ref) self.camera = Camera() self.GAME_STATE = 1 # Refs to GAME_STATES in GameDataIFace self.level_to_load = 1 self.load(1) def load(self,level_to_load): self.tile_loader = TileLoader(level_to_load) # Returns a reference to a display surface self.set_internal_state(1) # Level has finished loading self.camera.register_map_surface(self.tile_loader.get_map_surface(),self.tile_loader.get_map_surface_dims()) def tick(self,game_data_object): self.canvas.fill((0, 255, 0)) if self.internal_state == 0: self.canvas.fill((0, 255, 0)) elif self.internal_state == 1: self.canvas.fill((0, 0, 255)) self.canvas.blit(self.camera.calc_view(),(0,0)) print game_data_object elif self.internal_state == 2: pass else: raise Exception("Unhandled internal_state")
def startMonitor(): camera = Camera() actionDict = ActionDict(camera) config = Config( actionDict, getButtons().keys(), getClickTypes()) camera.setConfig(config) config.checkConfigFile() app = QApplication([]) camera.initCamera() keys = QmKeys() buttonTimers = dict() for b in getButtons().values(): buttonTimers[b] = ClickTimer(b, config) keys.keyEvent.connect(lambda k, s: (k in buttonTimers and buttonTimers[k].keyEvent(s))) config.dbusButton.setHandler( lambda button: dbusBtnClicked(config, button)) config.dbusButton.connectButtonDbus() config.proximityButton.setHandler( lambda state: prxBtnClicked(config, state)) config.proximityButton.connectProximityButton() app.exec_()
def main(arg): print BANNER model_file_pathname = arg image_file_pathname = model_file_pathname + ".ppm" model_file = open(model_file_pathname, "r") if model_file.next().strip() != MODEL_FORMAT_ID: raise "invalid model file" for line in model_file: if not line.isspace(): iterations = int(line) break image = Image(model_file) camera = Camera(model_file) scene = Scene(model_file, camera.view_position) model_file.close() last_time = time() - (SAVE_PERIOD + 1) try: for frame_no in range(1, iterations + 1): camera.get_frame(scene, image) if SAVE_PERIOD < time() - last_time or frame_no == iterations: last_time = time() save_image(image_file_pathname, image, frame_no) stdout.write("\b" * ((int(log10(frame_no - 1)) if frame_no > 1 else -1) + 12) + "iteration: %u" % frame_no) stdout.flush() print "\nfinished" except KeyboardInterrupt: save_image(image_file_pathname, image, frame_no) print "\ninterupted"
def main(): """Run the ray trace.""" # nx = 1200 # ny = 800 nx = 100 ny = 100 ns = 10 print('P3\n%d %d 255' % (nx, ny)) world = random_scene() lookfrom = Vec3(13, 2, 3) lookat = Vec3(0, 0, 0) dist_to_focus = 10.0 aperture = 0.1 cam = Camera(lookfrom, lookat, Vec3(0,1,0), 20, float(nx)/float(ny), aperture, dist_to_focus) for j in range(ny-1, -1, -1): for i in range(nx): col = Vec3(0, 0, 0) for s in range(ns): u = float(i + random()) / float(nx) v = float(j + random()) / float(ny) r = cam.get_ray(u, v) p = r.point_at_parameter(2.0) col += color(r, world, 0) col /= float(ns) col = Vec3(sqrt(col.r), sqrt(col.g), sqrt(col.b)) ir = int(255.99*col.r) ig = int(255.99*col.g) ib = int(255.99*col.b) print('%d %d %d' % (ir, ig, ib))
def load_from_file(uri): """Determine the correct subclass to instantiate. Also time everything and report how long it took. Raises IOError if the file extension is unknown, or no track points were found. """ start_time = clock() try: gpx = globals()[uri[-3:].upper() + 'File'](uri) except KeyError: raise IOError Widgets.status_message(_('%d points loaded in %.2fs.') % (len(gpx.tracks), clock() - start_time), True) if len(gpx.tracks) < 2: return TrackFile.instances.add(gpx) MapView.emit('realize') MapView.set_zoom_level(MapView.get_max_zoom_level()) MapView.ensure_visible(TrackFile.get_bounding_box(), False) TrackFile.update_range() Camera.set_all_found_timezone(gpx.start.geotimezone)
class ViewController: def __init__(self): self.camera = Camera(position=Vector3(0,0,-3)) #self.camera = Camera(position=Vector3(0,0,0)) self.meshes = [] self.bored = False def reset_camera(self): self.camera.target_position.x = DEFAULT_CAMERA_POSITION.x self.camera.target_position.y = DEFAULT_CAMERA_POSITION.y self.camera.target_position.z = DEFAULT_CAMERA_POSITION.z self.camera.target_rotation.x = DEFAULT_CAMERA_ROTATION.x self.camera.target_rotation.y = DEFAULT_CAMERA_ROTATION.y self.camera.target_rotation.z = DEFAULT_CAMERA_ROTATION.z def rotate_camera_to(self, x, y): self.camera.rotate_to(x, y) def rotate_camera_by(self, x, y): self.camera.rotate_by(x, y) def zoom_camera_by(self, z): self.camera.zoom_by(z) def zoom_camera_to(self, z): self.camera.zoom_to(z) def step_camera_to_target(self): self.camera.step_to_target()
def video_feed(): global dataFeed if not dataFeed: # we have to create it during the call, otherwise the list that syncs between threads (cients) doesn't get synced correctly between threads (bummer). dataFeed = Camera() client = CameraClient() dataFeed.add_client(client) return Response(gen(client), # all video streams use the same camera object -> the same input stream. mimetype='multipart/x-mixed-replace; boundary=frame')
def __init__(self, name, measureUnit, measureIface, writerUnit = None): '''constructor ''' TotalStation.__init__(self, name, measureUnit, measureIface, writerUnit) Camera.__init__(self, name, measureUnit, measureIface, writerUnit) #StepperMotor.__init__(self, stepperMotorUnit, speed, halfSteps) self._affinParams = None
def __init__(self, ideal_grid, units_per_cell=10): self.gridworld = GridWorld(ideal_grid.width, ideal_grid.height, ideal_grid.gridsize) self.gridworld.set_ideal_grid(ideal_grid) self.printer = Printer(10, 10, 9, 1, self.gridworld, units_per_cell) #TODO: shouldn't be giving location values here when it's determined somewhere else. that smells a lot self.camera = Camera(self.gridworld.grid, self.printer, self.camera_size) self.ideal_grid = self.gridworld.ideal_grid self.ideal_camera = Camera(self.gridworld.ideal_grid, self.printer, self.camera_size) width = self.gridworld.width() * self.gridworld.gridsize() height = self.gridworld.height() * self.gridworld.gridsize()
def main(): #sys.argv=["C:\Users\Adil\Desktop\camera\main.py",'C:\Users\Adil\Desktop\img',"C:\Program Files (x86)\opencv\data\lbpcascades\lbpcascade_frontalface.xml"] #sys.argv=["","D:\utilisateurs\tlelepvr\Desktop", "D:\utilisateurs\tlelepvr\Downloads\opencv\sources\data\lbpcascades\lbpcascade_frontalface.xml"] sys.argv=["","../../../../test", "../../../../Downloads/opencv/sources/data/lbpcascades/lbpcascade_frontalface.xml"] imagePath=sys.argv[1] cascadePath=sys.argv[2] camera = Camera(imagePath, cascadePath) camera._runCaptureLoop()
class FadeOut(State): def __init__(self, window, *args, **kwargs): print "++++ new fade state" State.__init__(self, window, "fade", *args, **kwargs) self.old_state_batch = kwargs["old_state"] self.duration = kwargs["duration"] self.next_state = kwargs["next_state"] self.next_state_args = kwargs["next_state_args"] self.build_scene() self.alpha = 0.0 def build_scene(self): self.quad = batch.get_batch().add(4, GL_QUADS, GRP_BLEND_ONE_MINUS, ("v3f", fade_quad), ("c4f", fade_color * 4)) self.camera = Camera((3.8, -18.0, 1.0), (3.8, 0, 1.0)) self.attaboy = MsgQueue() def destroy_scene(self): pass def on_draw(self): set3D(self.window) self.window.clear() glLoadIdentity() self.camera.focus() batch.get_batch(self.old_state_batch).draw() batch.get_batch().draw() set2D(self.window) return pyglet.event.EVENT_HANDLED def on_key_press(self, k, args): if k == key.F11: if self.window.fullscreen: self.window.set_fullscreen(False) else: self.window.set_fullscreen(True) return pyglet.event.EVENT_HANDLED def on_lose_focus(self): pyglet.clock.unschedule(self.on_update) self.destroy_scene() return pyglet.event.EVENT_HANDLED def on_gain_focus(self): pyglet.clock.schedule_interval(self.on_update, 1.0 / 60.0) return pyglet.event.EVENT_HANDLED def on_update(self, dt): self.attaboy.update(dt) if self.alpha > 1: self.window.replace_state(self.next_state, **self.next_state_args) else: color = fade_color color[3] = self.alpha self.quad.colors = color * 4 self.alpha += self.duration * dt return pyglet.event.EVENT_HANDLED
def test_cells_in_view_independent_of_camera_size(self): local_camera = Camera(self.grid, self.printer, 4) self.printer.position = Vector(30, 30) self.assertEqual(local_camera.num_cells_in_view(Vector(1, 1)), 1) #two cell self.printer.position = Vector(30, 32) self.assertEqual(local_camera.num_cells_in_view(Vector(1, 1)), 2) #red cell self.printer.position = Vector(32, 32) self.assertEqual(local_camera.num_cells_in_view(Vector(1, 1)), 4)
class Camera_Dialog: def __init__(self, profile_dialog, resolution, got_photo_cb): self.cb = got_photo_cb self.dialog = gtk.Dialog('Camera', profile_dialog, gtk.DIALOG_DESTROY_WITH_PARENT | gtk.DIALOG_MODAL) self.dialog.set_has_separator(False) self.image = gtk.DrawingArea() self.image.set_size_request(resolution[0], resolution[1]) self.help_text = gtk.Label('Click to take picture') try: self.camera = Camera(resolution, self.image) except Camera_Exception: debug('profile dialog: Unable to initialize camera\n') self.camera = None self.help_text.set_label('No camera found') self.image_hbox = gtk.HBox() self.image_hbox.pack_start(gtk.HBox()) self.image_hbox.pack_start(self.image, False, False) self.image_hbox.pack_start(gtk.HBox()) if self.camera != None: self.dialog.vbox.pack_start(self.image_hbox) self.dialog.vbox.pack_start(self.help_text, False, True) self.close_button = gtk.Button('Close') self.dialog.vbox.pack_start(self.close_button, False, True) self.close_button.connect('clicked', self.close_clicked) self.dialog.connect('response', self.dialog_response) self.image.add_events(gtk.gdk.BUTTON_PRESS_MASK) self.image.connect('button-press-event', self.image_clicked) self.dialog.show_all() def close_clicked(self, widget): self.close() def dialog_response(self, widget, response_id): self.close() def close(self): if self.camera: self.camera.stop() if self.camera.buffer: pixbuf = gtk.gdk.pixbuf_new_from_data(self.camera.buffer, gtk.gdk.COLORSPACE_RGB, False, 8, self.camera.width, self.camera.height, 3*self.camera.width) self.cb(pixbuf) else: self.cb(None) self.dialog.destroy() def image_clicked(self, widget, data=None): if self.camera: self.camera.take_photo()
def test_invalid_isospeed(self): cams = self.l.enumerate_cameras() c = Camera(self.l, cams[0]['guid'], isospeed=12393) c.start() c.shot() c.stop() c.close()
def main(): if len(argv) != 2 or argv[1] == '--help': print("""Usage: run.py MODEL Use MODEL to classify camera frames and play sounds when class 0 is recognised.""") exit(1) model_file = argv[1] # We use the same MobileNet as during recording to turn images into features print('Loading feature extractor') extractor = PiNet() # Here we load our trained classifier that turns features into categories print('Loading classifier') classifier = keras.models.load_model(model_file) # Initialize the camera and sound systems camera = Camera(training_mode=False) random_sound = RandomSound() # Create a preview window so we can see if we are in frame or not if SHOW_UI: pygame.display.init() pygame.display.set_caption('Loading') screen = pygame.display.set_mode((512, 512)) # Smooth the predictions to avoid interruptions to audio smoothed = np.ones(classifier.output_shape[1:]) smoothed /= len(smoothed) print('Now running!') #while True: for stream_frame in camera.stream: stream_frame.truncate() stream_frame.seek(0) raw_frame = stream_frame.array #raw_frame = camera.next_frame() # Use MobileNet to get the features for this frame z = extractor.features(raw_frame) # With these features we can predict a 'normal' / 'yeah' class (0 or 1) # Keras expects an array of inputs and produces an array of outputs classes = classifier.predict(np.array([z]))[0] # smooth the outputs - this adds latency but reduces interruptions smoothed = smoothed * SMOOTH_FACTOR + classes * (1.0 - SMOOTH_FACTOR) selected = np.argmax(smoothed) # The selected class is the one with highest probability # Show the class probabilities and selected class summary = 'Class %d [%s]' % (selected, ' '.join('%02.0f%%' % (99 * p) for p in smoothed)) stderr.write('\r' + summary) # Perform actions for selected class. In this case, play a sound from the sounds/ dir if selected == 0: random_sound.play_from('sounds/') else: random_sound.stop() # Show the image in a preview window so you can tell if you are in frame if SHOW_UI: pygame.display.set_caption(summary) surface = pygame.surfarray.make_surface(raw_frame) screen.blit(pygame.transform.smoothscale(surface, (512, 512)), (0, 0)) pygame.display.flip() for evt in pygame.event.get(): if evt.type == pygame.QUIT: pygame.quit() break
action = msg["action"] if action == "move": servo_msg = {camera[index].info()[0]: msg["angle"]} servo_pub.publish(servo_msg) elif action == "start": camera[index].start() elif action == "pause": camera[index].pause() elif action == "stop": camera[index].stop() return if __name__ == "__main__": rospy.init_node("camera") rospy.Subscriber("QT", String, camera_callback) servo_pub = rospy.Publisher("camera_servo", String, queue_size=5) host = "192.168.1.4" port1 = 5000 port2 = 5001 port3 = 5002 camera = [] camera.append(Camera("Main_Cam", 0, host, port1)) camera.append(Camera("Back_Cam", 1, host, port2)) camera.append(Camera("Third_Cam", 3, host, port3)) rospy.spin()
return ((diffX**2)+(diffY**2))**(0.5) #COMPLETE THIS PART def spawn_cells(numOfCells): """add the first line of the for loop to run as many times as numOfCells""" #The line should go here cell = Cell(surface) cell_list.append(cell) def draw_grid(): for i in range(0,2001,25): pygame.draw.line(surface,(230,240,240),(0+camera.x,i*camera.zoom+camera.y),(2001*camera.zoom+camera.x,i*camera.zoom+camera.y),3) pygame.draw.line(surface,(230,240,240),(i*camera.zoom+camera.x,0+camera.y),(i*camera.zoom+camera.x,2001*camera.zoom+camera.y),3) camera = Camera() blob = Player(surface,"Viliami") spawn_cells(2000) def draw_HUD(): w,h = font.size("Score: "+str(int(blob.mass*2))+" ") surface.blit(pygame.transform.scale(t_surface,(w,h)),(8,screen_height-30)) surface.blit(t_lb_surface,(screen_width-160,15)) drawText("Score: " + str(int(blob.mass*2)),(10,screen_height-30)) surface.blit(big_font.render("Leaderboard",0,(255,255,255)),(screen_width-157,20)) drawText("1. G #1",(screen_width-157,20+25)) drawText("2. G #2",(screen_width-157,20+25*2)) drawText("3. ISIS",(screen_width-157,20+25*3)) drawText("4. ur mom",(screen_width-157,20+25*4)) drawText("5. w = pro team",(screen_width-157,20+25*5)) drawText("6. jumbo",(screen_width-157,20+25*6))
value_serializer=lambda v: json.dumps(v).encode('utf-8'), bootstrap_servers=statusKafka) statusProducer.send(statusTopic, { "status": "starting", "client": "imagesfromopencv", "language": "python" }) imagesService = env.get_service(name='raw-images-topic') if imagesService is None: imagesKafka = "localhost:9092" imagesTopic = "opencv-kafka-demo-raw-images" else: imagesKafka = imagesService.credentials.get("hostname") imagesTopic = imagesService.credentials.get("topicName") imagesProducer = KafkaProducer(bootstrap_servers=imagesKafka) # import camera driver if os.environ.get('CAMERA'): Camera = import_module('camera_' + os.environ['CAMERA']).Camera else: from camera import Camera camerastream = Camera() while True: frame = camerastream.get_frame() # print("frame") imagesProducer.send(imagesTopic, frame) # statusProducer.send(statusTopic, {"status":"image-sent", "client": "imagesfromopencv", "camera": camerastream.__class__.__name__})
class GLDrawer(object): boundary = None boundary_grid_size = 30 sphere_slices = 10 camera = None clip_near = 0.1 clip_far = 10000 prev_time = None simu_time = None fps = 0 frame_cnt = 0 cur_frame = None stop_flag = False win_width = None win_height = None move_accel = 0.5 """acceleration""" move_velo = 0 """current velocity""" move_accel_dt = 0.1 """keypress within this time is treated as one long press""" prev_move_time = 0 """previous move keypress time""" prev_move_key = None """previous moving key code""" mouse_left_state = GLUT_UP mouse_right_state = GLUT_UP mouse_x = 0 mouse_y = 0 rotate_factor = 0.00001 x_rotate_speed = 0 y_rotate_speed = 0 wheel_speed = 5 model_rot_agl_x = 0 model_rot_agl_y = 0 _in_fullscreen = False def __init__(self, win_title, boundary, win_width=640, win_height=480): """:param boundary: list<(min, max) * 3> for x, y, z; or None if no boundary""" self.boundary = boundary self.camera = Camera([10, 10, 180], [sum(boundary[i]) / 2 for i in range(3)], [0, 1, 0]) self.win_width = win_width self.win_height = win_height def init_glut(): glutInit(sys.argv) glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH) glutInitWindowSize(win_width, win_height) glutCreateWindow(win_title) glutDisplayFunc(self._gl_drawscene) def visible(vis): if vis == GLUT_VISIBLE: glutIdleFunc(self._gl_drawscene) else: glutIdleFunc(None) glutKeyboardFunc(self._on_keyboard) glutMouseFunc(self._on_mouse) glutMotionFunc(self._on_mouse_motion) glutReshapeFunc(self._on_reshape) glutVisibilityFunc(visible) glutIdleFunc(self._gl_drawscene) def init_gl(): glClearColor(0.0, 0.0, 0.0, 0.0) # This Will Clear The Background Color To Black glClearDepth(1.0) # Enables Clearing Of The Depth Buffer glDepthFunc(GL_LESS) # The Type Of Depth Test To Do glEnable(GL_DEPTH_TEST) # Enables Depth Testing glShadeModel(GL_SMOOTH) # Enables Smooth Color Shading glMatrixMode(GL_PROJECTION) glLoadIdentity() # Reset The Projection Matrix gluPerspective(45.0, float(win_width) / float(win_height), self.clip_near, self.clip_far) glMatrixMode(GL_MODELVIEW) def init_light(): glLightfv(GL_LIGHT0, GL_AMBIENT, GLfloat_4(0.5, 0.5, 0.5, 1.0)) glLightfv(GL_LIGHT0, GL_DIFFUSE, GLfloat_4(1.0, 1.0, 1.0, 1.0)) glLightfv(GL_LIGHT0, GL_SPECULAR, GLfloat_4(1.0, 1.0, 1.0, 1.0)) glLightfv(GL_LIGHT0, GL_POSITION, GLfloat_4(1.0, 1.0, 1.0, 0.0)) glLightModelfv(GL_LIGHT_MODEL_AMBIENT, GLfloat_4(0.2, 0.2, 0.2, 1.0)) glEnable(GL_LIGHTING) glEnable(GL_LIGHT0) init_glut() init_gl() self._quadric = gluNewQuadric() #init_light() def start(self): self.prev_time = time() def mainloop(): glutMainLoop() t = threading.Thread(target=mainloop) t.daemon = True t.start() def _on_keyboard(self, key, x, y): if key == 'q': self.stop_flag = True thread.exit() if key == 'f': if not self._in_fullscreen: self._orig_w = self.win_width self._orig_h = self.win_height glutFullScreen() self._in_fullscreen = True else: glutReshapeWindow(self._orig_w, self._orig_h) self._in_fullscreen = False if key in ('w', 's', 'a', 'd'): if time() - self.prev_move_time > self.move_accel_dt or \ key != self.prev_move_key: self.move_velo = 0 self.prev_move_time = time() self.prev_move_key = key self.move_velo += self.move_accel if key == 'w': self.camera.move_forawrd(self.move_velo) elif key == 's': self.camera.move_forawrd(-self.move_velo) elif key == 'a': self.camera.move_right(-self.move_velo) else: self.camera.move_right(self.move_velo) def _on_mouse(self, button, state, x, y): self.mouse_x = x self.mouse_y = y if button == GLUT_LEFT_BUTTON: self.mouse_left_state = state elif button == GLUT_RIGHT_BUTTON: self.mouse_right_state = state if state == GLUT_UP: self.x_rotate_speed = 0 self.y_rotate_speed = 0 if button == 3: self.camera.move_forawrd(self.wheel_speed) elif button == 4: self.camera.move_forawrd(-self.wheel_speed) def _on_mouse_motion(self, x, y): def getv(v): s = False if v < 0: s = True v = -v r = self.rotate_factor * pow(v, 1.5) if s: r = -r return r if self.mouse_left_state == GLUT_DOWN or \ self.mouse_right_state == GLUT_DOWN: x -= self.mouse_x y -= self.mouse_y self.x_rotate_speed = getv(y) self.y_rotate_speed = getv(x) def _on_reshape(self, w, h): self.win_width = w self.win_height = h glViewport(0, 0, w, h) glMatrixMode(GL_PROJECTION) glLoadIdentity() gluPerspective(45.0, float(w) / float(h), self.clip_near, self.clip_far) glMatrixMode(GL_MODELVIEW) def draw_callback(self, frame, time): self.cur_frame = frame self.simu_time = time return not self.stop_flag def _gl_drawscene(self): frame = self.cur_frame if not frame: return glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) # apply rotate if self.mouse_right_state == GLUT_DOWN: self.camera.rotate_right(-self.x_rotate_speed) self.camera.rotate_up(self.y_rotate_speed) self.camera.setGL() if self.mouse_left_state == GLUT_DOWN: self.model_rot_agl_x += self.x_rotate_speed * 180 / math.pi self.model_rot_agl_y += self.y_rotate_speed * 180 / math.pi glRotatef(self.model_rot_agl_x, 1, 0, 0) glRotatef(self.model_rot_agl_y, 0, 1, 0) self._draw_boundary() # draw bodies self._draw_frame(frame) # draw info text glColor3f(1, 1, 1) self._print_str('fps={0} time={1}'.format(self.fps, self.simu_time)) # update fps cur_time = time() if cur_time - self.prev_time > 0.2: self.fps = int(self.frame_cnt / (cur_time - self.prev_time)) self.prev_time = cur_time self.frame_cnt = 0 self.frame_cnt += 1 glutSwapBuffers() def _draw_frame(self, frame): for sph in frame.sphlist: glPushMatrix() glColor3f(*sph.color) glTranslatef(sph.pos[0], sph.pos[1], sph.pos[2]) glutSolidSphere(sph.radius, self.sphere_slices, self.sphere_slices) glPopMatrix() for cyl in frame.cyllist: p1, p2 = cyl.p1, cyl.p2 vec = p2 - p1 vlen = float(np.sqrt(np.square(vec).sum())) angle = np.arccos(vec[2] / vlen) * 180.0 / np.pi if vec[2] < 0: angle = -angle glPushMatrix() glColor3f(*cyl.color) glTranslatef(p1[0], p1[1], p1[2]) glRotatef(angle, -vec[1] * vec[2], vec[0] * vec[2], 0.0) gluCylinder(self._quadric, 3.0, 3.0, vlen, 10, 10) glPopMatrix() def _draw_boundary(self): bd = self.boundary if not bd: return o = Vector(*[bd[i][0] for i in range(3)]) dx = bd[0][1] - bd[0][0] dy = bd[1][1] - bd[1][0] dz = bd[2][1] - bd[2][0] dxv = Vector(dx, 0, 0) dyv = Vector(0, dy, 0) dzv = Vector(0, 0, dz) glBegin(GL_LINES) self._draw_lines(o, o + dxv, dyv, (0.7, 0, 0)) self._draw_lines(o, o + dyv, dxv, (0.7, 0, 0)) self._draw_lines(o, o + dxv, dzv, (0, 0.7, 0)) self._draw_lines(o, o + dzv, dxv, (0, 0.7, 0)) self._draw_lines(o, o + dyv, dzv, (0, 0, 0.7)) self._draw_lines(o, o + dzv, dyv, (0, 0, 0.7)) glEnd() def _draw_lines(self, p0, p1, dist, color): """:param p0 and p1: Vector, initial line :param dist: Vector, total dist :param n: int, number of lines""" glColor3f(*color) dv = dist / self.boundary_grid_size for i in range(self.boundary_grid_size): glVertex3f(p0.x, p0.y, p0.z) glVertex3f(p1.x, p1.y, p1.z) p0 += dv p1 += dv def _print_str(self, s): glDisable(GL_DEPTH_TEST) glMatrixMode(GL_PROJECTION) glPushMatrix() glLoadIdentity() glOrtho(0, self.win_width, self.win_height, 0, -1, 1) glMatrixMode(GL_MODELVIEW) glPushMatrix() glLoadIdentity() glRasterPos2f(10, 20) for i in s: glutBitmapCharacter(GLUT_BITMAP_HELVETICA_18, ord(i)) glPopMatrix() glMatrixMode(GL_PROJECTION) glPopMatrix() glMatrixMode(GL_MODELVIEW) glEnable(GL_DEPTH_TEST)
from PyQt5 import QtGui, QtCore, QtWidgets import numpy as np from ctypes import c_float, c_uint, sizeof import time from camera import CameraMovement, Camera GLfloat = c_float GLuint = c_uint WIDTH = 800 HEIGHT = 600 # camera camera = Camera(position=QtGui.QVector3D(0., 0., 3.), up=QtGui.QVector3D(0., 1., 0.)) firstMouse = True lastX = WIDTH / 2.0 lastY = HEIGHT / 2.0 # timing dateTime = 0. # time between current frame and last frame lastFrame = 0. lightPos = QtGui.QVector3D(1.2, 1., 2.) class Window(QtGui.QOpenGLWindow): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs)
ns = 100 lower_left = Vec3(-2, -1, -1) horizontal = Vec3(4, 0, 0) vertical = Vec3(0, 2, 0) origin = Vec3(0, 0, 0) world = HitableList() world.append(Sphere(Vec3(0, 0, -1), 0.5, Lambertian(Vec3(0.8, 0.3, 0.3)))) world.append( Sphere(Vec3(0, -100.5, -1), 100, Lambertian(Vec3(0.8, 0.8, 0.0)))) world.append( Sphere(Vec3(1, 0, -1), 0.5, Metal(Vec3(0.8, 0.6, 0.2), fuzz=0.3))) world.append( Sphere(Vec3(-1, 0, -1), 0.5, Metal(Vec3(0.8, 0.8, 0.8), fuzz=1.0))) cam = Camera() pbar = ProgressBar( widgets=['Percentage ', Percentage(), ' ', ETA(), ' ', Bar()], maxval=nx * ny).start() with open('image.ppm', 'w') as f: f.write('P3\n{} {}\n255\n'.format(nx, ny)) for y, j in enumerate(xrange(ny - 1, -1, -1)): for i in xrange(nx): col = Vec3(0, 0, 0) for _ in xrange(ns): u = float(i + random()) / nx v = float(j + random()) / ny
'--logfile', action='store', help="save stats to file") parser.add_argument('-w', '--wristband', action='store_true', help="enable bluetooth wristband") args = parser.parse_args() if args.wristband: wrist = Wristband() wrist.start() if args.camera: neural = Neural(parameters) camera = Camera(parameters, neural) camera.start() print("* Camera loop started") _socketHandler = (r"/websocket", SocketHandler, {'camera': camera}) _statusHandler = (r"/status", StatusHandler, { 'io': hardware, 'wristband': wrist }) _staticHandler = (r"/(.*)", tornado.web.StaticFileHandler, { 'path': os.path.dirname(os.path.realpath(__file__)) + '/web/', 'default_filename': 'index.html' }) if args.stream and args.camera:
Texture_Check(6, Colour(0, 0, 0), Colour(0.5, 0.5, 0.5))) scene = Scene([ Sphere(Point3(0.35, 0.6, 0.5), 0.25, SHINY_BLUE), #Difference([ Intersection([ # Cube #Plane(Point3(0.2,0.0,0.5), Vector3(0,-1,0), CHECK_FLOOR), Plane(Point3(0.1, 0.175, 0.8), Vector3(0.5, 1, 0.1), SHINY_BLUE), #Plane(Point3(0.1,0.1,0.5), Vector3(-1,0,0), CHECK_FLOOR), #Plane(Point3(0.4,0.1,0.5), Vector3( 1,0,0), CHECK_FLOOR), #Plane(Point3(0.5,0.1,0.8), Vector3(0,0, 1), CHECK_FLOOR), #Plane(Point3(0.5,0.1,0.5), Vector3(0,0,-1), CHECK_FLOOR), Sphere(Point3(0.1, 0.175, 0.8), 0.175, SHINY_BLUE), ]), #Sphere(Point3(0.1,0.175,0.8), 0.165, SHINY_BLUE)]), #Sphere(Point3(0.75,0.15,.2), 0.15, SHINY_RED), Plane(Point3(0, 0, 0), Vector3(0, 1, 0), CHECK_FLOOR) ]) scene.lights = [ #Light(scene, unit(Vector3(2,5,3)), Colour(0.6, 0.6, 0.6)), #Light(scene, unit(Vector3(-4,3,0)), Colour(0.7, 0.7, 0.7)), PointLight(scene, Point3(.5, 1.1, 1.2), Colour(0.9, 0.9, 0.9)), ] scene.background = Colour(0, 0, 0) scene.ambient = Colour(0.4, 0.4, 0.4) camera = Camera(scene, Point3(0.5, 0.2, 1.6), WIN_SIZE) camera.lookAt(Point3(0.5, 0.2, 0.3)) #camera.lookAt(Point3(0.1,0.1, 0.9))
class World(pyglet.window.Window): def __init__(self, *args, **kwargs): super(World, self).__init__(*args, **kwargs) self.scale = 1.0 self.pos = (0, 0, 0) self.fov = 65 self.render_distance = 100.0 self.window_x = 1080 self.window_y = 720 self.on_resize(self.window_x, self.window_y) glClearColor(1.0, 1.0, 1.0, 0.0) glEnable(GL_DEPTH_TEST) self.file_path = resource_path('textureImages') self.textures = self.load_textures() # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ self.shape = terrainShape.TerrainShape(seed=11, island_location=(0, 0), size=15, height=1) # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ self.camera = FpsCamera(self) self.draw_number = 0 # the first rendered frame is 1 pyglet.clock.schedule_interval(self.update, 1 / 60.0) def load_textures(self): img_dir = self.file_path textures = [] img_paths = os.listdir(img_dir) print img_paths img_paths.sort() for image in img_paths: try: if not image == '.DS_Store': image = pyglet.image.load(os.path.join(img_dir, image)) else: continue except pyglet.image.codecs.dds.DDSException: print '"%s" is not a valid image file' % image continue textures.append(image.get_texture()) glEnable(textures[-1].target) glBindTexture(textures[-1].target, textures[-1].id) glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, image.width, image.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, image.get_image_data().get_data('RGBA', image.width * 4)) if len(textures) == 0: print 'Found no textures to load. Exiting' sys.exit(0) return textures def update(self, delta_time): self.camera.update(delta_time) def on_draw(self): self.draw_number += 1 glLoadIdentity() glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) self.camera.draw() shape = self.shape terrain = Terrain(self.textures[0], shape) mat = terrain.get_example_mat(20, 20) import matTerrian matTerrian.draw(texture=terrain.sand_texture, mat=mat) def on_resize(self, width, height): self.window_x = width self.window_y = height glViewport(0, 0, width, height) glMatrixMode(GL_PROJECTION) glLoadIdentity() gluPerspective(65.0, width / float(height), 0.1, self.render_distance) glMatrixMode(GL_MODELVIEW)
if __name__ == '__main__': #classe que cria os alvos tempo = time.time() alvo = drawObj.Alvo() # conta quadros para desenhar novo alvo alvoQuadrosCount = 0 # classe detecta fluxo optico fluxo = fluxo.Fluxo() # guarda estado atual da aplicacao estado = 0 salvo = 'user.png' user1 = cv2.imread(salvo, 0) cam = Camera(1) faceTracker = roi.Detect() recon = FaceRecognition() contador = 0 while True: #print 'estdo = ', estado # captura frame frame = cam.preprocessa() # detecta faces frame = faceTracker.detectar(**frame) #if 'gray' in frame.keys(): # cv2.imshow('gray', frame['gray']) #if 'roi_face' in frame.keys(): # cv2.imshow('roi_face', frame['roi_face']) if 'roi_eyes' in frame.keys(): #cv2.imshow('roi_eyes', frame['roi_eyes'])
from car import Car from vision import Vision from camera import Camera import cv2 import numpy as np if __name__ == '__main__': #car = Car(18,12) vision = Vision(0.1) camera = Camera() #car.reset() while True: img ,depth = camera.getImages() img2 = img.copy() if depth is None: #car.stop() #car.reset() break ret = vision.processFrame(depth) print(ret) font = cv2.FONT_HERSHEY_SIMPLEX print(img.shape) if ret == 1: cv2.putText(img2,"BREAK",(90,120),font,1.5,(0,0,255),5) elif ret == 3: cv2.putText(img2,"STEER LEFT",(30,120),font,1.5,(0,0,255),5) elif ret == 2: cv2.putText(img2,"STEER RIGHT",(30,120),font,1.5,(0,0,255),5)
def __init__(self, **kwargs): super().__init__(**kwargs) self.camera = Camera(fps=25)
def main(): # Parse command line if len(sys.argv) < 2: print("python main.py mode <query_image_path> [ <train_video_path> ]") return 1 # Extract features and descriptors from query image query_image_path = sys.argv[1] print("Query Image Path: {}".format(query_image_path)) marker = Marker() #class maker ret = marker.query_marker(query_image_path) #method from class; query is scan of card if ret == -1: print("Unable to get query image...terminating...") return cap = None if len(sys.argv) == 3: train_image_path = sys.argv[2] #live scene print("Using video file...Training Image Path: {}".format(train_image_path)) cap = cv2.VideoCapture(train_image_path) else: print("Using web cam") cap = cv2.VideoCapture(0) # For loading and saving videos id_ = 3 start_frame = 0 # Get metadata from input movie cap.set(cv2.CAP_PROP_POS_FRAMES, start_frame) fps = cap.get(cv2.CAP_PROP_FPS) frame_width = int(cap.get(3)) frame_height = int(cap.get(4)) fourcc = cv2.VideoWriter_fourcc(*'MJPG') # Create video writer video_writer = cv2.VideoWriter('videos/output_{}.avi'.format(id_), fourcc, fps, (frame_width, frame_height)) i = 0 while True: ret, frame = cap.read() i+=1 # Display every 5 frames if i % 5 == 0: continue if ret == False: break if ret == -1: print("Unable to get frame...terminating...") return ret, outlined_frame, matches_image = marker.find_marker(frame) #drawn on webcam frame (blue outline) if ret != -1: #if no error frame = outlined_frame marker.estimate_pose(outlined_frame,Camera()) #get pose from drawn image cv2.imshow('Matches',matches_image) cv2.imshow('AR Frame',frame) key = cv2.waitKey(1) print(key) if key & 0xFF == ord('q'): break video_writer.write(frame) cv2.destroyAllWindows()
def __init__(self): # composition stuff #: list of (int, child-reference) where int is the z-order, sorted by ascending z (back to front order) self.children = [] #: dictionary that maps children names with children references self.children_names = {} self._parent = None # drawing stuff #: x-position of the object relative to its parent's children_anchor_x value. #: Default: 0 self._x = 0 #: y-position of the object relative to its parent's children_anchor_y value. #: Default: 0 self._y = 0 #: a float, alters the scale of this node and its children. #: Default: 1.0 self._scale = 1.0 #: a float, in degrees, alters the rotation of this node and its children. #: Default: 0.0 self._rotation = 0.0 #: eye, center and up vector for the `Camera`. #: gluLookAt() is used with these values. #: Default: FOV 60, center of the screen. #: IMPORTANT: The camera can perform exactly the same #: transformation as ``scale``, ``rotation`` and the #: ``x``, ``y`` attributes (with the exception that the #: camera can modify also the z-coordinate) #: In fact, they all transform the same matrix, so #: use either the camera or the other attributes, but not both #: since the camera will be overridden by the transformations done #: by the other attributes. #: You can change the camera manually or by using the `Camera3DAction` #: action. self.camera = Camera() #: offset from (x,0) from where rotation and scale will be applied. #: Default: 0 self.transform_anchor_x = 0 #: offset from (0,y) from where rotation and scale will be applied. #: Default: 0 self.transform_anchor_y = 0 #: whether of not the object and his childrens are visible. #: Default: True self.visible = True #: the grid object for the grid actions. #: This can be a `Grid3D` or a `TiledGrid3D` object depending #: on the action. self.grid = None # actions stuff #: list of `Action` objects that are running self.actions = [] #: list of `Action` objects to be removed self.to_remove = [] #: whether or not the next frame will be skipped self.skip_frame = False # schedule stuff self.scheduled = False # deprecated, soon to be removed self.scheduled_calls = [] #: list of scheduled callbacks self.scheduled_interval_calls = [] #: list of scheduled interval callbacks self.is_running = False #: whether of not the object is running # matrix stuff self.is_transform_dirty = False self.transform_matrix = euclid.Matrix3().identity() self.is_inverse_transform_dirty = False self.inverse_transform_matrix = euclid.Matrix3().identity()
class CameraTest(unittest.TestCase): def setUp(self): self.camera = Camera(800, 800, 10, 10) def test_apply(self): self.assertEqual(self.camera.apply((10, 10)), (10, 10)) self.assertEqual(self.camera.apply(Vector((10, 10))), Vector(10, 10)) self.assertEqual(self.camera.apply([Vector((10, 10)), Vector((5, 5))]), [Vector((10, 10)), Vector((5, 5))]) def test_update(self): self.camera.update((50, 50)) self.assertEqual(self.camera.state.x, -45.0) self.camera.update(Vector((100, 100))) self.assertEqual(self.camera.state.x, -95.0) def test_reverse_apply(self): self.assertEqual(self.camera.reverse_apply((10, 10)), (10, 10)) self.assertEqual(self.camera.reverse_apply(Vector((10, 10))), Vector(10, 10)) self.assertEqual(self.camera.reverse_apply([Vector((10, 10)), Vector((5, 5))]), [Vector((10, 10)), Vector((5, 5))]) def test_functionality(self): self.assertEqual(self.camera.functionality((50, 50)).x, -45.0) self.assertEqual(self.camera.functionality((50, 50)).y, -45.0)
def get_image(self): from camera import Camera camera = Camera() camera.capture_mobject(self) return Image.fromarray(camera.get_image())
def setUp(self): self.camera = Camera(800, 800, 10, 10)
match_cams = set() for filename in os.listdir('./match_test_data'): if re.match(r'^match_[0-9]\-[0-9].txt$', filename): nums = [int(x) for x in re.findall(r'\d+', filename)] match_cams.add(nums[0]) match_cams.add(nums[1]) imgs = {} for filename in sorted(os.listdir('../data/carmel_all')): img = cv.imread(os.path.join('../data/carmel_all', filename)) if img is not None: imgs[filename] = img cams = [ Camera( Image(imgs['carmel-0' + str(x) + '.png'], 'carmel-0' + str(x) + '.png')) for x in match_cams ] matches = [] # (H, [[[x,y], [x',y']], ...]) for filename in os.listdir('./match_test_data'): if re.match(r'^match_[0-9]\-[0-9].txt$', filename): match_nums = [int(x) for x in re.findall(r'\d+', filename)] nums = [int(x) for x in re.findall(r'\d+', filename)] cam_from_idx = nums[0] cam_to_idx = nums[1] # Extract match parameters contents = open('./match_test_data/' + filename, 'r').read() # print(contents.split()) # words = re.compile("\s*").split(contents)
df_solar = pd.read_csv("data/solar.csv", delimiter=";", skiprows=1) S = interp1d(df_solar["Wavelength (nm)"], df_solar["Extraterrestrial W*m-2*nm-1"], fill_value="extrapolate") # W per meter squared per nanometer return S if __name__ == "__main__": M = get_mirror() Q = get_detector() S = get_solar() print(snr(27000)) CoCa = Camera() def integrand(w, alpha=0): return w * M(w) * Q(w) * ref_rock(w, alpha).T * S(w) phase_angle = np.arange(1, 90, 10) snr_vals = [] snr_vals_80 = [] signals = [] signals_80 = [] centers = range(450, 1000, 50) t_exp = 0.005 t = [] t_sat = [] df = pd.read_csv("data/texp.csv")
def video_feed(): return Response(gen(Camera()), mimetype='multipart/x-mixed-replace; boundary=frame')
class App(object): def __init__(self): vsync = config.IS_VSYNC if config.IS_FULLSCREEN: self.__window = window.Window( fullscreen=True, vsync=vsync ) else: width,height = config.WIN_SIZE self.__window = window.Window( width=width, height=height, fullscreen=False, vsync=vsync ) self.__winSize = winSize = ( self.__window.width, self.__window.height ) self.__camera = Camera( winSize ) self.__hud = HUD( winSize ) self.__inputManager = InputManager() self.__window.on_key_press = self.__inputManager.key_pressed self.__window.on_key_release = self.__inputManager.key_released if config.IS_FPS_LIMIT: clock.set_fps_limit( FPS_LIMIT ) glDepthFunc( GL_LEQUAL ) glEnable( GL_DEPTH_TEST ) self.__world = GameWorld(self) # to musi być na końcu def get_window_coords(self): ''' Zwraca współrzędne czworokąta, w którym można rysować. ''' return self.__camera.windowCoords def register_input_observer(self, obj): self.__inputManager.register_observer(obj) def get_window_dim(self): ''' Zwraca wymiary okna (szerokość, wysokość) ''' return (float(self.__window.width), float(self.__window.height)) def get_window_draw_dim(self): ''' Zwraca współrzędne, w których należy rysować (szerokość, wysokość). ''' return (1000.0, 750.0) # return (800.0, 600.0) def main_loop(self): ''' Pętla główna gry. ''' self.__timeElapsed = 0.0 # czas jaki upłynął od początku gry splash = Splash(self, self.__camera, config.SPLASH_DISPLAY_TIME) while not self.__window.has_exit: self.__window.dispatch_events() # update świata i HUDa dt = clock.tick() * config.DTIME_MULTIPLY self.__timeElapsed += dt if config.PRINT_FPS and dt>0.001: print "FPS:", 1.0/dt # ustaw kamerę self.__camera.set3d() # narysuj splash screen albo grę if self.__timeElapsed < config.SPLASH_DISPLAY_TIME: splash.update(dt) splash.draw() else: self.__world.update( dt ) # self.__hud.update( dt ) # narysuj świat self.__camera.set3d() self.__world.draw() # # narysuj HUD # self.__camera.set2d() # self.__hud.draw() self.__window.flip()
class Hub: """ Hub class, provides a central module to hold all the properties that are constantly being accessed """ def __init__(self): """ Initialize default values """ self.CLOCK = pygame.time.Clock() self.WINDOW_WIDTH = 1080 self.WINDOW_HEIGHT = 720 self.WINDOW_TITLE = "Legend of Peach" self.WINDOW_ICON = pygame.image.load('imgs/WINDOW_ICON.png') self.BG_COLOR = (0, 0, 0) self.FRAMERATE = 30 self.speed = 0 # PHYSICS VALUES self.GRAVITY = 10 self.velocityAI = 5 self.velocityMushroom = 5 self.velocityStar = 10 # DEBUG MODE self.modeFreeze = False self.modePlace = False # Load mario levels from mario level self.game_levels = self.get_levels() self.gamemode = GameMode(self) self.controller = Controller(self) self.camera = Camera(self) # Screen selector chooses what screen to display self.screen_selector = 1 self.level_name = '' # STATES self.WALK = 'WALK' self.LEFT = 'LEFT' self.RIGHT = 'RIGHT' self.STOMPED = 'STOMPED' self.STAND = 'STAND' self.SHELL = 'SHELL' self.SLIDE = 'SLIDE' self.HIT = 'HIT' self.DEATHFALL = 'DEATHFALL' self.RISE = "RISE" self.FALL = "FALL" # Brick States self.RESTING = 'RESTING' self.BUMPED = 'BUMPED' self.OPENED = 'OPENED' """ Initialize the type of screen possible to display game_screen is the only one that will probably be reinstance everytime a new level opens. """ self.sound_board = SoundBoard() self.main_screen = pygame.display.set_mode((self.WINDOW_WIDTH, self.WINDOW_HEIGHT)) self.hud_screen = HudScreen(self) self.main_menu_screen = MainMenuScreen(self) self.level_screen = LevelSelectionScreen(self) self.game_screen = GameScreen(self) def display_screen(self): if self.screen_selector is 1: self.main_menu_screen.run() elif self.screen_selector is 2: self.level_screen.run() elif self.screen_selector is 3: # display gameover screen pass elif self.screen_selector is 0: # runs the game screen self.game_screen.run() if self.gamemode.mario_is_dead: if self.gamemode.lives == 0: # When mario has no more lives self.gamemode.reset_gamemode() self.sound_board.gameover.play() self.screen_selector = 1 else: self.open_level(self.level_name) self.gamemode.mario_is_dead = False self.hud_screen.run() @staticmethod def exit_game(): pygame.quit() sys.exit() @staticmethod def get_levels(): """ Grab the level data from the JSON file""" filename = 'levels.json' with open(filename, 'r') as read_file: data = json.load(read_file) return data def open_level(self, level_name, world_offset=0): """ Opens new gamee_screen and level""" print('new game_screen instantiated') self.game_screen = GameScreen(self, level_name) self.level_name = level_name theme = self.game_levels[level_name]["theme"] self.camera.reset_camera() self.camera.world_offset_x = world_offset if theme is "0": self.sound_board.play_main_theme_overworld() elif theme is "1": self.sound_board.play_underworld() elif theme is "2": self.sound_board.play_castle() else: self.sound_board.play_main_theme_overworld()
import cv2 import pickle import os import numpy as np # All this to include camera.py from os.path import dirname, abspath import sys sys.path.insert(0, dirname(dirname(abspath(__file__)))) from camera import Camera path = "./calibration/chessboard_imgs/" imgs = os.listdir(path) cam = Camera(disable_video=True) for fname in imgs: img = cv2.imread(path + fname) if img is not None: img = cam.undistort(img) small = cv2.resize(img, (0, 0), fx=0.6, fy=0.6) cv2.imshow(fname, small) cv2.waitKey(0)
class __impl: """This implementation hides the singleton interface\ in an inner class and creates exactly one instance of\ the inner class. The outer class is a handle to the inner\ class and delegates any requests to it. While the id() of\ the handle objects changes, the id() of the inner class which\ implements the singleton behaviour is constant.""" #------------------------------------------------------------------------------# # # # Class Attributes # # # #------------------------------------------------------------------------------# #reference to our game singletons __game = GameController() __camera = Camera() __hud = HUD() #reference to game timers timers = {} #------------------------------------------------------------------------------# # Accessors # #------------------------------------------------------------------------------# #get the game controller instance def getGame(this): return this.__game #get the camera instance def getCamera(this): return this.__camera #get the hud instance def getHud(this): return this.__hud #------------------------------------------------------------------------------# # Mutators # #------------------------------------------------------------------------------# #no mutators in here #------------------------------------------------------------------------------# # # # Class Methods # # # #------------------------------------------------------------------------------# #------------------------------------------------------------------------------# # Initilization # #------------------------------------------------------------------------------# #Initlize our single instance def __init__(this): #Ninja Game constructor methods this.initGame() this.runGame() #loads any pygame functions or objects before the user gets a chance to act def initGame(this): #initilize pygame's sound component #frequency, size, channels, buffersize pygame.mixer.pre_init(44100, 16, 2, 4096) #boot up pygame and print boot info message = pygame.init() print("Successes, Failures\n", message) #set the resolution of the game display this.getGame().setDisplay( pygame.display.set_mode(this.getGame().getResolution())) #set the name of the game pygame.display.set_caption(this.getGame().getGameName()) this.getGame().setTimer(this, "quitTimer", 10) this.getGame().setTimer(this, "spaceTimer", 5) #------------------------------------------------------------------------------# # Game Processes # #------------------------------------------------------------------------------# def runGame(this): #the game loop to keep the game running while this.getGame().getGameRunning(): #If we are in the menu if this.getGame().getAtMainMenu(): this.runMainMenu() #If we are in the options menu elif this.getGame().getAtOptionsMenu(): this.runOptionsMenu() #If we are in the game... elif this.getGame().getAtGame(): this.startGameplay() #if we manage to break out of the loop without quitting... #automatically call the quit method this.quitGame() #this is where the actual game gets played def startGameplay(this): pygame.mixer.music.load('sounds/music/level.wav') pygame.mixer.music.play(-1) #load the map and all of the objects this.loadMap() this.getHud().initGameHUD() #reset the game over flag so this does not repeat this.getGame().setGameOver(False) this.getGame().setVictory(False) this.getGame().setGameOverPlayed(False) #------------------ Game Loop Begin ------------------- #setup the event timer so that the game does not freeze by itself #set the event ID to be Uservent + 1 (25) timer_event = pygame.USEREVENT + 1 #set up the timer event to occur every set of miliseconds determined by the second argument pygame.time.set_timer(timer_event, 1) #while we are considered in the game while (this.getGame().getAtGame()): #------------ Event Processes ------------ #check to see if the player has a game over and if has been played yet if this.getGame().getGameOver()\ and not this.getGame().getGameOverPlayed(): #use the game over method if this is the case this.gameOver() #checks to see if the player is trying to use input and assigns the action #takes the pygame event argument that was created from the for loop command = this.processInput() #as long as the game isnt over... #player selects the new action and the player procces it if not this.getGame().getGameOver(): this.getGame().getPlayer().recieveCommand(command) else: this.getGame().getPlayer().recieveCommand("idle") #AI selects the new action and the AI processes it this.checkAIStates(this.getGame().getNPCSprites()) #check to see if all characters are in the middle of an action #finishes the action if the chracters are in the middle of one this.checkStates(this.getGame().getNPCSprites()) this.checkStates(this.getGame().getPlayer()) #add forces (including gravity) to all object lists, then the player this.addForces(this.getGame().getTerrainSprites()) this.addForces(this.getGame().getItemSprites()) this.addForces(this.getGame().getNPCSprites()) this.addForces(this.getGame().getPlayer()) #check to see if any triggers have been activated this.checkTriggers() #---------- Camera Update ---------------- #check to see if the camera needs to move this.getCamera().checkMove() #update the position of all sprites according to how the camera is shifting this.getCamera().update(this.getGame().getTerrainSprites()) this.getCamera().update(this.getGame().getItemSprites()) this.getCamera().update(this.getGame().getNPCSprites()) this.getCamera().update(this.getGame().getTriggerSprites()) this.getCamera().update(this.getHud().getMovingHUDSprites()) """ #update the position of all sprite buffers this.getCamera().update(this.getGame().terrainSpriteBuffer) this.getCamera().update(this.getGame().itemSpriteBuffer) this.getCamera().update(this.getGame().NPCSpriteBuffer) this.getCamera().update(this.getGame().triggerSpriteBuffer) """ this.getCamera().update(this.getGame().getPlayer()) #----------- Graphics Rendering ----------- #run the render graphics method this.renderGraphics() #----------- Graphics Update Process -------------- #updates all sprites to their proper positions this.getGame().getTerrainSprites().update() this.getGame().getItemSprites().update() this.getGame().getNPCSprites().update() this.getGame().getTriggerSprites().update() this.getGame().getPlayer().update() this.getHud().getHUDSprites().update() #update the display outside of the update loop to reflect any changes pygame.display.update() """ buffering methods to be added in at a later date #---------- Appearing and Vanishing ---------- #a method that removes all sprites out of view this.vanish(this.getGame().getTerrainSprites()) this.vanish(this.getGame().getItemSprites()) this.vanish(this.getGame().getNPCSprites()) this.vanish(this.getGame().getTriggerSprites()) this.vanish(this.getHud().getMovingHUDSprites()) this.appear(this.getGame().terrainSpriteBuffer) this.appear(this.getGame().itemSpriteBuffer) this.appear(this.getGame().NPCSpriteBuffer) this.appear(this.getGame().triggerSpriteBuffer) """ #---------- Game Timers ---------------- this.getGame().countdownTimers(this) #---------- Update Process --------------- #update frames per second outside fo the update loop and set the delta time to the variable this.getGame().deltaTime = ( this.getGame().clock.tick(this.getGame().gameFPS) / 4) #ensure the pygame event system is still working properly pygame.event.pump() #-------------------- Game Loop End ------------------------ def loadMap(this): this.loadMapLayer('map1/', 'terrain.txt', "terrain") this.loadMapLayer('map1/', 'character.txt', "character") this.loadMapLayer('map1/', 'item.txt', "item") this.loadMapLayer('map1/', 'triggers.txt', "trigger") def loadMapLayer(this, mapPath, filename, objectType): path1 = 'maps/' filepath = path1 + mapPath + filename mapfile = open(filepath, 'r') idxX = 0 idxY = 1 #loop through the map file to find the dimmensions of the map with open(filepath, 'r') as mapfile: while True: block = mapfile.read(1) if not block: break elif block == '\n': idxY += 1 idxX = 0 else: idxX += 1 mapfile.close() #reset the coordinate index values idxX = 0 idxY = 0 #loop through the map file to turn the character array into an objects array with open(filepath, 'r') as mapfile: while True: block = mapfile.read(1) if not block: break elif block == '\n': idxY += 1 idxX = 0 else: this.loadObject(block, objectType, idxX, idxY) idxX += 1 mapfile.close() def loadObject(this, block, objectType, idxX, idxY): blockScale = this.getGame().getBlockScale() tBuffer = this.getGame().terrainSpriteBuffer iBuffer = this.getGame().itemSpriteBuffer nBuffer = this.getGame().NPCSpriteBuffer if objectType == "terrain": #match the character with the object and add it to the map array if block == 'b': tBuffer[str(idxX) + "," + str(idxY)] = Brick( (idxX * blockScale), (idxY * blockScale)) elif block == 'w': tBuffer[str(idxX) + "," + str(idxY)] = Wall( (idxX * blockScale), (idxY * blockScale)) elif block == 's': tBuffer[str(idxX) + "," + str(idxY)] = Sky( (idxX * blockScale), (idxY * blockScale)) elif block == 'd': tBuffer[str(idxX) + "," + str(idxY)] = Door( (idxX * blockScale), (idxY * blockScale)) elif block == 'g': tBuffer[str(idxX) + "," + str(idxY)] = Ground( (idxX * blockScale), (idxY * blockScale)) #if it is a character type object elif objectType == "character": #match the character with the object and add it to the map array if block == 'r': nBuffer[str(idxX) + "," + str(idxY)] = Gaurd( "Standing Gaurd", (idxX * blockScale), (idxY * blockScale)) elif block == 'p': Player((idxX * blockScale), (idxY * blockScale)) #if it is an item type object elif objectType == "item": pass #if it is a trigger type object elif objectType == "trigger": #match the character with the object and add it to the map array if block == 'm': tBuffer[str(idxX) + "," + str(idxY)] = Trigger( "howToMoveMessage", (idxX * blockScale), (idxY * blockScale), blockScale, (blockScale * 2)) elif block == 'a': tBuffer[str(idxX) + "," + str(idxY)] = Trigger( "howToAttackMessage", (idxX * blockScale), (idxY * blockScale), blockScale, (blockScale * 2)) elif block == 'e': tBuffer[str(idxX) + "," + str(idxY)] = Trigger( "enemyInfoMessage", (idxX * blockScale), (idxY * blockScale), blockScale, (blockScale * 2)) elif block == 'r': tBuffer[str(idxX) + "," + str(idxY)] = Trigger( "enemyBroadcastMessage", (idxX * blockScale), (idxY * blockScale), blockScale, (blockScale * 2)) elif block == 'v': tBuffer[str(idxX) + "," + str(idxY)] = Trigger( "victory", (idxX * blockScale), (idxY * blockScale), blockScale, (blockScale * 2)) elif block == 'c': tBuffer[str(idxX) + "," + str(idxY)] = Trigger( "clearMessages", (idxX * blockScale), (idxY * blockScale), blockScale, (blockScale * 2)) def renderGraphics(this): """ The way this works, is that it builds the display in layers based on what comes first and the last thing that gets drawn is the sprite/shape on the bottom of the graphics rendering code block """ #wipe the slate clean this.getGame().getDisplay().fill(this.getGame().getColor("black")) #add all sprites to the game display this.getGame().getTerrainSprites().draw( this.getGame().getDisplay()) this.getGame().getItemSprites().draw(this.getGame().getDisplay()) this.customDraw(this.getGame().getNPCSprites()) this.customDraw(this.getGame().getPlayer()) this.getHud().getHUDSprites().draw(this.getGame().getDisplay()) #function for using the custome draw function for a sprite group def customDraw(this, sObject): #if the object instance is a single sprite if isinstance(sObject, pygame.sprite.Sprite): #use the custom-made draw function sObject.draw(this.getGame().getDisplay()) #if the object instance is a sprite group if isinstance(sObject, pygame.sprite.Group): #loop through the sprite group for sprite in sObject: #use the custom-made draw function sprite.draw(this.getGame().getDisplay()) """ functions to be added in at a later date def vanish(this, spriteGroup): block = this.getGame().getBlockScale() vanishRect = pygame.Rect((0,0),(this.getGame().getResolution())) #expand the rect to account for the loading buffer vanishRect.inflate_ip(block * this.getGame().loadingBuffer,\ block * this.getGame().loadingBuffer) #loop through the sprite group for sprite in spriteGroup: #if the sprite is not within the load rect... if not vanishRect.contains(sprite.getRect()): #remove the sprite sprite.remove() def appear(this, spriteList): block = this.getGame().getBlockScale() vanishRect = pygame.Rect((0,0),(this.getGame().getResolution())) #expand the rect to account for the loading buffer loadRect = vanishRect.inflate(block * (this.getGame().loadingBuffer + 2),\ block * (this.getGame().loadingBuffer + 2)) #expand the vanishing buffer vanishRect.inflate_ip(block * (this.getGame().loadingBuffer + 2),\ block * (this.getGame().loadingBuffer)) #loop through each sprite in the sprite buffer for key, value in spriteList.items(): #if the sprite is not within the vanish rect #but is within the load rect.... if not vanishRect.contains(value.getRect())\ and loadRect.contains(value.getRect()): #ensure the item gets added to the correct list if isinstance(value, Block): this.getGame().getTerrainSprites().add(value) elif isinstance(value, Item): this.getGame().getItemSprites().add(value) elif isinstance(value, NPC): this.getGame().getNPCSprites().add(value) elif isinstance(value, Trigger): this.getGame().getTriggerSprites().add(value) """ def processInput(this): """Will go back and change jump to a MOD key to try to fix jumping issue""" #assign the reference to the game keys list keys = this.getGame().keys mods = pygame.key.get_mods() #keysPressed = this.getGame().noKeysPressed keysPressed = pygame.key.get_pressed() #reset all the keys that are pressed for idx in range(0, len(keys)): keys[idx] = False #if the keys that are pressed = the boolean tuple if keysPressed == this.getGame().wPressed: keys[0] = True elif keysPressed == this.getGame().sPressed: keys[1] = True elif keysPressed == this.getGame().aPressed: keys[2] = True elif keysPressed == this.getGame().dPressed: keys[3] = True elif keysPressed == this.getGame().upPressed: keys[4] = True elif keysPressed == this.getGame().downPressed: keys[5] = True elif keysPressed == this.getGame().leftPressed: keys[6] = True elif keysPressed == this.getGame().rightPressed: keys[7] = True elif keysPressed == this.getGame().spacePressed: keys[8] = True elif keysPressed == this.getGame().escPressed: keys[9] = True #if the mods are pressed = one number for a specific key if mods == this.getGame().rCtrlPressed: keys[10] = True #print(keysPressed) #print(keys) #print (mods) if keysPressed == this.getGame().noKeysPressed: return "idle" #return a command based on which keys are pressed if keys[8]: if this.getGame().checkTimer(this, "spaceTimer"): #ensure we dont press the button twice this.getGame().setTimer(this, "spaceTimer", 5) return "jump" elif keys[9]: if this.getGame().checkTimer(this, "quitTimer"): if not this.getGame().getAtMainMenu(): this.quitLevel() #ensure we dont press the button twice this.getGame().setTimer(this, "quitTimer", 10) else: return this.quitGame() elif keys[10]: return "attack" elif keys[0] or keys[4]: return "goUp" elif keys[1] or keys[5]: return "goDown" elif keys[2] or keys[6]: return "goLeft" elif keys[3] or keys[7]: return "goRight" #if no actions are being taken or no keys are being pressed... return idle return "idle" #function for using the check AI state function for a group of sprites def checkAIStates(this, sObject): #loop through the sprite group for sprite in sObject: #use the checkState function sprite.checkAIState() #function for using the check state function for a sprite or group def checkStates(this, sObject): #if the object instance is a single sprite if isinstance(sObject, pygame.sprite.Sprite): #use the checkState function sObject.checkState() #if the object instance is a sprite group if isinstance(sObject, pygame.sprite.Group): #loop through the sprite group for sprite in sObject: #use the checkState function sprite.checkState() #add gravity to an object array or just the player def addForces(this, sObject): #if the object instance is a single sprite if isinstance(sObject, pygame.sprite.Sprite): #add force to a single object this.addSingleForce(sObject) #if the object instance is a sprite group elif isinstance(sObject, pygame.sprite.Group): #loop through the sprite group for sprite in sObject: #add force to a single object this.addSingleForce(sprite) def addSingleForce(this, sObject): #if the object instance is a character or NPC sprite if isinstance(sObject, Character)\ or isinstance(sObject, NPC): #have gravity affect the object if they are in the air if sObject.mass > 0: sObject.addForce(0, (this.getGame().gravity / 2)) #implement speed loss over time if sObject.getState("isIdle"): if not sObject.speedX == 0: if sObject.speedX > 0: sObject.addForce(-this.getGame().speedLoss, 0) elif sObject.speedX < 0: sObject.addForce(this.getGame().speedLoss, 0) #if there is less than 1 unit of force if abs(sObject.speedX) < 1: #set the speed to 0 sObject.speedX = 0 # if the object is in the middle of moving left or right... if sObject.speedX > 0 or sObject.speedX < 0: #move the object and see if they collides with another object if not sObject.move( sObject.speedX * this.getGame().deltaTime, 0): if not sObject.getState("isJumping"): #if they collide, then set the x speed to 0 sObject.speedX = 0 #if the object is in the air if sObject.speedY > 0 or sObject.speedY < 0: #move the object and see if he collides with another object if not sObject.move( 0, (sObject.speedY * this.getGame().deltaTime)): #if they collides, set the y speed to 0 sObject.speedY = 0 #if the object is not a character sprite else: #if the object has mass if sObject.mass > 0: #make the object fall sObject.move(0, (this.getGame().deltaTime / 2) * this.getGame().gravity) def checkTriggers(this): #loop through each trigger for trigger in this.getGame().getTriggerSprites(): #check to see if the trigger is colliding with the player if this.getGame().getPlayer().getRect().colliderect( trigger.getRect()): #trigger the event trigger.event() #countdown the timers on the triggers Trigger.game.countdownTimers(Trigger) #a method to run if the player has a game over def gameOver(this): #if it is not a victorious game over if not this.getGame().getVictory(): pygame.mixer.music.load('sounds/music/gameOver.wav') pygame.mixer.music.play(-1) #remove any text box elements (if there is any) this.getHud().removeTextBox() #Create a text box with a message this.getHud().createBoxWithMessage( "*-----------------------------------------------*"\ +"| _____ ____ |"\ +"| / ___/__ ___ _ ___ / __ \_ _____ ____ |"\ +"| / (_ / _ `/ ` \/ -_) / /_/ / |/ / -_) __/ |"\ +"| \___/\_,_/_/_/_/\__/ \____/|___/\__/_/ |"\ +"| |"\ +"| |"\ +"| Press ESC key to go back to the main menu |"\ +"*-----------------------------------------------*",\ this.getHud().getTextBoxLocX(), this.getHud().getTextBoxLocY(),\ this.getHud().getTextBoxSizeX(), this.getHud().getTextBoxSizeY() + 2,\ False) #if it is a victorious game over elif this.getGame().getVictory(): pygame.mixer.music.load('sounds/music/victory.wav') pygame.mixer.music.play(-1) #remove any text box elements (if there is any) this.getHud().removeTextBox() #Create a text box with a message this.getHud().createBoxWithMessage(" _ ___ __ "\ +" | | / (_)____/ /_____ _______ __ "\ +" | | / / / ___/ __/ __ \/ ___/ / / / "\ +" | |/ / / /__/ /_/ /_/ / / / /_/ / "\ +" |___/_/\___/\__/\____/_/ \__, / "\ +" /____/ "\ +" "\ +" "\ +" Press ESC to return to the main menu ",\ 128,212,43,13, False) #reset the game over flag so this does not repeat this.getGame().setGameOverPlayed(True) #----------------------------- Main Menu Method ------------------------- def runMainMenu(this): pygame.mixer.music.load('sounds/music/title.wav') pygame.mixer.music.play(-1) #Create a main menu and while bool to store selection this.getHud().createBoxWithMessage("*-----------------------------------------------------*"\ +"| |"\ +"| |"\ +"| P r e s s S P A C E |"\ +"| |"\ +"| |"\ +"| |"\ +"| S T A R T G A M E |"\ +"| |"\ +"| |"\ +"| |"\ +"| |"\ +"| |"\ +"| |"\ +"*-----------------------------------------------------*",\ 8,8,58,18, False) this.getHud().createBoxWithMessage("*-----------------------------------------------------*"\ +"| |"\ +"| |"\ +"| |"\ +"| |"\ +"| |"\ +"| |"\ +"| Q U I T G A M E |"\ +"| |"\ +"| |"\ +"| |"\ +"| P r e s s E S C |"\ +"| |"\ +"| |"\ +"*-----------------------------------------------------*",\ 8,328,58,18, False) this.getHud().createBoxWithMessage(" ______ _ __ _ "\ +" / __/ / (_)__ ___ / / (_) "\ +" _\ \/ _ \/ / _ \/ _ \/ _ \/ / "\ +" /___/_//_/_/_//_/\___/_.__/_/ "\ +" "\ +" ___ _ "\ +" / _ | ___ ___ ___ ____ ___ (_)__ "\ +" / __ |(_-<(_-</ _ `(_-<(_-</ / _ \ "\ +" /_/ |_/___/___/\_,_/___/___/_/_//_/ ",\ 128,212,43,13, False) mainMenu = Menu("Main") mainMenu.addMenuItem("Start", this.getGame().imgBlank, 0, 0, 960, 320) #mainMenu.addMenuItem("Start", this.getGame().startImage, 0,0,480,320) #mainMenu.addMenuItem("Options", this.getGame().optionsImage, 480,0,480,320) mainMenu.addMenuItem("Quit", this.getGame().imgBlank, 0, 320, 960, 320) #------------------ Main Menu Loop Begin ------------------- #while we are considered in the main menu while (this.getGame().getAtMainMenu()): #for event in pygame.event.get(): #------------ Event Processes ------------ #a method that checks to see if a menu item get pressed #and assigns the process name to a process variable #process = mainMenu.selectOption(this.getGame().getDisplay(), event) process = this.processInput() this.runSelectedProcess(process) #----------- Graphics Rendering ----------- """ The way this works, is that it builds the display in layers based on what comes first and the last thing that gets drawn is the sprite/shape on the bottom of the graphics rendering code block """ #draw the HUD sprites on the screen this.getHud().getHUDSprites().update() #run the render graphics method this.renderGraphics() #update the screen pygame.display.update() #Run the display menu items method #mainMenu.displayMenuItems(this.getGame().getDisplay()) #------------ Game Timers ---------------- this.getGame().countdownTimers(this) #----------- Update Process -------------- #update the display outside of the event loop to reflect any changes pygame.display.update() #update frames per second outside fo the update loop and set the delta time to the variable this.getGame().deltaTime = ( this.getGame().clock.tick(this.getGame().gameFPS) / 4) #ensure the pygame event system is still working properly pygame.event.pump() #-------------------- Main Menu Loop End ------------------------ def runOptionsMenu(this): print("You are in the options menu, nothing here yet...") this.runSelectedProcess("Main Menu") def runSelectedProcess(this, process): if process == "jump": print("Starting Start Process...") this.getGame().setAtMainMenu(False) this.getGame().setAtOptionsMenu(False) this.getGame().setAtGame(True) elif process == "Main Menu": print("Returning to the Main Menu...") this.getGame().setAtMainMenu(True) this.getGame().setAtOptionsMenu(False) this.getGame().setAtGame(False) elif process == "Options": print("Starting Options Process...") this.getGame().setAtMainMenu(False) this.getGame().setAtOptionsMenu(True) this.getGame().setAtGame(False) elif process == "Quit": print("Continuing Quit Process...") this.getGame().setGameRunning(False) this.getGame().setAtMainMenu(False) this.getGame().setAtOptionsMenu(False) this.getGame().setAtGame(False) this.quitGame() elif process == "Invalid": print( "You have selected an invalid proceess... please try again" ) else: pass def quitLevel(this): #Clear out all sprite groups this.getGame().getTerrainSprites().empty() this.getGame().getItemSprites().empty() this.getGame().getNPCSprites().empty() this.getGame().getTriggerSprites().empty() this.getHud().getHUDSprites().empty() #Remove the player this.getGame().getPlayer().kill() #reset the camera this.getCamera().reset() #reset the game over flag this.getGame().setGameOver(False) #reset the victory flag this.getGame().setVictory(False) #remove the game over text Box this.getHud().removeTextBox() #run the main menu process this.runSelectedProcess("Main Menu") def quitGame(this): pygame.quit() quit()
dict_list = [] keys = [sheet.cell(0, col_index).value for col_index in range(sheet.ncols)] for row_index in range(1, sheet.nrows): d = { keys[col_index]: sheet.cell(row_index, col_index).value for col_index in range(sheet.ncols) } dict_list.append(d) camerasArray = [] for index in range(len(dict_list)): camerasArray.append( Camera(ip=dict_list[index]['ip'], port=int(dict_list[index]['port']), login=dict_list[index]['login'], password=dict_list[index]['password'])) #result = open(config_ini['DEFAULT']['path_to_save_file'], "w", encoding='utf8') log = open(config_ini['DEFAULT']['log_file'], 'w') for camer in camerasArray: print(camer) status = changeLogTries(camer.ip, camer.port, camer.login, camer.password, int(config_ini['DEFAULT']['mode'])) log.write("{}:{}\t{}\n".format(camer.ip, camer.port, status))
def generate_camera(): """ Generates camera """ config.CAMERA = Camera(config.MAP_INFO)
def main() -> int: parser = argparse.ArgumentParser() parser.add_argument('-u', '--unit-config', type=str, required=True) parser.add_argument('-a', '--app-config', type=str, required=True) args = parser.parse_args() with open(args.app_config, 'r') as f: sim_config = json.load(f)["simulation"] with open(args.unit_config, 'r') as f: unit_config = json.load(f) robots = list() robots.append( Robot(0, pose=np.array([[0], [0], [0]], dtype=np.float64), world_size=np.array([ sim_config["world"]["length_m"], sim_config["world"]["width_m"] ]))) robots.append( Robot(1, pose=np.array([[0], [0], [pi / 4]], dtype=np.float64), world_size=np.array([ sim_config["world"]["length_m"], sim_config["world"]["width_m"] ]))) robots.append( Robot(2, pose=np.array([[0], [0], [pi / 2]], dtype=np.float64), world_size=np.array([ sim_config["world"]["length_m"], sim_config["world"]["width_m"] ]))) robots.append( Robot(3, pose=np.array([[0], [0], [3 * pi / 4]], dtype=np.float64), world_size=np.array([ sim_config["world"]["length_m"], sim_config["world"]["width_m"] ]))) robots.append( Robot(4, pose=np.array([[0], [0], [pi]], dtype=np.float64), world_size=np.array([ sim_config["world"]["length_m"], sim_config["world"]["width_m"] ]))) robots.append( Robot(5, pose=np.array([[0], [0], [5 * pi / 4]], dtype=np.float64), world_size=np.array([ sim_config["world"]["length_m"], sim_config["world"]["width_m"] ]))) robots.append( Robot(6, pose=np.array([[0], [0], [3 * pi / 2]], dtype=np.float64), world_size=np.array([ sim_config["world"]["length_m"], sim_config["world"]["width_m"] ]))) robots.append( Robot(7, pose=np.array([[0], [0], [7 * pi / 4]], dtype=np.float64), world_size=np.array([ sim_config["world"]["length_m"], sim_config["world"]["width_m"] ]))) robots.append( Robot(8, pose=np.array([[-1], [1], [0]], dtype=np.float64), world_size=np.array([ sim_config["world"]["length_m"], sim_config["world"]["width_m"] ]))) robots.append( Robot(9, pose=np.array([[-1], [1], [pi / 4]], dtype=np.float64), world_size=np.array([ sim_config["world"]["length_m"], sim_config["world"]["width_m"] ]))) for robot in robots: # create, initialize, and attach camera to robot camera = Camera(intrinsics=unit_config["camera"]["0"]["intrinsics"], extrinsics=unit_config["camera"]["0"]["extrinsics"]) robot.attach_camera(camera) # generate 10 fiducials and place them fiducials = [] ''' for i in range(0,10): fiducial = Fiducial(np.array([[random.randrange(0, world_length), random.randrange(0, world_width), random.randrange(0, world_height)]], dtype=np.float64), i) fiducials.append(fiducial) ''' fiducials.append( Fiducial( np.array([[1, 1, 1, 1], [0, 0.1, 0.1, 0], [1, 1, 0.9, 0.9]], dtype=np.float64), 0)) fiducials.append(Fiducial(np.array([[1], [1], [1]], dtype=np.float64), 1)) fiducials.append(Fiducial(np.array([[0], [1], [1]], dtype=np.float64), 2)) fiducials.append(Fiducial(np.array([[-1], [1], [1]], dtype=np.float64), 3)) fiducials.append(Fiducial(np.array([[-1], [0], [1]], dtype=np.float64), 4)) fiducials.append(Fiducial(np.array([[-1], [-1], [1]], dtype=np.float64), 5)) fiducials.append(Fiducial(np.array([[0], [-1], [1]], dtype=np.float64), 6)) fiducials.append(Fiducial(np.array([[1], [-1], [1]], dtype=np.float64), 7)) seen = Simulator(robots, fiducials, world_size=np.array([ sim_config["world"]["length_m"], sim_config["world"]["width_m"] ])).run() # run the simulation
from camera import Camera, CameraModels import cv2 import numpy as np import os from tqdm import tqdm camera_model = CameraModels.FISHEYE retval, K, d, rvecs, tvecs, obj_points_temp, img_points_temp, not_used = np.load( 'calibration_file.npy', allow_pickle=True) cam = Camera(camera_matrix=K, distortion_coefficients=d, camera_model=camera_model) image_size = (640, 480) image_fov = (150, 120) show_image = False path = 'images' path_in = os.path.join(path, 'in/') path_out = os.path.join(path, 'out/') files = os.listdir(path_in) files = [file for file in files] #print(f'Searching: {}')
def __init__(self): self.image = None self.motor_step = 0 self.theta = 0 self.is_scanning = False self.camera = Camera()