def testmain(): xxx = Camera() xxx.start() while True: i = yyy.getImage() print "YYY got image"
def test_getPicture(self): try: Camera.getPicture(self.logger, 10000) print "Not exception" except Exception, e: self.assertEqual(e.args[0], 2)
class CameraJPEGServer(HTTPServer): cameraStore = None camera = None def __init__(self, *args, **kw): HTTPServer.__init__(self, *args, **kw) self.camera = Camera() self.camera.start()
class Scene(BackgroundLayer, KeyListener): def __init__(self, engine): self.engine = engine self.camera = Camera() self.time = 0.0 self.player = self.engine.world.getPlayers()[0] self.controls = Player.Controls() def shown(self): self.engine.input.addKeyListener(self) def hidden(self): self.engine.input.removeKeyListener(self) def keyPressed(self, key, unicode): c = self.controls.keyPressed(key) if c: return True return False def keyReleased(self, key): c = self.controls.keyReleased(key) if c: return True return False def run(self, ticks): self.time += ticks / 50.0 def render3D(self): pass def render(self, visibility, topMost): font = self.engine.data.font # render the scene try: glMatrixMode(GL_PROJECTION) glPushMatrix() glLoadIdentity() gluPerspective(60, self.engine.view.aspectRatio, 0.1, 1000) glMatrixMode(GL_MODELVIEW) glLoadIdentity() glPushMatrix() self.camera.apply() self.render3D() finally: glPopMatrix() glMatrixMode(GL_PROJECTION) glPopMatrix() glMatrixMode(GL_MODELVIEW)
def __init__(self): Globals.PLAYER_HEALTH = 100 Globals.PLAYER_SCORE = 0 Globals.REMAINING_TIME = 30000 self.tileEngine = TileEngine("test_def.txt", "test_map.txt", 1, 3) self.camera = Camera(self.tileEngine, pygame.Rect( 0, 0, Globals.WIDTH, Globals.HEIGHT)) self.keyCode = None self.testPoint = [] self.object_radius = \ self.camera.tileEngine.get_tile_rect().height * 1.5 self.direction = -1 self.has_collided = False self.enemySprites = pygame.sprite.Group() self.playerSprites = pygame.sprite.Group() self.health = HealthBar() self.score_timer = ScoreTimer() for x in range(TileTest.NUM_ENEMY): # fix the positions they are added in and everything else # should work self.enemySprites.add(Enemy(Globals.WIDTH, Globals.HEIGHT, self.camera)) player_x = Globals.WIDTH / 2 player_y = int(Globals.HEIGHT - self.camera.tileEngine.get_tile_rect().height * 3.5) self.player = Player( Globals.WIDTH, Globals.HEIGHT, player_x, player_y, self.score_timer ) self.playerSprites.add(self.player)
def __init__(self, engine, prompt = "", selectedSong = None, selectedLibrary = None): self.prompt = prompt self.engine = engine self.time = 0 self.accepted = False self.selectedIndex = 0 self.camera = Camera() self.cassetteHeight = .8 self.cassetteWidth = 4.0 self.libraryHeight = 1.2 self.libraryWidth = 4.0 self.itemAngles = None self.itemLabels = None self.selectedOffset = 0.0 self.cameraOffset = 0.0 self.selectedItem = None self.song = None self.songCountdown = 1024 self.songLoader = None self.initialItem = selectedSong self.library = selectedLibrary self.searchText = "" # Use the default library if this one doesn't exist if not self.library or not os.path.isdir(self.engine.resource.fileName(self.library)): self.library = Song.DEFAULT_LIBRARY self.loadCollection() self.engine.resource.load(self, "cassette", lambda: Mesh(self.engine.resource.fileName("cassette.dae")), synch = True) self.engine.resource.load(self, "label", lambda: Mesh(self.engine.resource.fileName("label.dae")), synch = True) self.engine.resource.load(self, "libraryMesh", lambda: Mesh(self.engine.resource.fileName("library.dae")), synch = True) self.engine.resource.load(self, "libraryLabel", lambda: Mesh(self.engine.resource.fileName("library_label.dae")), synch = True) self.engine.loadSvgDrawing(self, "background", "cassette.svg")
def __initP__(self, **kwArgs): super().__initP__(**kwArgs) self._sceneGraph = SceneGraph() self._camera = Camera(getDictValue(kwArgs, None, ['ws', 'winSize', 'windowSize'], True), t=Transform()) self._camera.focus()
def __init__(self, engine, songName = None, libraryName = DEFAULT_LIBRARY): self.engine = engine self.time = 0.0 self.guitar = Guitar(self.engine, editorMode = True) self.controls = Player.Controls() self.camera = Camera() self.pos = 0.0 self.snapPos = 0.0 self.scrollPos = 0.0 self.scrollSpeed = 0.0 self.newNotes = None self.newNotePos = 0.0 self.song = None self.engine.loadSvgDrawing(self, "background", "editor.svg") self.modified = False self.songName = songName self.libraryName = libraryName self.heldFrets = set() mainMenu = [ (_("Save Song"), self.save), (_("Set Song Name"), self.setSongName), (_("Set Artist Name"), self.setArtistName), (_("Set Beats per Minute"), self.setBpm), (_("Estimate Beats per Minute"), self.estimateBpm), (_("Set A/V delay"), self.setAVDelay), (_("Set Cassette Color"), self.setCassetteColor), (_("Set Cassette Label"), self.setCassetteLabel), (_("Editing Help"), self.help), (_("Quit to Main Menu"), self.quit), ] self.menu = Menu(self.engine, mainMenu)
def init(self): self.camera = Camera(euclid.Point3(0,15, 0)) self.mainplayer_status = StatusView() self.otherplayer_status = StatusView(is_opponent=True) self.mana_controller = ManaController(self.mainplayer_status.manapool, self.otherplayer_status.manapool, self) self.x_controller = XSelector(self.mainplayer_status.manapool, self.otherplayer_status.manapool, self) self.card_selector = CardSelector(self.mainplayer_status, self.otherplayer_status, self) #self.game_status = GameStatus() self.phase_status = PhaseStatus() self.phase_bar = PhaseBar() self.phase_controller = PhaseController(self.phase_status, self) self.status_controller = StatusController(self.mainplayer_status, self.otherplayer_status, self.phase_status, self) self.selection = SelectionList() self.list_selector = SelectController(self.selection, self) self.msg_dialog = MessageDialog() self.msg_controller = MessageController(self.msg_dialog, self) self.table = Table() self.mainplay = PlayView(z=3) self.otherplay = PlayView(z=-3, is_opponent_view=True) self.play_controller = PlayController(self.mainplay, self.otherplay, self) self.damage_assignment = DamageSelector(self.mainplay, self.otherplay, self) self.distribution_assignment = DistributionSelector(self.mainplay, self.otherplay, self) self.player_hand = HandView() self.hand_controller = HandController(self.player_hand, self) self.otherplayer_hand = HandView(is_opponent=True) self.otherhand_controller = HandController(self.otherplayer_hand, self) self.stack = StackView() self.stack_controller = StackController(self.stack, self) self.zone_animator = ZoneAnimator(self) self._keep_priority = False self.finish_turn = False self.p1_stop_next = False self.p2_stop_next = False
def __init__(self): self.lock_ = Lock() # create a lock for this thread self.alive_ = True # create and initialise server for this processor self.server_ = VisionServer( self, V_SETT.VISION_SRV_NET_OPEN, V_SETT.VISION_SRV_PORT, V_SETT.MAX_PENDING_REQS) # obtain frame capture device obj self.cam_ = Camera(0) self.fps_ = 0 # flags that will tell wheter data can be trusted (accurate) self.trust_bal_ = self.trust_blu_ = self.trust_ylw_ = None # these hold robots' and ball's coordinates and direction self.bal_center_ = None self.blu_robot_center_ = None self.ylw_robot_center_ = None self.blu_dir_ = self.ylw_dir_ = None # these hold pitcj and goal coordinates self.l_goal_t_ = self.l_goal_b_ = self.r_goal_t_ = self.r_goal_b_ = None self.pitch_tl_ = self.pitch_bl_ = self.pitch_tr_ = self.pitch_br_ = None # create colour objects and set their threshold values self.red_color_ = ColorSpace(ColorSpace.HSV) self.red_color_.set_trsh_bounds((0, 80, 80), (10, 255, 255)) # pitch 2 self.blu_color_ = ColorSpace(ColorSpace.HSV) self.blu_color_.set_trsh_bounds((92, 132, 199), (180, 255, 255)) self.ylw_color_ = ColorSpace(ColorSpace.RGB) self.ylw_color_.set_trsh_bounds((0, 0, 0), (255, 255, 255))
def __init__(self, parent): QGLWidget.__init__(self, parent) self.setMouseTracking(True) self.selectedProj = -1 self.canvasModel = CanvasModel.Dome(23.0,11.5,11.5,0.0,1.0) self.showCanvas = True self.projectors = Projectors4( Projector(11.5), Projector(11.5), Projector(11.5), Projector(11.5), 0.0, # Tower Height 25.0, # Pitch Angle 0.0) # Yaw Angle self.edgeBlending = True self.showProjectorImages = True self.projImagesFullscreen = False # self.setMinimumSize(500, 500) self.camera = Camera() self.camera.setSceneRadius( 30 ) self.camera.reset() self.isPressed = False self.oldx = self.oldy = 0 self.textureFiles = os.listdir(TEXTURE_PATH) self.textures = dict() self.shaders = dict() self.selTexture = "spherical_small"
def __init__(self): #glutInit(sys.argv) self.width, self.height = 1280, 800 pygame.init() self.screen = pygame.display.set_mode((self.width, self.height), OPENGL | DOUBLEBUF) glMatrixMode(GL_PROJECTION) glLoadIdentity() gluPerspective(65.0, self.width/float(self.height), 0.01, 1000.0) glMatrixMode(GL_MODELVIEW) glEnable(GL_DEPTH_TEST) self.camera = Camera((0.0, 100, 0), (0.0, 0, 0)) #Base vertices = np.array([[100.0, -10.0, 100.0, Conf.GRAPHX.BASE_COLOR[0],Conf.GRAPHX.BASE_COLOR[1],Conf.GRAPHX.BASE_COLOR[2]], \ [-100.0, -10.0, 100.0, Conf.GRAPHX.BASE_COLOR[0],Conf.GRAPHX.BASE_COLOR[1],Conf.GRAPHX.BASE_COLOR[2]], \ [-100.0, -10.0, -100.0,Conf.GRAPHX.BASE_COLOR[0],Conf.GRAPHX.BASE_COLOR[1],Conf.GRAPHX.BASE_COLOR[2]], \ [100.0, -10.0, -100.0, Conf.GRAPHX.BASE_COLOR[0],Conf.GRAPHX.BASE_COLOR[1],Conf.GRAPHX.BASE_COLOR[2]]], \ dtype=np.float32) self.vertexPositions = vbo.VBO(vertices) #Create the index buffer object indices = np.array([[0,1,2], [0, 3, 2]], dtype=np.int32) self.indexPositions = vbo.VBO(indices, target=GL_ELEMENT_ARRAY_BUFFER) self.uniform_values = {} self.uniform_locations = {}
def __init__(self,source=0): # Selected base color # fourth one is not used self.hsv = (0,0,0,0) self.hsv2 = (0,0,0,0) self.hsv3 = (0,0,0,0) # Thresholds self.ht = 0 self.st = 180 self.vt = 200 self.ht_ = 0 self.st_ = 180 self.vt_ = 200 # Co-ords for the color selection square # self.start = (0,0) # self.end = (0,0) self.center = (0,0) # Boolean to check weather # the colors are locked or not self.locked = False # Get the camera object self.cam = Camera(source)
def main(): global x, y, run x = y = 0 run = True pi = pigpio.pi() motorx = Motor(pi,1) motory = Motor(pi,2) sampling_period = 0.2 control = Controller(pi, motorx, motory, sampling_period) camera = Camera(sampling_period) camera.start() #control.start() control.generate_transform() control.target((0,0)) time.sleep(1) #t = threading.Thread(target=read_input) #t.start() #obj = Identification() try: while True: ##### Test without the camera ##### #x = float(input("x: ")) #y = float(input("y: ")) #obj.position = (x,y) #control.update_positions(obj, camera.laser) ############################################ control.target(camera.object.position) time.sleep(sampling_period) except(KeyboardInterrupt): pass finally: run = False control.stop() camera.stop() pi.stop()
def __init__(self, screen): # Explicitly ask for legacy OpenGL version to keep maximum compatibility across different operating systems fmt = QtOpenGL.QGLFormat() fmt.setVersion(2, 1) fmt.setProfile(QtOpenGL.QGLFormat.CoreProfile) fmt.setSampleBuffers(True) super(GLRenderArea, self).__init__(fmt, parent=screen) self.setAutoFillBackground(False) self.setFocusPolicy(QtCore.Qt.ClickFocus) self.xRot = 0.0 self.yRot = 0.0 self.zRot = 0.0 self.xTrans = 0.0 self.yTrans = 0.0 self.zTrans = 0.0 self.lastPos = QtCore.QPoint() self.mouseMoved = False self.mousePickRectStart = False self.ctrlPressed = False self.shiftPressed = False self.mouseRect = [] self.autoCam = False self.ortho = False self.camName = '' self.cameraPos = (0, 0, -1) self.targetPos = (0, 0, 0) self.testVertexBuffer = [] self.testColorBuffer = [] # self.vw = 0 # self.vh = 0 self.camera = Camera() self.screen = screen self.programCompiled = False self.currentFrame = 0 self.frameData = None self.groups = [] self.selectedMarkers = set([]) self.selectedGroups = set([]) self.maskDraw = set([]) self.maskTraj = set([]) self.maskTag = set([]) self.colorDict = {} self.timer = QtCore.QTimer(self) self.timer.setInterval(10) self.timer.timeout.connect(self.updateTimer) self.timer.start()
def snapshot(self): camera = Camera.get_instance() pos = self.script.find('.shef') path = 'log/' + self.script[0:pos] + '/' if not os.path.exists(path): os.mkdir(path) name = path + str(time.time()) + '.jpg' camera.save_frame(name)
class Space: def __init__(self): self.q_mode_camera = Queue.Queue() self.q_mode_com_device = Queue.Queue() self.q_com_device_out = Queue.Queue() self.camera = Camera(self.q_mode_camera) self.gps_logger = ComDevice(self.q_mode_com_device, self.q_com_device_out) self.running = True def set_mode(self, mode): print("Setting mode " + mode) self.q_mode_camera.put(mode) self.q_mode_com_device.put(mode) def shutdown(self): self.running = False self.set_mode("EXIT") print("All shut down") def run(self): self.gps_logger.start() self.camera.start() try: self.set_mode("Mode 1") time.sleep(100) self.set_mode("Mode 2") while self.running: try: msg = self.q_com_device_out.get_nowait() if msg == "Mode 3": self.set_mode("Mode 3") if msg == "Mode 4": self.set_mode("Mode 4") if msg == "Mode 5": self.set_mode("Mode 5") except Queue.Empty: None time.sleep(1) except KeyboardInterrupt: self.shutdown()
def __init__(self): self.q_mode_camera = Queue.Queue() self.q_mode_com_device = Queue.Queue() self.q_com_device_out = Queue.Queue() self.camera = Camera(self.q_mode_camera) self.gps_logger = ComDevice(self.q_mode_com_device, self.q_com_device_out) self.running = True
def __init__(self): self.set_up_graphics() self.load_object() self.set_up_glut() self.camera = Camera(0,60,0) self.camera.rotate(-75,-150,0) self.poly_view = False self.start_loop()
class JamMode(JamModeUpdate, GameMode): def __init__(self): GameMode.__init__(self) self.camera = Camera((700,400), (), 10, 100) self.court = Court() self.entities = [] self.physics = CapsuleManager(Court.getBounds()) self.totalTime = 0 self.font = pygame.font.SysFont(None, 36) self.score = [0, 0] def init(self): self.player = self.addEntity(Baller(Vec3d(0, 0, 0))) self.computer = self.addEntity(Baller(Vec3d(5, 0, 0))) self.computer.input = AIController(self.computer) self.computer.color = 0x00AAFF self.computer.net = 1 self.ball = self.addEntity(Ball(Vec3d(0, 0, 0))) def goal(self, net, points): self.score[(net + 1) / 2] += points def addEntity(self, entity): self.physics.addCapsule(entity.capsule) self.entities.append(entity) entity.register(self) return entity def draw(self, canvas): self.court.draw(self.camera, canvas) self.entities = sorted(self.entities, key=lambda entity: -entity.pos.z) for entity in self.entities: entity.draw(canvas, self.camera.toScreen(entity.pos), self.camera.getDepthModifier(entity.pos)) text = self.font.render("%d:%d" % (self.score[1], self.score[0]), False, (0, 0, 0)) canvas.blit(text, (340, 15))
def enterGame(self, task): self.createOtherVehicles("otherPlayer", 0, 0, 0) self.startGameNow() return task.done if self.gameState == self.gameStateDict["Login"]: #responseValue = 1 indicates that this state has been finished if self.responseValue == 1: print "Authentication succeeded" # Authentication succeeded self.cManager.sendRequest(Constants.CMSG_CREATE_LOBBY, ["raceroyal", "0", "1"]) self.gameState = self.gameStateDict["CreateLobby"] self.responseValue = -1 elif self.gameState == self.gameStateDict["CreateLobby"]: if self.responseValue == 1: # Lobby Created and we are already in print "Lobby Created and we are already in" self.gameState = self.gameStateDict["EnterGame"] self.responseValue = -1 self.cManager.sendRequest(Constants.CMSG_READY) elif self.responseValue == 0: #Game already created, let's join it print "Game already created, let's join it" self.cManager.sendRequest(Constants.CMSG_ENTER_GAME_NAME, "raceroyal") #self.gameState = self.gameStateDict["EnterGame"] #self.responseValue = -1 self.responseValue = -1 self.gameState = self.gameStateDict["InitializeGame"] # Everyone is in the game, we send ReqReady, and the server will send positions when every client did self.cManager.sendRequest(Constants.CMSG_READY) elif self.gameState == self.gameStateDict["EnterGame"]: if self.responseValue == 1: # When the positions are sent, an acknowledgment is sent and we begin the InitializeGame print "When the positions are sent, an acknowledgment is sent and we begin the InitializeGame" self.responseValue = -1 self.gameState = self.gameStateDict["InitializeGame"] # Everyone is in the game, we send ReqReady, and the server will send positions when every client did self.cManager.sendRequest(Constants.CMSG_READY) elif self.gameState == self.gameStateDict["InitializeGame"]: if self.responseValue == 1: print "Set up the camera" # Set up the camera self.camera = Camera(self.mainChar) self.gameState = self.gameStateDict["BeginGame"] self.cManager.sendRequest(Constants.CMSG_READY) self.responseValue = -1 elif self.gameState == self.gameStateDict["BeginGame"]: if self.responseValue == 1: print "Begin Game" #taskMgr.doMethodLater(.1, self.updateMove, 'updateMove') taskMgr.add(self.move, "moveTask") return task.done return task.cont
def put_scan(): global stepper objString = "" stepperThread = threading.Thread(target=stepper.goTop).start() #Start the upwards movement scanning = True cam = Camera(captureWidth, captureHeight, 120) #Up to 120 images will be held in the cache before discarding images from the cache #Start image computation threads threading.Thread(target=processThread, args=(transformationMatrix, laserThreshold, cam)).start() threading.Thread(target=processThread, args=(transformationMatrix, laserThreshold, cam)).start() st = time.time() while stepperThread.is_alive(): time.sleep(1) #Wait for the scan to finish scanning = False #Kill the threads f = open("test.obj", "w") f.write(objString) f.close() cam.release()
def __init__(self): GameMode.__init__(self) self.camera = Camera((700,400), (), 10, 100) self.court = Court() self.entities = [] self.physics = CapsuleManager(Court.getBounds()) self.totalTime = 0 self.font = pygame.font.SysFont(None, 36) self.score = [0, 0]
def set_up(self): self.set_up_graphics() self.set_up_lighting() self.set_up_glut() water_path = 'data/textures/water/water.bmp' self.tex_holder.hold_my_texture(water_path, 'water') self.camera = Camera(10,20,-10) self.curr_time = time.time() self.count = 0 self.poly_view = False self.load_skybox() self.building_index_list = []
def init_camera(self): self.camera_dest = pygame.Rect( LevelEditor.PADDING, LevelEditor.PADDING, self.globals.WIDTH - self.right_padding - LevelEditor.PADDING, self.globals.HEIGHT - LevelEditor.PADDING) self.camera = Camera(self.tile_engine, self.camera_dest) extra_y = self.camera_dest.height % self.tile_rect.height extra_x = self.camera_dest.width % self.tile_rect.width if extra_y > 0: self.camera_dest.height -= extra_y if extra_x > 0: self.camera_dest.width -= extra_x self.camera_dest.centery = self.globals.HEIGHT / 2
def __init__(self): self.__num = Acces.numero_acces Acces.numero_acces += 1 self.camera = Camera() self.teleporteur = Teleporteur() self.__borne = Borne() self.__pannaux = PannauxAffichage() self.__liste_abo = {} self.__liste_client = {} self.__liste_ticket = {} self.__parking = 0 self.prix_parking = 0.0 self.__placements = 0
def setup(): global prevFrame, frame, mCamera global mDetector, mCascade global POWS, GPIOS, powVals, gpioVals global mSynth sc.start() mSynth = sc.Synth("fmSynth") #mSynth = sc.Synth("PMCrotale") GPIO.setmode(GPIO.BCM) for pin in (POWS+GPIOS): GPIO.setup(pin, GPIO.OUT) mCamera = Camera(CAM_RES) mCamera.update() frame = cv2.blur(cv2.cvtColor(mCamera.frame, cv2.COLOR_RGB2GRAY), (4,4)) prevFrame = frame # Setup SimpleBlobDetector parameters. mParams = cv2.SimpleBlobDetector_Params() mParams.minThreshold = 16; mParams.maxThreshold = 32; mParams.filterByArea = True mParams.minArea = 64 mParams.maxArea = 10e3 mParams.filterByConvexity = True mParams.minConvexity = 0.001 mParams.filterByInertia = True mParams.minInertiaRatio = 0.001 mDetector = cv2.SimpleBlobDetector(mParams) mCascade = None if len(sys.argv) > 1: mCascade = cv2.CascadeClassifier(sys.argv[1]) else: print "Please provide a cascade file if you want to do face/body detection."
def __init__(self): super().__init__() self.infoObject = pygame.display.Info() self.CAM_HEIGHT = self.infoObject.current_h - 80 self.CAM_WIDTH = int(self.infoObject.current_w-100) self.num_of_creatures = 180 self.num_of_food = 100 self.game_bounds = (-5000, 5000) self.running = True # self.camera = Camera(self.CAM_WIDTH, self.CAM_HEIGHT, x=-(self.CAM_WIDTH / 2), y=-(self.CAM_HEIGHT / 2)) self.camera = Camera(self.CAM_WIDTH, self.CAM_HEIGHT, x=0, y=0, zoom=1.0) self.screen = pygame.display.set_mode((self.CAM_WIDTH, self.CAM_HEIGHT)) self.fullscreen = False # QuadTree for collision detection self.quadtree = QuadTree( bounds=( -self.WORLD_WIDTH/2, -self.WORLD_HEIGHT/2, self.WORLD_WIDTH, self.WORLD_HEIGHT), depth=9) self.ui = UserInterface(self.screen) self.dt = 0 # Will draw the quadtree overlay if true self.draw_quadtree = False self.paused = False # When the user clicks on the screen it's position will be stored here self.mouse_screen_position = None self.mouse_real_position = None # How fast everything moves self.game_speed = 1.0 self.selected_creature = None self.follow_creature = False self.breeder = Breeder() self.population_stats = StatsTracker() self.spinner = Background()
def __init__(self, engine, prompt = "", selectedSong = None, selectedLibrary = None): self.prompt = prompt self.engine = engine self.time = 0 self.lastTime = 0 self.accepted = False self.selectedIndex = 0 self.camera = Camera() self.cassetteHeight = .8 self.cassetteWidth = 4.0 self.libraryHeight = 1.2 self.libraryWidth = 4.0 self.itemAngles = None self.itemLabels = None self.selectedOffset = 0.0 self.cameraOffset = 0.0 self.selectedItem = None self.song = None self.songCountdown = 1024 self.songLoader = None self.initialItem = selectedSong self.library = selectedLibrary self.searchText = "" self.searching = False #RF-mod self.previewDisabled = self.engine.config.get("audio", "disable_preview") self.sortOrder = self.engine.config.get("game", "sort_order") self.rotationDisabled = self.engine.config.get("game", "disable_librotation") self.spinnyDisabled = self.engine.config.get("game", "disable_spinny") temp = self.engine.config.get("game", "search_key") if temp != "None": self.searchKey = ord(temp[0]) else: self.searchKey = ord('/') # Use the default library if this one doesn't exist if not self.library or not os.path.isdir(self.engine.resource.fileName(self.library)): self.library = Song.DEFAULT_LIBRARY self.loadCollection() self.engine.resource.load(self, "cassette", lambda: Mesh(self.engine.resource.fileName("cassette.dae")), synch = True) self.engine.resource.load(self, "label", lambda: Mesh(self.engine.resource.fileName("label.dae")), synch = True) self.engine.resource.load(self, "libraryMesh", lambda: Mesh(self.engine.resource.fileName("library.dae")), synch = True) self.engine.resource.load(self, "libraryLabel", lambda: Mesh(self.engine.resource.fileName("library_label.dae")), synch = True) self.engine.loadSvgDrawing(self, "background", "cassette.svg")
def __init__(self, file_name): '''Sets everything up: camera, modes, lighting, and the list of blocks''' self.camera = Camera() self.set_up_graphics() self.makeLights() self.objects = LoadWorld.load(file_name) # glMaterialfv(GL_FRONT, GL_SPECULAR, [1, 1, 1, 1]) # glMaterialfv(GL_FRONT, GL_SHININESS, [50]) glClearColor(.529,.8078,.980,0) glutDisplayFunc(self.display) glutKeyboardFunc(self.keyPressed) glutMainLoop()
def main(): # Pretty videos: fourcc = cv2.VideoWriter_fourcc(*'mp4v') kyleOutputVideo = cv2.VideoWriter('../UntrackedFiles/BallOutputKyle.mp4', fourcc, 60.0, (1920, 1080)) meganOutputVideo = cv2.VideoWriter('../UntrackedFiles/BallOutputMegan.mp4', fourcc, 60.0, (1920, 1080)) meganFilename = '../UntrackedFiles/stereoClip5_Megan.mov' kyleFilename = '../UntrackedFiles/stereoClip5_Kyle.mov' vrMegan1 = VideoReader(meganFilename) vrMegan2 = VideoReader(meganFilename) vrKyle1 = VideoReader(kyleFilename) vrKyle2 = VideoReader(kyleFilename) numFrameForward = 5 vrMegan2.setNextFrame(numFrameForward) vrKyle2.setNextFrame(numFrameForward) # find court corners: cfKyle = CourtFinder() cfMegan = CourtFinder() numFrames = int(vrMegan1.getNumFrames()) vrMegan1.setNextFrame(int(numFrames / 2)) ret, frame = vrMegan1.readFrame() cfMegan.FindCourtCorners(frame, 0) vrKyle1.setNextFrame(int(numFrames / 2)) ret, frame = vrKyle1.readFrame() cfKyle.FindCourtCorners(frame, 0) if (not cfMegan.found_corners) or not (cfKyle.found_corners): print "Couldn't find the court. Exiting." return # reset frame index to beginning vrMegan1.setNextFrame(0) vrKyle1.setNextFrame(0) frameNum = 1 meganCam = Camera("megan", cfMegan.corners_sort) kyleCam = Camera("kyle", cfKyle.corners_sort) # make a ball finder bf = BallFinder() kf = KalmanFilter(vrMegan1.framerate) csvData = [] while (True): ret1, kyleFrame1 = vrKyle1.readFrame() ret2, kyleFrame2, = vrKyle2.readFrame() ret3, meganFrame1 = vrMegan1.readFrame() ret4, meganFrame2, = vrMegan2.readFrame() if not (ret1) or not (ret2) or not (ret3) or not (ret4): print 'Ending after', frameNum - 1, 'frames.' break kyleMask, kyleRays = getBallCandidateRays(bf, kyleCam, kyleFrame1, kyleFrame2) meganMask, meganRays = getBallCandidateRays(bf, meganCam, meganFrame1, meganFrame2) # check all candidate rays for candidate balls minDist = 1000000 # TODO set inf ballPt = [] # all ball points and distances threshDist = 0.2 # rays must be within .1 m of each other for intersect ballCandidates = [] candidateCertainty = [] for kyleRay in kyleRays: for meganRay in meganRays: pt, dist, _D, _E = IntersectRays(kyleRay, meganRay) if dist < threshDist and pt[1] < 3.5: # don't include candidates clearly not valid intersect points # also don't include candidates that are clearly too high to be the ball courtBuffer = 2 if pt[0] < Camera.HALF_COURT_X + courtBuffer and pt[ 0] > -Camera.HALF_COURT_X - courtBuffer: if pt[2] < Camera.HALF_COURT_Z + 0.6: # and pt[2] > -Camera.HALF_COURT_Z - 0: ballCandidates.append(pt) candidateCertainty.append(dist) if dist < minDist: minDist = dist ballPt = pt kf.processMeas(ballCandidates, candidateCertainty) # ========== CSV and VIDEO output =========== csvTuple = list() csvTuple.append(frameNum) if np.linalg.norm(kf.sigma_k, 'fro') < 100: # valid result # Format the tuple for successful reading csvTuple.append(1) posVel = np.reshape(kf.mu_k, (1, 6))[0] posVel = np.round(posVel, 3) for val in posVel: csvTuple.append(val) for val in kyleCam.ConvertWorldToImagePosition(posVel[0:3]): csvTuple.append(val) for val in meganCam.ConvertWorldToImagePosition(posVel[0:3]): csvTuple.append(val) # Videos kyleOutFrame = kyleFrame1.copy() bf.ballPixelLoc = kyleCam.ConvertWorldToImagePosition(posVel[0:3]) kyleOutFrame = cfKyle.drawCornersOnFrame(kyleOutFrame) kyleOutFrame = bf.drawBallOnFrame(kyleOutFrame) kyleOutFrame |= kyleMask kyleOutputVideo.write(kyleOutFrame) meganOutFrame = meganFrame1.copy() meganOutFrame |= meganMask bf.ballPixelLoc = meganCam.ConvertWorldToImagePosition(posVel[0:3]) meganOutFrame = cfMegan.drawCornersOnFrame(meganOutFrame) meganOutFrame = bf.drawBallOnFrame(meganOutFrame) meganOutputVideo.write(meganOutFrame) else: # Format the tuple for unsuccessful reading csvTuple.append(0) csvData.append(list(csvTuple)) print csvTuple frameNum += 1 # <END WHILE LOOP> with open('../UntrackedFiles/ballEst.csv', 'wb') as csvfile: filewriter = csv.writer(csvfile, delimiter=',') filewriter.writerows(csvData) vrKyle1.close() vrKyle2.close() vrMegan1.close() vrMegan2.close() kyleOutputVideo.release() meganOutputVideo.release()
import PhotoViewer as pv from SingleImage import SingleImage import MatrixMethods from ObjectsSynthetic import * if __name__ == '__main__': # Part A focal_length = 35 # [mm] sensor_size = 35 # [mm] xp = 0.02 # [mm] yp = 0.01 # [mm] k1_factor = 1e-5 k2_factor = 1e-10 k1 = 5 * k1_factor k2 = 5 * k2_factor camera1 = Camera(focal_length, np.array([xp, yp]), np.array([k1, k2]), None, None, sensor_size) img1 = SingleImage(camera1) omega = np.radians(90) phi = 0 kappa = 0 X1 = 0 # [m] Y1 = 0 Z1 = 0 img1.exteriorOrientationParameters = np.array( [[X1, Y1, Z1, omega, phi, kappa]]) # Clibration field calibration_field = np.array([[-1, 5, -2], [-1, 5, 2], [1, 5, 2], [1, 5, -2], [3, 7, -2], [3, 7, 3], [0, 7, 3], [-3, 7, 3], [-3, 7, -2], [0, 5, 0]])
def __init__(self): self.ground = Ground() self.chimney = ChimneyFactory().createRandomChimney() self.light = Light() self.camera = Camera()
class World(DirectObject): gameStateDict = { "Login": 0, "CreateLobby": 4, "EnterGame": 1, "BeginGame": 2, "InitializeGame": 3 } gameState = -1 # Login , EnterGame , BeginGame responseValue = -1 currentTime = 0 idleTime = 0 mySequence = None pandaPace = None jumpState = False isWalk = False previousPos = None # used to store the mainChar pos from one frame to another host = "" port = 0 vehiclelist = {} # Stores the list of all the others players characters characters = [] def __init__(self): self.login = "******" base.setFrameRateMeter(True) #input states inputState.watchWithModifiers('forward', 'w') inputState.watchWithModifiers('left', 'a') inputState.watchWithModifiers('brake', 's') inputState.watchWithModifiers('right', 'd') inputState.watchWithModifiers('turnLeft', 'q') inputState.watchWithModifiers('turnRight', 'e') self.keyMap = { "hello": 0, "left": 0, "right": 0, "forward": 0, "backward": 0, "cam-left": 0, "cam-right": 0, "chat0": 0, "powerup": 0, "reset": 0 } base.win.setClearColor(Vec4(0, 0, 0, 1)) # Network Setup self.cManager = ConnectionManager(self) self.startConnection() #self.cManager.sendRequest(Constants.CMSG_LOGIN, ["username", "password"]) # chat box # self.chatbox = Chat(self.cManager, self) # Set up the environment # self.initializeBulletWorld(False) #self.createEnvironment() Track(self.bulletWorld) # Create the main character, Ralph self.mainCharRef = Vehicle(self.bulletWorld, (100, 10, 5, 0, 0, 0), self.login) #self.mainCharRef = Character(self, self.bulletWorld, 0, "Me") self.mainChar = self.mainCharRef.chassisNP #self.mainChar.setPos(0, 25, 16) # self.characters.append(self.mainCharRef) # self.TestChar = Character(self, self.bulletWorld, 0, "test") # self.TestChar.actor.setPos(0, 0, 0) self.previousPos = self.mainChar.getPos() taskMgr.doMethodLater(.1, self.updateMove, 'updateMove') # Set Dashboard self.dashboard = Dashboard(self.mainCharRef, taskMgr) self.floater = NodePath(PandaNode("floater")) self.floater.reparentTo(render) # Accept the control keys for movement and rotation self.accept("escape", self.doExit) self.accept("a", self.setKey, ["left", 1]) self.accept("d", self.setKey, ["right", 1]) self.accept("w", self.setKey, ["forward", 1]) self.accept("s", self.setKey, ["backward", 1]) self.accept("arrow_left", self.setKey, ["cam-left", 1]) self.accept("arrow_right", self.setKey, ["cam-right", 1]) self.accept("a-up", self.setKey, ["left", 0]) self.accept("d-up", self.setKey, ["right", 0]) self.accept("w-up", self.setKey, ["forward", 0]) self.accept("s-up", self.setKey, ["backward", 0]) self.accept("arrow_left-up", self.setKey, ["cam-left", 0]) self.accept("arrow_right-up", self.setKey, ["cam-right", 0]) self.accept("h", self.setKey, ["hello", 1]) self.accept("h-up", self.setKey, ["hello", 0]) self.accept("0", self.setKey, ["chat0", 1]) self.accept("0-up", self.setKey, ["chat0", 0]) self.accept("1", self.setKey, ["powerup", 1]) self.accept("1-up", self.setKey, ["powerup", 0]) self.accept("2", self.setKey, ["powerup", 2]) self.accept("2-up", self.setKey, ["powerup", 0]) self.accept("3", self.setKey, ["powerup", 3]) self.accept("3-up", self.setKey, ["powerup", 0]) self.accept("r", self.doReset) self.accept("p", self.setTime) #taskMgr.add(self.move, "moveTask") # Game state variables self.isMoving = False # Sky Dome self.sky = SkyDome() # Set up the camera self.camera = Camera(self.mainChar) #base.disableMouse() #base.camera.setPos(self.mainChar.getX(), self.mainChar.getY() + 10, self.mainChar.getZ() + 2) # Create some lighting ambientLight = AmbientLight("ambientLight") ambientLight.setColor(Vec4(.3, .3, .3, 1)) directionalLight = DirectionalLight("directionalLight") directionalLight.setDirection(Vec3(-5, -5, -5)) directionalLight.setColor(Vec4(1, 1, 1, 1)) directionalLight.setSpecularColor(Vec4(1, 1, 1, 1)) directionalLight2 = DirectionalLight("directionalLight2") directionalLight2.setDirection(Vec3(5, 5, -5)) directionalLight2.setColor(Vec4(1, 1, 1, 1)) directionalLight2.setSpecularColor(Vec4(1, 1, 1, 1)) render.setLight(render.attachNewNode(ambientLight)) render.setLight(render.attachNewNode(directionalLight)) render.setLight(render.attachNewNode(directionalLight2)) # Game initialisation self.gameState = self.gameStateDict["Login"] self.responseValue = -1 self.cManager.sendRequest(Constants.CMSG_LOGIN, [self.login, "1234"]) taskMgr.add(self.enterGame, "EnterGame") # Create Powerups self.createPowerups() taskMgr.add(self.powerups.checkPowerPickup, "checkPowerupTask") taskMgr.add(self.usePowerup, "usePowerUp") def createOtherVehicles(self, username, carType, carPaint, carTires): if username in self.vehiclelist.keys(): print "Player Already rendered" else: print "Creating copie other player @ 60" char = Vehicle(self.bulletWorld, (100, 10, 5, 0, 0, 0), username) self.characters.append(char) self.vehiclelist[username] = char def usePowerup(self, task): if self.keyMap["powerup"] == 1: self.mainCharRef.usePowerup(0) elif self.keyMap["powerup"] == 2: self.mainCharRef.usePowerup(1) elif self.keyMap["powerup"] == 3: self.mainCharRef.usePowerup(2) return task.cont def createPowerups(self): self.powerups = PowerupManager(self.cManager, self.characters) def use_powerup3(self): self.use_powerup(3) def setTime(self): self.cManager.sendRequest(Constants.CMSG_TIME) def use_powerup(self, num): if self.mainCharRef.power_ups[num - 1] == 0: print "power-up slot empty" else: print "power-up", num, "used" def doExit(self): self.cleanup() sys.exit(1) def cleanup(self): self.cManager.sendRequest(Constants.CMSG_DISCONNECT) self.cManager.closeConnection() self.world = None self.outsideWorldRender.removeNode() def doReset(self): self.mainCharRef.reset() def enterGame(self, task): self.startGameNow() return task.done if self.gameState == self.gameStateDict["Login"]: #responseValue = 1 indicates that this state has been finished if self.responseValue == 1: # Authentication succeeded #self.cManager.sendRequest(Constants.CMSG_CREATE_LOBBY, ["raceroyal","0","1"]) self.gameState = self.gameStateDict["CreateLobby"] #self.responseValue = -1 elif self.gameState == self.gameStateDict["CreateLobby"]: if self.responseValue == 1: print "Lobby Created and we are already in" # Lobby Created and we are already in self.gameState = self.gameStateDict["EnterGame"] self.responseValue = -1 elif self.responseValue == 0: print "Game already created, let's join it" #Game already created, let's join it self.cManager.sendRequest(Constants.CMSG_ENTER_GAME_NAME, "raceroyal") self.gameState = self.gameStateDict["EnterGame"] self.responseValue = -1 self.startGameNow() #self.gameState = self.gameStateDict["InitializeGame"] # Everyone is in the game, we send ReqReady, and the server will send positions when every client did #self.cManager.sendRequest(Constants.CMSG_READY) elif self.gameState == self.gameStateDict["EnterGame"]: if self.responseValue == 1: # When the positions are sent, an acknowledgment is sent and we begin the InitializeGame self.responseValue = -1 self.gameState = self.gameStateDict["InitializeGame"] # Everyone is in the game, we send ReqReady, and the server will send positions when every client did self.cManager.sendRequest(Constants.CMSG_READY) elif self.gameState == self.gameStateDict["InitializeGame"]: if self.responseValue == 1: # Set up the camera self.camera = Camera(self.mainChar) self.gameState = self.gameStateDict["BeginGame"] self.cManager.sendRequest(Constants.CMSG_READY) self.responseValue = -1 elif self.gameState == self.gameStateDict["BeginGame"]: if self.responseValue == 1: taskMgr.add(self.move, "moveTask") return task.done return task.cont #return task.done def startGameNow(self): self.camera = Camera(self.mainChar) taskMgr.doMethodLater(.1, self.updateMove, 'updateMove') taskMgr.add(self.move, "moveTask") def createEnvironment(self): self.environ = loader.loadModel("models/square") self.environ.reparentTo(render) #self.environ.setPos(0, 0, 10) self.environ.setScale(500, 500, 1) self.moon_tex = loader.loadTexture("models/moon_1k_tex.jpg") self.environ.setTexture(self.moon_tex, 1) shape = BulletPlaneShape(Vec3(0, 0, 1), 0) node = BulletRigidBodyNode('Ground') node.addShape(shape) np = render.attachNewNode(node) #np.setPos(0, 0, 0) self.bulletWorld.attachRigidBody(node) self.visNP = loader.loadModel('models/track.egg') self.tex = loader.loadTexture("models/tex/Main.png") self.visNP.setTexture(self.tex) geom = self.visNP.findAllMatches('**/+GeomNode').getPath( 0).node().getGeom(0) mesh = BulletTriangleMesh() mesh.addGeom(geom) trackShape = BulletTriangleMeshShape(mesh, dynamic=False) body = BulletRigidBodyNode('Bowl') self.visNP.node().getChild(0).addChild(body) bodyNP = render.anyPath(body) bodyNP.node().addShape(trackShape) bodyNP.node().setMass(0.0) bodyNP.setTexture(self.tex) self.bulletWorld.attachRigidBody(bodyNP.node()) self.visNP.reparentTo(render) self.bowlNP = bodyNP self.visNP.setScale(70) def initializeBulletWorld(self, debug=False): self.outsideWorldRender = render.attachNewNode('world') self.bulletWorld = BulletWorld() self.bulletWorld.setGravity(Vec3(0, 0, -9.81)) if debug: self.debugNP = self.outsideWorldRender.attachNewNode( BulletDebugNode('Debug')) self.debugNP.show() self.debugNP.node().showWireframe(True) self.debugNP.node().showConstraints(True) self.debugNP.node().showBoundingBoxes(True) self.debugNP.node().showNormals(False) self.bulletWorld.setDebugNode(self.debugNP.node()) def makeCollisionNodePath(self, nodepath, solid): ''' Creates a collision node and attaches the collision solid to the supplied NodePath. Returns the nodepath of the collision node. ''' # Creates a collision node named after the name of the NodePath. collNode = CollisionNode("%s c_node" % nodepath.getName()) collNode.addSolid(solid) collisionNodepath = nodepath.attachNewNode(collNode) return collisionNodepath # Records the state of the arrow keys def setKey(self, key, value): self.keyMap[key] = value # Accepts arrow keys to move either the player or the menu cursor, # Also deals with grid checking and collision detection def getDist(self): mainCharX = self.mainChar.getPos().x mainCharY = self.mainChar.getPos().y pandaX = self.pandaActor2.getPos().x pandaY = self.pandaActor2.getPos().y dist = math.sqrt( abs(mainCharX - pandaX)**2 + abs(mainCharY - pandaY)**2) return dist def move(self, task): self.camera.update(self.mainChar) dt = globalClock.getDt() forces = self.mainCharRef.processInput(inputState, dt) moving = self.mainCharRef.chassisNP.getPos() print "Forces received& sending: ", moving[0], moving[1], moving[2] self.cManager.sendRequest(Constants.CMSG_MOVE, [ forces[0], forces[1], forces[2], moving.getX(), moving.getY(), moving.getZ(), self.mainCharRef.chassisNP.getH(), self.mainCharRef.chassisNP.getP(), self.mainCharRef.chassisNP.getR() ]) self.bulletWorld.doPhysics(dt, 10, 0.02) self.bulletWorld.doPhysics(dt) return task.cont def startConnection(self): """Create a connection to the remote host. If a connection cannot be created, it will ask the user to perform additional retries. """ if self.cManager.connection == None: if not self.cManager.startConnection(): return False return True def listFromInputState(self, inputState): # index 0 == forward # index 1 == brake # index 2 == right # index 3 == left result = [0, 0, 0, 0] if inputState.isSet('forward'): result[0] = 1 if inputState.isSet('brake'): result[1] = 1 if inputState.isSet('right'): result[2] = 1 if inputState.isSet('left'): result[3] = 1 return result def updateMove(self, task): if self.isMoving == True: moving = self.mainChar.getPos() - self.previousPos self.cManager.sendRequest(Constants.CMSG_MOVE, [ moving.getX(), moving.getY(), moving.getZ(), self.mainCharRef.actor.getH(), self.mainCharRef.actor.getP(), self.mainCharRef.actor.getR(), self.listFromInputState(inputState) ]) # self.cManager.sendRequest(Constants.RAND_FLOAT, 1.0) self.previousPos = self.mainChar.getPos() return task.again
class PongHauKi: def __init__(self, playerA1, playerA2, playerB1, playerB2, tabuleiro, lights): self.window_width = 1280 self.window_height = 620 self.cube_obj = Loader("./resources/models/cube.obj") player1_obj = Loader("./resources/models/drone.obj") player2_obj = Loader("./resources/models/galinha.obj") galinha_texture = Texture("./resources/textures/galinha.png") mech_texture = Texture("./resources/textures/mech.png") self.camera = Camera(self.window_width, self.window_height) self.camera.view['position'] = [0.0, 1.0, 0.0] self.camera.orthogonal = True self.camera.update() self.nave = Object(player1_obj, self.camera, mech_texture) self.nave.scale(0.4, 0.4, 0.4) self.galinha = Object(player2_obj, self.camera, galinha_texture) self.nave.model['rotation'][2] += 5 self.galinha.model['rotation'][2] += 5 self.galinha_win = Label("Galinha Wins", "kashima", 40, [1, 1, 1], [-1.5, 0, 0], self.camera) self.nave_win = Label("Nave Wins", "kashima", 40, [1, 1, 1], [-1.5, 0, 0], self.camera) self.playerA1 = playerA1 self.playerA2 = playerA2 self.playerB1 = playerB1 self.playerB2 = playerB2 self.tabuleiro = tabuleiro self.light = lights[0] self.playerA1.model['translation'] = [-0.8, 0.2, 0.8] self.playerA2.model['translation'] = [-0.8, 0.2, -0.8] self.playerB1.model['translation'] = [0.8, 0.2, -0.8] self.playerB2.model['translation'] = [0.8, 0.2, 0.8] self.positions = [[0.8, 0.2, -0.8], [-0.8, 0.2, 0.8], [0.8, 0.2, 0.8], [-0.8, 0.2, -0.8], [0.0, 0.2, 0.0]] self.current_player = "playerA" self.selected_piece = self.playerA1 self.free_position = self.positions[4] self.winner = None self.plays_count = 0 self.can_move_tree = { str(self.positions[0]): { str(self.positions[0]): False, str(self.positions[1]): False, str(self.positions[2]): True, str(self.positions[3]): True, str(self.positions[4]): True }, str(self.positions[1]): { str(self.positions[0]): False, str(self.positions[1]): False, str(self.positions[2]): True, str(self.positions[3]): False, str(self.positions[4]): True }, str(self.positions[2]): { str(self.positions[0]): True, str(self.positions[1]): True, str(self.positions[2]): False, str(self.positions[3]): False, str(self.positions[4]): True }, str(self.positions[3]): { str(self.positions[0]): True, str(self.positions[1]): False, str(self.positions[2]): False, str(self.positions[3]): False, str(self.positions[4]): True }, str(self.positions[4]): { str(self.positions[0]): True, str(self.positions[1]): True, str(self.positions[2]): True, str(self.positions[3]): True, str(self.positions[4]): False } } self.fire_work1 = FireWork(self.camera, self.cube_obj) self.fire_work2 = FireWork(self.camera, self.cube_obj) self.fire_work3 = FireWork(self.camera, self.cube_obj) self.render_count = 0 def have_winner(self): if self.current_player == "playerA": return (not self.can_move(self.playerA1.model['translation'], self.free_position) and not self.can_move(self.playerA2.model['translation'], self.free_position)) elif self.current_player == "playerB": return (not self.can_move(self.playerB1.model['translation'], self.free_position) and not self.can_move(self.playerB2.model['translation'], self.free_position)) def can_move(self, from_position, to_position): return self.can_move_tree[str(from_position)][str(to_position)] def select_piece(self): self.light.color = [1, 1, 0.5] if self.selected_piece == self.playerA1: self.selected_piece = self.playerA2 elif self.selected_piece == self.playerA2: self.selected_piece = self.playerA1 elif self.selected_piece == self.playerB1: self.selected_piece = self.playerB2 elif self.selected_piece == self.playerB2: self.selected_piece = self.playerB1 def move_piece(self): current_position = self.selected_piece.model['translation'].copy() if (self.can_move(current_position, self.free_position)): self.selected_piece.target_position = self.free_position self.free_position = current_position previous_player = self.current_player if self.current_player == "playerA": self.current_player = "playerB" self.selected_piece = self.playerB1 elif self.current_player == "playerB": self.current_player = "playerA" self.selected_piece = self.playerA1 if self.have_winner(): self.winner = previous_player else: self.plays_count += 1 else: self.light.color = [1, 0, 0] def handle_event(self, event): if event.type == pygame.MOUSEBUTTONDOWN: if event.button == 1 or event.button == 3: self.select_piece() if event.type == pygame.KEYDOWN: if event.key == pygame.K_SPACE: self.move_piece() def restart(self): self.playerA1.model['translation'] = [-0.8, 0.2, 0.8] self.playerA1.target_position = None self.playerA2.model['translation'] = [-0.8, 0.2, -0.8] self.playerA2.target_position = None self.playerB1.model['translation'] = [0.8, 0.2, -0.8] self.playerB1.target_position = None self.playerB2.model['translation'] = [0.8, 0.2, 0.8] self.playerB2.target_position = None self.free_position = self.positions[4] self.winner = None self.current_player = "playerA" self.selected_piece = self.playerA1 self.plays_count = 0 self.render_count = 0 def update(self, renderer): self.light.set_position(self.selected_piece.model['translation']) self.playerA1.update() self.playerA2.update() self.playerB1.update() self.playerB2.update() if self.render_count > 35: self.fire_work1 = FireWork(self.camera, self.cube_obj) self.fire_work2 = FireWork(self.camera, self.cube_obj) self.fire_work3 = FireWork(self.camera, self.cube_obj) self.render_count = 0 if self.winner == "playerA": renderer.render_with_lights(self.nave) self.nave.model['rotation'][0] += 0.1 self.nave_win.render(renderer) self.fire_work1.render(renderer) self.fire_work2.render(renderer) self.fire_work3.render(renderer) self.render_count += 1 elif self.winner == "playerB": renderer.render_with_lights(self.galinha) self.galinha.model['rotation'][0] += 0.1 self.galinha_win.render(renderer) self.fire_work1.render(renderer) self.fire_work2.render(renderer) self.fire_work3.render(renderer) self.render_count += 1
class Stereo: world = World() camera_l = Camera() camera_r = Camera() image = Image(1, 1) def set_camera(self, camera=Camera()): if camera == None: camera = Camera() crp = camera.o.dup().add(camera.right, 0.1) crf = camera.focus.dup().add(camera.right, 0.1) clp = camera.o.dup().add(camera.right, -0.1) clf = camera.focus.dup().add(camera.right, -0.1) self.camera_r = camera.dup().set_focus(crf).set_position(crp) self.camera_l = camera.dup().set_focus(clf).set_position(clp) return self def set_world(self, world=World()): self.world = world return self def __init__(self, world=None, camera=None): self.world = world self.set_camera(camera) self._drawn = False self.image = None def draw(self, passes=8): if self.world == None: self.set_world() ppu = self.camera_r.ppu w = int(ppu * self.camera_r.width) width = 2 * w height = int(ppu * self.camera_r.height) self.image = Image(width, height) c = Color() for y in range(height): print 'drawing line', y + 1, 'of', height for x in range(w): # draw pixel from left camera c.set_rgb(0.0, 0.0, 0.0) for p in range(passes): c = c + self.world.sample(self.camera_l.get_ray(x, y)) self.image.set_pixel(x, y, c.dim(1.0 / passes)) # draw pixel from right camera c.set_rgb(0.0, 0.0, 0.0) for p in range(passes): c = c + self.world.sample(self.camera_r.get_ray(x, y)) self.image.set_pixel(x + w, y, c.dim(1.0 / passes)) self._drawn = True return self def write(self, filename=_default_filename, gamma=None): if not self._drawn: raise self.image if not gamma == None: self.image.gamma(gamma) print 'encoding as {}...'.format(filename) self.image.toPNG().write(filename) print ' ALL DONE!' return self
for y in range(len(mapToRender)): builtRow = "" for x in range(len(mapToRender[y])): builtRow += mapToRender[y][x] print(builtRow) self.culledMapData = mapToRender if __name__ == "__main__": g = LevelGenerator() g.GenerateStartingRooms(5, 5, 1) cam = Camera(49, 11) playerPos = V2(0,0) cam.Update(playerPos) #g.DrawRooms(cam) while True: g.DrawRooms(cam) move = input() s = 5 if move == "w": playerPos.y -= 1 * s elif move == "s":
response = camera.updateCamera(buildQueryObject(queryString)) else: response = camera.getState() if isinstance(response, object) or isinstance(response, list): response = dumps(response, separators=(',', ':')) response = response.encode('utf-8') self.send_response(200) self.send_header('Content-Type', 'text/plain') self.send_header('Content-Length', len(response)) self.end_headers() self.wfile.write(response) else: self.send_error(404) self.end_headers() class StreamingServer(socketserver.ThreadingMixIn, server.HTTPServer): allow_reuse_address = True daemon_threads = True camera = Camera() try: address = ('', PORT) server = StreamingServer(address, StreamingHandler) server.serve_forever() finally: camera.close()
(image_height, image_width) = im_greyscale_reference.shape depth_factor = 5000.0 use_ndc = True im_depth_reference /= depth_factor im_depth_target /= depth_factor se3_identity = np.identity(4, dtype=Utils.matrix_data_type) intrinsic_identity = Intrinsic.Intrinsic(1, 1, image_width / 2, image_height / 2) if use_ndc: intrinsic_identity = Intrinsic.Intrinsic(1, 1, 1 / 2, 1 / 2) # for ndc camera_reference = Camera.Camera(intrinsic_identity, se3_identity) camera_target = Camera.Camera(intrinsic_identity, se3_identity) # We only need the gradients of the target frame frame_reference = Frame.Frame(im_greyscale_reference, im_depth_reference, camera_reference, False) frame_target = Frame.Frame(im_greyscale_target, im_depth_target, camera_target, True) #visualizer = Visualizer.Visualizer(photometric_solver) SE3_est = Solver.solve_photometric(frame_reference, frame_target, threadLock=None, pose_estimate_list=None, max_its=20000,
def __init__(self): self.login = "******" base.setFrameRateMeter(True) #input states inputState.watchWithModifiers('forward', 'w') inputState.watchWithModifiers('left', 'a') inputState.watchWithModifiers('brake', 's') inputState.watchWithModifiers('right', 'd') inputState.watchWithModifiers('turnLeft', 'q') inputState.watchWithModifiers('turnRight', 'e') self.keyMap = { "hello": 0, "left": 0, "right": 0, "forward": 0, "backward": 0, "cam-left": 0, "cam-right": 0, "chat0": 0, "powerup": 0, "reset": 0 } base.win.setClearColor(Vec4(0, 0, 0, 1)) # Network Setup self.cManager = ConnectionManager(self) self.startConnection() #self.cManager.sendRequest(Constants.CMSG_LOGIN, ["username", "password"]) # chat box # self.chatbox = Chat(self.cManager, self) # Set up the environment # self.initializeBulletWorld(False) #self.createEnvironment() Track(self.bulletWorld) # Create the main character, Ralph self.mainCharRef = Vehicle(self.bulletWorld, (100, 10, 5, 0, 0, 0), self.login) #self.mainCharRef = Character(self, self.bulletWorld, 0, "Me") self.mainChar = self.mainCharRef.chassisNP #self.mainChar.setPos(0, 25, 16) # self.characters.append(self.mainCharRef) # self.TestChar = Character(self, self.bulletWorld, 0, "test") # self.TestChar.actor.setPos(0, 0, 0) self.previousPos = self.mainChar.getPos() taskMgr.doMethodLater(.1, self.updateMove, 'updateMove') # Set Dashboard self.dashboard = Dashboard(self.mainCharRef, taskMgr) self.floater = NodePath(PandaNode("floater")) self.floater.reparentTo(render) # Accept the control keys for movement and rotation self.accept("escape", self.doExit) self.accept("a", self.setKey, ["left", 1]) self.accept("d", self.setKey, ["right", 1]) self.accept("w", self.setKey, ["forward", 1]) self.accept("s", self.setKey, ["backward", 1]) self.accept("arrow_left", self.setKey, ["cam-left", 1]) self.accept("arrow_right", self.setKey, ["cam-right", 1]) self.accept("a-up", self.setKey, ["left", 0]) self.accept("d-up", self.setKey, ["right", 0]) self.accept("w-up", self.setKey, ["forward", 0]) self.accept("s-up", self.setKey, ["backward", 0]) self.accept("arrow_left-up", self.setKey, ["cam-left", 0]) self.accept("arrow_right-up", self.setKey, ["cam-right", 0]) self.accept("h", self.setKey, ["hello", 1]) self.accept("h-up", self.setKey, ["hello", 0]) self.accept("0", self.setKey, ["chat0", 1]) self.accept("0-up", self.setKey, ["chat0", 0]) self.accept("1", self.setKey, ["powerup", 1]) self.accept("1-up", self.setKey, ["powerup", 0]) self.accept("2", self.setKey, ["powerup", 2]) self.accept("2-up", self.setKey, ["powerup", 0]) self.accept("3", self.setKey, ["powerup", 3]) self.accept("3-up", self.setKey, ["powerup", 0]) self.accept("r", self.doReset) self.accept("p", self.setTime) #taskMgr.add(self.move, "moveTask") # Game state variables self.isMoving = False # Sky Dome self.sky = SkyDome() # Set up the camera self.camera = Camera(self.mainChar) #base.disableMouse() #base.camera.setPos(self.mainChar.getX(), self.mainChar.getY() + 10, self.mainChar.getZ() + 2) # Create some lighting ambientLight = AmbientLight("ambientLight") ambientLight.setColor(Vec4(.3, .3, .3, 1)) directionalLight = DirectionalLight("directionalLight") directionalLight.setDirection(Vec3(-5, -5, -5)) directionalLight.setColor(Vec4(1, 1, 1, 1)) directionalLight.setSpecularColor(Vec4(1, 1, 1, 1)) directionalLight2 = DirectionalLight("directionalLight2") directionalLight2.setDirection(Vec3(5, 5, -5)) directionalLight2.setColor(Vec4(1, 1, 1, 1)) directionalLight2.setSpecularColor(Vec4(1, 1, 1, 1)) render.setLight(render.attachNewNode(ambientLight)) render.setLight(render.attachNewNode(directionalLight)) render.setLight(render.attachNewNode(directionalLight2)) # Game initialisation self.gameState = self.gameStateDict["Login"] self.responseValue = -1 self.cManager.sendRequest(Constants.CMSG_LOGIN, [self.login, "1234"]) taskMgr.add(self.enterGame, "EnterGame") # Create Powerups self.createPowerups() taskMgr.add(self.powerups.checkPowerPickup, "checkPowerupTask") taskMgr.add(self.usePowerup, "usePowerUp")
class Editor(Layer, KeyListener): """Song editor layer.""" def __init_str(self, engine, songName = None, libraryName = DEFAULT_LIBRARY): self.engine = engine self.time = 0.0 self.guitar = Guitar(self.engine, editorMode = True) self.controls = Player.Controls() self.camera = Camera() self.pos = 0.0 self.snapPos = 0.0 self.scrollPos = 0.0 self.scrollSpeed = 0.0 self.newNotes = None self.newNotePos = 0.0 self.song = None self.engine.loadSvgDrawing(self, "background", "editor.svg") self.modified = False self.songName = songName self.libraryName = libraryName self.heldFrets = set() self.spinnyDisabled = self.engine.config.get("game", "disable_spinny") mainMenu = [ (str("Save Song"), self.save), (str("Set Song Name"), self.setSongName), (str("Set Artist Name"), self.setArtistName), (str("Set Beats per Minute"), self.setBpm), (str("Estimate Beats per Minute"), self.estimateBpm), (str("Set A/V delay"), self.setAVDelay), (str("Set Cassette Color"), self.setCassetteColor), (str("Set Cassette Label"), self.setCassetteLabel), (str("Editing Help"), self.help), (str("Quit to Main Menu"), self.quit), ] self.menu = Menu(self.engine, mainMenu) def save(self): if not self.modified: Dialogs.showMessage(self.engine, str("There are no changes to save.")) return def save(): self.song.save() self.modified = False self.engine.resource.load(function = save) Dialogs.showLoadingScreen(self.engine, lambda: not self.modified, text = str("Saving...")) Dialogs.showMessage(self.engine, str("'%s' saved.") % self.song.info.name) def help(self): Dialogs.showMessage(self.engine, str("Editing keys: ") + str("Arrows - Move cursor, ") + str("Space - Play/pause song, ") + str("Enter - Make note (hold and move for long notes), ") + str("Delete - Delete note, ") + str("Page Up/Down - Change difficulty")) def setSongName(self): name = Dialogs.getText(self.engine, str("Enter Song Name"), self.song.info.name) if name: self.song.info.name = name self.modified = True def setArtistName(self): name = Dialogs.getText(self.engine, str("Enter Artist Name"), self.song.info.artist) if name: self.song.info.artist = name self.modified = True def setAVDelay(self): delay = Dialogs.getText(self.engine, str("Enter A/V delay in milliseconds"), unicode(self.song.info.delay)) if delay: try: self.song.info.delay = int(delay) self.modified = True except ValueError: Dialogs.showMessage(self.engine, str("That isn't a number.")) def setBpm(self): bpm = Dialogs.getText(self.engine, str("Enter Beats per Minute Value"), unicode(self.song.bpm)) if bpm: try: self.song.setBpm(float(bpm)) self.modified = True except ValueError: Dialogs.showMessage(self.engine, str("That isn't a number.")) def estimateBpm(self): bpm = Dialogs.estimateBpm(self.engine, self.song, str("Tap the Space bar to the beat of the song. Press Enter when done or Escape to cancel.")) if bpm is not None: self.song.setBpm(bpm) self.modified = True def setCassetteColor(self): if self.song.info.cassetteColor: color = Theme.colorToHex(self.song.info.cassetteColor) else: color = "" color = Dialogs.getText(self.engine, str("Enter cassette color in HTML (#RRGGBB) format."), color) if color: try: self.song.info.setCassetteColor(Theme.hexToColor(color)) self.modified = True except ValueError: Dialogs.showMessage(self.engine, str("That isn't a color.")) def setCassetteLabel(self): label = Dialogs.chooseFile(self.engine, masks = ["*.png"], prompt = str("Choose a 256x128 PNG format label image.")) if label: songPath = self.engine.resource.fileName("songs", self.songName, writable = True) shutil.copyfile(label, os.path.join(songPath, "label.png")) self.modified = True def shown(self): self.engine.input.addKeyListener(self) if not self.songName: self.libraryName, self.songName = Dialogs.chooseSong(self.engine) if not self.songName: self.engine.view.popLayer(self) return self.engine.resource.load(self, "song", lambda: loadSong(self.engine, self.songName, seekable = True, library = self.libraryName)) Dialogs.showLoadingScreen(self.engine, lambda: self.song, text = str("Loading song...")) def hidden(self): if self.song: self.song.stop() self.engine.input.removeKeyListener(self) #self.engine.view.pushLayer(MainMenu.MainMenu(self.engine)) self.engine.view.pushLayer(self.engine.mainMenu) #rchiav: use already-existing MainMenu instance def controlPressed(self, control): if not self.song: return if control in Player.UPS: self.guitar.selectPreviousString() elif control in Player.DOWNS: self.guitar.selectNextString() elif control in Player.LEFTS: self.pos = self.snapPos - self.song.period / 4 elif control in Player.RIGHTS: self.pos = self.snapPos + self.song.period / 4 elif control in KEYS: self.heldFrets.add(KEYS.index(control)) elif control in Player.ACTION1S + Player.ACTION2S: self.newNotePos = self.snapPos # Add notes for the frets that are held down or for the selected string. if self.heldFrets: self.newNotes = [Note(f, self.song.period / 4) for f in self.heldFrets] else: self.newNotes = [Note(self.guitar.selectedString, self.song.period / 4)] self.modified = True def controlReleased(self, control): if not self.song: return if control in Player.ACTION1S + Player.ACTION2S and self.newNotes and not self.heldFrets: self.newNotes = [] elif control in KEYS: self.heldFrets.remove(KEYS.index(control)) if not self.heldFrets and self.newNotes: self.newNotes = [] def quit(self): self.engine.view.popLayer(self) self.engine.view.popLayer(self.menu) def keyPressed(self, key, unicode): c = self.engine.input.controls.getMapping(key) if c in Player.CANCELS: self.engine.view.pushLayer(self.menu) elif key == pygame.K_PAGEDOWN and self.song: d = self.song.difficulty[0] v = difficulties.values() self.song.difficulty[0] = v[(v.index(d) + 1) % len(v)] elif key == pygame.K_PAGEUP and self.song: d = self.song.difficulty[0] v = difficulties.values() self.song.difficulty[0] = v[(v.index(d) - 1) % len(v)] elif key == pygame.K_DELETE and self.song: # gather up all events that intersect the cursor and delete the ones on the selected string t1 = self.snapPos t2 = self.snapPos + self.song.period / 4 e = [(time, event) for time, event in self.song.track[0].getEvents(t1, t2) if isinstance(event, Note)] for time, event in e: if event.number == self.guitar.selectedString: self.song.track[0].removeEvent(time, event) self.modified = True elif key == pygame.K_SPACE and self.song: if self.song.isPlaying(): self.song.stop() else: self.song.play(start = self.pos) c = self.controls.keyPressed(key) if c: self.controlPressed(c) return True def keyReleased(self, key): c = self.controls.keyReleased(key) if c: self.controlReleased(c) return True def run(self, ticks): self.time += ticks / 50.0 if not self.song: return self.guitar.run(ticks, self.scrollPos, self.controls) if not self.song.isPlaying(): if (self.controls.getState(Player.RIGHT) or self.controls.getState(Player.PLAYER_2_RIGHT)) and not (self.controls.getState(Player.LEFT) or self.controls.getState(Player.PLAYER_2_LEFT)): self.pos += self.song.period * self.scrollSpeed self.scrollSpeed += ticks / 4096.0 elif (self.controls.getState(Player.LEFT) or self.controls.getState(Player.PLAYER_2_LEFT)) and not (self.controls.getState(Player.RIGHT) or self.controls.getState(Player.PLAYER_2_RIGHT)): self.pos -= self.song.period * self.scrollSpeed self.scrollSpeed += ticks / 4096.0 else: self.scrollSpeed = 0 else: self.pos = self.song.getPosition() self.pos = max(0, self.pos) quarterBeat = int(self.pos / (self.song.period / 4) + .5) self.snapPos = quarterBeat * (self.song.period / 4) # note adding if self.newNotes: if self.snapPos < self.newNotePos: self.newNotes = [] for note in self.newNotes: self.song.track[0].removeEvent(self.newNotePos, note) note.length = max(self.song.period / 4, self.snapPos - self.newNotePos) # remove all notes under the this new note oldNotes = [(time, event) for time, event in self.song.track[0].getEvents(self.newNotePos, self.newNotePos + note.length) if isinstance(event, Note)] for time, event in oldNotes: if event.number == note.number: self.song.track[0].removeEvent(time, event) if time < self.newNotePos: event.length = self.newNotePos - time self.song.track[0].addEvent(time, event) self.song.track[0].addEvent(self.newNotePos, note) if self.song.isPlaying(): self.scrollPos = self.pos else: self.scrollPos = (self.scrollPos + self.snapPos) / 2.0 def render(self, visibility, topMost): if not self.song: return v = 1.0 - ((1 - visibility) ** 2) # render the background t = self.time / 100 + 34 w, h, = self.engine.view.geometry[2:4] r = .5 if self.spinnyDisabled != True and Theme.spinnyEditorDisabled: self.background.transform.reset() self.background.transform.translate(w / 2 + math.sin(t / 2) * w / 2 * r, h / 2 + math.cos(t) * h / 2 * r) self.background.transform.rotate(-t) self.background.transform.scale(math.sin(t / 8) + 2, math.sin(t / 8) + 2) self.background.draw() self.camera.target = ( 2, 0, 5.5) self.camera.origin = (-2, 9, 5.5) glMatrixMode(GL_PROJECTION) glLoadIdentity() gluPerspective(60, 4.0 / 3.0, 0.1, 1000) glMatrixMode(GL_MODELVIEW) glLoadIdentity() self.camera.apply() self.guitar.render(v, self.song, self.scrollPos, self.controls) self.engine.view.setOrthogonalProjection(normalize = True) font = self.engine.data.font try: Theme.setSelectedColor() w, h = font.getStringSize(" ") if self.song.isPlaying(): status = str("Playing") else: status = str("Stopped") t = "%d.%02d'%03d" % (self.pos / 60000, (self.pos % 60000) / 1000, self.pos % 1000) font.render(t, (.05, .05 - h / 2)) font.render(status, (.05, .05 + h / 2)) font.render(unicode(self.song.difficulty[0]), (.05, .05 + 3 * h / 2)) Theme.setBaseColor() text = self.song.info.name + (self.modified and "*" or "") Dialogs.wrapText(font, (.5, .05 - h / 2), text) finally: self.engine.view.resetProjection()
def init_camera(): K = Camera(W, H, 0) return K
def __init__(self, *args, **kwargs): kwargs['y_length'] = Y_LENGTH kwargs['x_length'] = X_LENGTH Camera.__init__(self, *args, **kwargs) self.x_lim = X_LENGTH
def TrackImages(): """ Track the face objects through the camera If system cannot recognize the actual or trained faces, it will show the "Unknown". Otherwise, it will be showing the real name and ID over the actual face detected. :return: None """ # Loading recognizer recognizer = cv2.face.LBPHFaceRecognizer_create() # Read data from Trainer.yml recognizer.read("../ModelTrainer/Trainer.yml") # Read data from StdentDetails.csv dataset_file = pd.read_csv("../Students/StudentsList.csv") # Create a video capture object cam = Camera(0) # Select the font and it will be showing the name of person font_cv = cv2.FONT_HERSHEY_SIMPLEX col_names = ['Id', 'Name', 'Date', 'Time'] attendance = pd.DataFrame(columns=col_names) while True: # Prepare camera and get frames (images) img, gray = cam.getFrames() # Detect the face in the object faces = detector.detectMultiScale(gray, 1.05, 5) # Create a rectangle over the face and print the for (x, y, w, h) in faces: cv2.rectangle(img, (x, y), (x + w, y + h), (0, 128, 255), 2) # Predict using the confidence Id, confident = recognizer.predict(gray[y:y + h, x:x + w]) if confident < 50: # Create a time object ts = time.time() # Current date date = datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d') # Current timestamp timeStamp = datetime.datetime.fromtimestamp(ts).strftime( '%H:%M:%S') # Check and compare the data from prediction and data from file Students.csv # Return the name that is equivalent to the accurate ID. aa = dataset_file.loc[dataset_file['Id'] == Id]['Name'].values # Create a string of information, used to add in the face object detected later on! tt = str(Id) + "-" + aa # Save data to the attendace attendance.loc[len(attendance)] = [Id, aa, date, timeStamp] else: # In case the system cannot recognize the object # It will be showing the "Unknown" (name) over the face object detected Id = 'Unknown' tt = str(Id) # Add the name over the face object detected cv2.putText(img, str(tt), (x, y + h), font_cv, 1, (0, 128, 255), 2) # Remove the duplicate rows based on all columns attendance = attendance.drop_duplicates(subset=['Id'], keep='first') # Show the window cv2.imshow('Image', img) # Wait until to press 'q' from keyboard to terminate the window if cv2.waitKey(1) == ord('q'): break # Create a time object # Purpose: using the current date as a filename for attendance checking. ts = time.time() date = datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d') # Create a new filename and save the attendance to that file. fileName = "../Attendance/Attendance_" + date + ".csv" attendance.to_csv(fileName, index=False) # Destroy and release all windows cam.releaseCam()
import glfw from OpenGL.GL import * import OpenGL.GL.shaders import numpy from pyrr import matrix44, Vector3 import TextureLoader from Camera import Camera def window_resize(window, width, height): glViewport(0, 0, width, height) cam = Camera() keys = [False] * 1024 lastX, lastY = 960, 540 first_mouse = True def key_callback(window, key, scancode, action, mode): if key == glfw.KEY_ESCAPE and action == glfw.PRESS: glfw.set_window_should_close(window, True) if key >= 0 and key < 1024: if action == glfw.PRESS: keys[key] = True elif action == glfw.RELEASE: keys[key] = False def do_movement(): if keys[glfw.KEY_W]:
def main(): # Local Variables camera = Camera(complex_camera, GAME_WIDTH, WINDOW_HEIGHT) up = down = False # Indicates the jumping movement left = right = False # Indicates character direction game_is_running = True # Indicates when program is running x = y = 0 # Sprite position variables score = 0 # Keeps track of the current score # Build the level for row in LEVEL: for col in row: # Barriers if col == "G": grass = Platform(x, y, "Grass") sprites_list.add(grass) if col == "D": dirt = Platform(x, y, "Dirt") sprites_list.add(dirt) if col == "L": left_edge = Platform(x, y, "Left Edge") sprites_list.add(left_edge) if col == "R": right_edge = Platform(x, y, "Right Edge") sprites_list.add(right_edge) if col == "T": two_edge = Platform(x, y, "Two Edge") sprites_list.add(two_edge) # Collectibles if col == "W": water = Sprite(RECYCLABLE_IMAGE, x, y, RECYCLABLE_WIDTH, RECYCLABLE_HEIGHT, 2) sprites_list.add(water) if col == "F": food = Sprite(NON_RECYCLABLE_IMAGE, x, y, NON_RECYCLABLE_WIDTH, NON_RECYCLABLE_HEIGHT, 3) sprites_list.add(food) # Reminders and Signs if col == "0": recycle_dash_sign = Sprite("sprites/Recycle Dash Sign.png", x, y, SIGN_WIDTH, BLOCK_DIMENSIONS, 4) sprites_list.add(recycle_dash_sign) if col == "1": left_button = Sprite("sprites/Left Button.png", x, y, BLOCK_DIMENSIONS, BLOCK_DIMENSIONS, 4) sprites_list.add(left_button) if col == "2": up_button = Sprite("sprites/Up Button.png", x, y, BLOCK_DIMENSIONS, BLOCK_DIMENSIONS, 4) sprites_list.add(up_button) if col == "3": right_button = Sprite("sprites/Right Button.png", x, y, BLOCK_DIMENSIONS, BLOCK_DIMENSIONS, 4) sprites_list.add(right_button) if col == "4": fly_indefinitely_sign = Sprite("sprites/Fly Indefinitely Sign.png", x, y, SIGN_WIDTH, BLOCK_DIMENSIONS, 4) sprites_list.add(fly_indefinitely_sign) if col == "5": collect_sign = Sprite("sprites/Collect Sign.png", x, y, SIGN_WIDTH, BLOCK_DIMENSIONS, 4) sprites_list.add(collect_sign) if col == "6": avoid_sign = Sprite("sprites/Avoid Sign.png", x, y, SIGN_WIDTH, BLOCK_DIMENSIONS, 4) sprites_list.add(avoid_sign) if col == "7": finish_sign = Sprite("sprites/Finish Sign.png", x, y, BLOCK_DIMENSIONS, BLOCK_DIMENSIONS, 4) sprites_list.add(finish_sign) x += BLOCK_DIMENSIONS y += BLOCK_DIMENSIONS x = 0 # Game execution while True: # Read input for event in pygame.event.get(): # If the game is closed, turn off the game if event.type == pygame.QUIT or (event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE): sys.exit() # If a button is pressed... if event.type == pygame.KEYDOWN: # If A is pressed, set character direction left if event.key == pygame.K_a: left = True # If D is pressed, set character direction right if event.key == pygame.K_d: right = True # If W is pressed, jump if event.key == pygame.K_w: up = True down = False # Once the user lets go of the key, set character direction to nothing if event.type == pygame.KEYUP: if event.key == pygame.K_d: right = False if event.key == pygame.K_a: left = False if event.key == pygame.K_w: up = False down = True # Runs the actual game if game_is_running: # Determines if game is over if GAME_WIDTH - 200 < character.rect.centerx < GAME_WIDTH: game_is_running = False # Acquires the list of sprites sprites_to_modify = sprites_list.sprites() for sprite in sprites_to_modify: # Player manipulations if sprite.identity == 1: # Get the list of objects colliding with the current sprite hit_list = pygame.sprite.spritecollide(sprite, sprites_list, False) # Update positions (using pixel-perfect movement) if sprite.rect.bottom <= WINDOW_HEIGHT and sprite.rect.top >= 0 and sprite.rect.right <= GAME_WIDTH and\ sprite.rect.left >= 0: # Movement if sprite.identity == 1: x_speed = 0 y_speed = 0 if left and not down: x_speed += -PLAYER_SPEED if right and not down: x_speed += PLAYER_SPEED if up: y_speed -= PLAYER_SPEED if down: y_speed += PLAYER_SPEED character.rect.centerx += x_speed character.rect.centery += y_speed # Collision handling for player for hit in hit_list: # If a barrier has been hit... if hit.identity == 0: if down and not pygame.sprite.collide_rect(hit, character): y_speed += 5 character.rect.centery += y_speed # If the player was moving right, move the player back if x_speed > 0: while pygame.sprite.collide_rect(character, hit): character.rect.centerx -= 1 # If the player was moving left, move the player back if x_speed < 0: while pygame.sprite.collide_rect(character, hit): character.rect.centerx += 1 # If the player was moving up, move the player down if y_speed < 0: while pygame.sprite.collide_rect(character, hit): character.rect.centery += 1 # If the player was moving down, move the player up if y_speed > 0: while pygame.sprite.collide_rect(character, hit): character.rect.centery -= 1 down = False # If a collectible has been hit if hit.identity == 2 or hit.identity == 3: hit.image = pygame.image.load("sprites/Blank.png") if hit.identity == 2: hit.identity = 4 score += 1 if hit.identity == 3: hit.identity = 4 score -= 1 # Position adjustments # If an object is destructible and it hits a wall, get rid of it while sprite.rect.bottom > WINDOW_HEIGHT: sprite.rect.y -= 1 while sprite.rect.top < 0: sprite.rect.y += 1 down = False while sprite.rect.right > GAME_WIDTH: sprite.rect.x -= 1 while sprite.rect.left < 0: sprite.rect.x += 1 # Updates screen for every passing frame display_score(score) screen.fill((0, 0, 0)) screen.blit(background.image, background.rect) camera.update(character) # Allows camera to follow the player # Draw everything over the .draw() function (more control with camera) for sprite in sprites_list: screen.blit(sprite.image, camera.apply(sprite)) screen.blit(character.image, camera.apply(character)) pygame.display.flip() clock.tick(240) # Displays the Game Over screen else: game_over(score)
K2 = np.genfromtxt('./calibration/data_AV/camera.txt') d1 = np.genfromtxt('./calibration/data_PG/dist.txt') d2 = np.genfromtxt('./calibration/data_AV/dist.txt') ################################################################# # Écran ------------------------------------- w = np.array([1600, 900]) #pixels W = w * 0.277e-3 #m ecran = Ecran(W, w, c) # Camera Point Grey ------------------------------------- sgmf1 = "./data/" + echantillon + "/cam_match_PG.png" R1 = np.array(pg.R) T1 = np.array(pg.T) w1 = np.array([3376, 2704]) W1 = w1 * 1.69e-6 cam1 = Camera(ecran, K1, R1, T1, W1, sgmf1) cam1.dist = d1 cam1.mask = cv2.imread("./data/" + echantillon + "/confcrop_PG.png", 0).astype('bool') # Allied vision ------------------------------------- sgmf2 = "./data/" + echantillon + "/cam_match_AV.png" R2 = np.array(av.R) T2 = np.array(av.T) w2 = np.array([780, 580]) W2 = w2 * 8.3e-6 cam2 = Camera(ecran, K2, R2, T2, W2, sgmf2) cam2.dist = d2 cam2.mask = cv2.imread("./data/" + echantillon + '/confcrop_AV.png', 0).astype('bool') #----------------------------------------------------------------------------
def main(): pygame.init() window_width = 1920 window_height = 1080 aspect_ratio = window_width / window_height fps = 60 clock = pygame.time.Clock() running = True pygame.display.set_mode([window_width, window_height], DOUBLEBUF | OPENGL | FULLSCREEN) pygame.display.set_caption("Minecraft Clone") window_width, window_height = pygame.display.get_surface().get_size() pygame.event.set_grab(True) pygame.mouse.set_visible(False) glViewport(0, 0, window_width, window_height) glEnable(GL_DEPTH_TEST) # Shader shader = shader_loader.Shader("vertex.vs", "fragment.fs") shader.use() # Vertex Buffering vao = GLuint(0) vbo = GLuint(0) ebo = GLuint(0) glGenVertexArrays(1, vao) glGenBuffers(1, vbo) glGenBuffers(1, ebo) glBindVertexArray(vao) glBindBuffer(GL_ARRAY_BUFFER, vbo) glBufferData(GL_ARRAY_BUFFER, 4 * len(vertices), vertices, GL_STATIC_DRAW) # glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo) # glBufferData(GL_ELEMENT_ARRAY_BUFFER, 4 * len(indices), indices, GL_STATIC_DRAW) # Position attribute glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * 4, ctypes.c_void_p(0)) glEnableVertexAttribArray(0) # Texture attribute glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 5 * 4, ctypes.c_void_p(3 * 4)) glEnableVertexAttribArray(2) # Unbinding buffers glBindVertexArray(0) # Instances instance_array = np.array(block_positions, np.float32) instance_vbo = glGenBuffers(1) glBindBuffer(GL_ARRAY_BUFFER, instance_vbo) glBufferData(GL_ARRAY_BUFFER, instance_array.itemsize * len(instance_array), instance_array, GL_STATIC_DRAW) glVertexAttribPointer(1, 1, GL_FLOAT, GL_FALSE, 0, ctypes.c_void_p(0)) glEnableVertexAttribArray(1) glVertexAttribDivisor(1, 1) # Texturing wood = Image.open("resources/wood.jpg") wood.load() wood_data = list(wood.getdata()) wood_data = np.array(wood_data, dtype=np.uint8) wood_texture = glGenTextures(1) # Wood texture glBindTexture(GL_TEXTURE_2D, wood_texture) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR) glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, wood.size[0], wood.size[1], 0, GL_RGB, GL_UNSIGNED_BYTE, wood_data) glGenerateMipmap(GL_TEXTURE_2D) glBindTexture(GL_TEXTURE_2D, 0) transform_location = glGetUniformLocation(shader.shader_program, "transform") model_location = glGetUniformLocation(shader.shader_program, "model") view_location = glGetUniformLocation(shader.shader_program, "view") projection_location = glGetUniformLocation(shader.shader_program, "projection") # Model Matrix model_orientation = Quaternion() model_matrix_base = Matrix44.from_scale(Vector3([1., 1., 1.])) rotation = Quaternion.from_x_rotation(-radians(-55)) model_orientation = rotation * model_orientation model_matrix = model_matrix_base * model_orientation model_matrix = np.array(model_matrix, dtype=np.float32) # Projection Matrix projection_matrix = Matrix44.perspective_projection( 45.0, aspect_ratio, .1, 100.) projection_matrix = np.array(projection_matrix, dtype=np.float32) # Camera camera = Camera(window_width, window_height, view_location) while running: keys_pressed = pygame.key.get_pressed() # Keyboard if keys_pressed[K_SPACE]: camera.move_camera("UP") if keys_pressed[K_LSHIFT]: camera.move_camera("DOWN") if keys_pressed[K_w]: camera.move_camera("FORWARD") if keys_pressed[K_s]: camera.move_camera("BACK") if keys_pressed[K_a]: camera.move_camera("LEFT") if keys_pressed[K_d]: camera.move_camera("RIGHT") # Mouse camera.point_camera() # Event Handling for event in pygame.event.get(): if event.type == QUIT: running = False elif event.type == KEYDOWN: if event.key == K_ESCAPE: running = False glClearColor(0.4667, 0.7373, 1., 1.0) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) # Texturing glBindTexture(GL_TEXTURE_2D, wood_texture) glUniform1i(glGetUniformLocation(shader.shader_program, "woodTexture"), 0) glBindVertexArray(vao) glUniformMatrix4fv(transform_location, 1, GL_FALSE, np.array(Matrix44.identity(), dtype=np.float32)) # MP glUniformMatrix4fv(model_location, 1, GL_FALSE, model_matrix) glUniformMatrix4fv(projection_location, 1, GL_FALSE, projection_matrix) for each_block in range(0, len(block_positions)): translation = Vector3() translation += block_positions[each_block] translation = Matrix44.from_translation(translation) block_translation_matrix = Matrix44.from_scale( Vector3([1., 1., 1.])) * translation block_translation_matrix = np.array(block_translation_matrix, dtype=np.float32) glUniformMatrix4fv(model_location, 1, GL_FALSE, block_translation_matrix) glDrawArraysInstanced(GL_TRIANGLES, 0, 36, len(block_positions)) glBindVertexArray(0) pygame.display.flip() clock.tick(fps) glDeleteVertexArrays(1, vao) glDeleteBuffers(1, vbo) glDeleteBuffers(1, ebo) pygame.quit() sys.exit()
def __init__(self, playerA1, playerA2, playerB1, playerB2, tabuleiro, lights): self.window_width = 1280 self.window_height = 620 self.cube_obj = Loader("./resources/models/cube.obj") player1_obj = Loader("./resources/models/drone.obj") player2_obj = Loader("./resources/models/galinha.obj") galinha_texture = Texture("./resources/textures/galinha.png") mech_texture = Texture("./resources/textures/mech.png") self.camera = Camera(self.window_width, self.window_height) self.camera.view['position'] = [0.0, 1.0, 0.0] self.camera.orthogonal = True self.camera.update() self.nave = Object(player1_obj, self.camera, mech_texture) self.nave.scale(0.4, 0.4, 0.4) self.galinha = Object(player2_obj, self.camera, galinha_texture) self.nave.model['rotation'][2] += 5 self.galinha.model['rotation'][2] += 5 self.galinha_win = Label("Galinha Wins", "kashima", 40, [1, 1, 1], [-1.5, 0, 0], self.camera) self.nave_win = Label("Nave Wins", "kashima", 40, [1, 1, 1], [-1.5, 0, 0], self.camera) self.playerA1 = playerA1 self.playerA2 = playerA2 self.playerB1 = playerB1 self.playerB2 = playerB2 self.tabuleiro = tabuleiro self.light = lights[0] self.playerA1.model['translation'] = [-0.8, 0.2, 0.8] self.playerA2.model['translation'] = [-0.8, 0.2, -0.8] self.playerB1.model['translation'] = [0.8, 0.2, -0.8] self.playerB2.model['translation'] = [0.8, 0.2, 0.8] self.positions = [[0.8, 0.2, -0.8], [-0.8, 0.2, 0.8], [0.8, 0.2, 0.8], [-0.8, 0.2, -0.8], [0.0, 0.2, 0.0]] self.current_player = "playerA" self.selected_piece = self.playerA1 self.free_position = self.positions[4] self.winner = None self.plays_count = 0 self.can_move_tree = { str(self.positions[0]): { str(self.positions[0]): False, str(self.positions[1]): False, str(self.positions[2]): True, str(self.positions[3]): True, str(self.positions[4]): True }, str(self.positions[1]): { str(self.positions[0]): False, str(self.positions[1]): False, str(self.positions[2]): True, str(self.positions[3]): False, str(self.positions[4]): True }, str(self.positions[2]): { str(self.positions[0]): True, str(self.positions[1]): True, str(self.positions[2]): False, str(self.positions[3]): False, str(self.positions[4]): True }, str(self.positions[3]): { str(self.positions[0]): True, str(self.positions[1]): False, str(self.positions[2]): False, str(self.positions[3]): False, str(self.positions[4]): True }, str(self.positions[4]): { str(self.positions[0]): True, str(self.positions[1]): True, str(self.positions[2]): True, str(self.positions[3]): True, str(self.positions[4]): False } } self.fire_work1 = FireWork(self.camera, self.cube_obj) self.fire_work2 = FireWork(self.camera, self.cube_obj) self.fire_work3 = FireWork(self.camera, self.cube_obj) self.render_count = 0
np.vstack([dydX0, dydY0, dydZ0, dydOmega, dydPhi, dydKappa]).T ]) a = np.zeros((2 * dd[0].shape[0], 6)) a[0::2] = dd[0] a[1::2] = dd[1] return a if __name__ == '__main__': fMarks = np.array([[113.010, 113.011], [-112.984, -113.004], [-112.984, 113.004], [113.024, -112.999]]) img_fmarks = np.array([[-7208.01, 7379.35], [7290.91, -7289.28], [-7291.19, -7208.22], [7375.09, 7293.59]]) cam = Camera(153.42, np.array([0.015, -0.020]), None, None, fMarks) img = SingleImage(camera=cam) print(img.ComputeInnerOrientation(img_fmarks)) print(img.ImageToCamera(img_fmarks)) print(img.CameraToImage(fMarks)) GrdPnts = np.array([[5100.00, 9800.00, 100.00]]) print(img.GroundToImage(GrdPnts)) imgPnt = np.array([23.00, 25.00]) print(img.ImageToRay(imgPnt)) imgPnt2 = np.array([-50., -33.]) print(img.ImageToGround_GivenZ(imgPnt2, 115.))
def startGameNow(self): self.camera = Camera(self.mainChar) taskMgr.doMethodLater(.1, self.updateMove, 'updateMove') taskMgr.add(self.move, "moveTask")
from projectiveFormulas import * from Camera import Camera from tkinter import * from Object3D import * import copy width = 500.0 height = 500.0 c = Canvas(width=width, height=height, bg='white') c.pack(expand=YES, fill=BOTH) testVanishPoint = Point3D() testVanishPoint.setYValue(10.0) testFocalPoint = Point3D() testFocalPoint.setYValue(100.0) viewport = Camera() viewport.setVanishPoint(testVanishPoint) viewport.setWindowDistance(50.0) viewport.setWindowSize([width, height]) viewport.setFocalPoint(testFocalPoint) pointOne = Point3D(-20.0, 5.0, 20.0) pointTwo = Point3D(20.0, 5.0, 20.0) pointThree = Point3D(20.0, 5.0, -20.0) pointFour = Point3D(-20.0, 5.0, -20.0) testPlane = Plane() testPlane.setPoints([pointOne, pointTwo, pointThree, pointFour]) pointFive = Point3D(-20.0, 40.0, 20.0) pointSix = Point3D(-20.0, 5.0, 20.0) pointSeven = Point3D(-20.0, 5.0, -20.0) pointEight = Point3D(-20.0, 40.0, -20.0)
def __init__(self): self.cam = Camera(CaptureConfig())
import cv2 from Camera import Camera from LaneKeepAssistSystem import LaneKeepAssistSystem camera = Camera() lka = LaneKeepAssistSystem() # camera.calibrateCamera() # camera.loadCameraProperties() image = cv2.imread("sample_road_img_13.png") out_img = lka.process(image) cv2.imwrite("out.png", out_img) # c = cv2.waitKey(0) # if 'q' == chr(c & 255): # cv2.destroyAllWindows()
class PythonOpenGLRaytracer: window_size = [1920, 1080] window = None spheres = list(range(50)) camera = Camera(30.0) first_mouse = True last_x = -1 last_y = -1 raytracing_max_bounces = 3 def init_spheres(self): for s in range(len(self.spheres)): random_position = glm.vec3([ random.random() - 0.5, random.random() - 0.5, random.random() - 0.5 ]) * 7500.0 random_radius = 200 + (800 * random.random()) random_color = glm.vec3( [random.random(), random.random(), random.random()]) random_opacity = random.random() self.spheres[s] = (Sphere(random_position, random_radius, random_color, random_opacity)) def window_resize_callback(self, window, width, height): glViewport(0, 0, width, height) self.window_size[:] = width, height def key_callback(self, window, key, scancode, action, mods): if key == glfw.KEY_ESCAPE: glfw.set_window_should_close(window, True) elif key in self.camera.get_keys(): self.camera.handle_keyboard(key) elif key == glfw.KEY_SPACE and action == glfw.PRESS: self.init_spheres() glClearColor(random.random(), random.random(), random.random(), 1.0) elif action == glfw.PRESS and (key == glfw.KEY_KP_ADD or key == glfw.KEY_KP_SUBTRACT): if key == glfw.KEY_KP_ADD: self.raytracing_max_bounces += 1 else: self.raytracing_max_bounces -= 1 self.raytracing_max_bounces = int( glm.clamp(self.raytracing_max_bounces, 0, 10)) def update_sphere_positions(self): for idx, sphere in enumerate(self.spheres): if idx % 2 == 0: new_sphere_position = glm.vec3( glm.rotate(glm.mat4(1.0), 0.00090, glm.vec3(0.0, 1.0, 0.5)) * glm.vec4(sphere.get_position(), 1.0)) elif idx % 3 == 0: new_sphere_position = glm.vec3( glm.rotate(glm.mat4(1.0), 0.00110, glm.vec3(0.5, 1.0, 1.0)) * glm.vec4(sphere.get_position(), 1.0)) else: new_sphere_position = glm.vec3( glm.rotate(glm.mat4(1.0), -0.00250, glm.vec3( 1.0, 1.0, 0.0)) * glm.vec4(sphere.get_position(), 1.0)) sphere.set_position(new_sphere_position) sphere.set_radius(sphere.get_radius() * 1.0 + ((random.random() - 0.5) / 50.0)) def run(self): if not glfw.init(): return self.window = glfw.create_window(self.window_size[0], self.window_size[1], "Python Opengl Raytracer", None, None) if not self.window: glfw.terminate() return glfw.set_key_callback(self.window, self.key_callback) glfw.set_window_size_callback(self.window, self.window_resize_callback) glfw.make_context_current(self.window) full_screen = np.array( [-1.0, -1.0, 0.0, -1.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0, -1.0, 0.0], dtype=np.float32) PASS_THROUGH_FRAGMENT_SHADER = open("shaders/pass_through.vert", "r").read() SPHERE_RAY_TRACER_FRAGMENT_SHADER = open( "shaders/sphere_ray_tracer.frag", "r").read() sphere_ray_tracer_shader_program = None try: sphere_ray_tracer_shader_program = OpenGL.GL.shaders.compileProgram( OpenGL.GL.shaders.compileShader(PASS_THROUGH_FRAGMENT_SHADER, GL_VERTEX_SHADER), OpenGL.GL.shaders.compileShader( SPHERE_RAY_TRACER_FRAGMENT_SHADER, GL_FRAGMENT_SHADER)) except OpenGL.GL.shaders.ShaderCompilationError as e: print( str(e.args[0]).replace("\\n", '\n').replace(": 0:", " line ")) return # Create Buffer object in gpu quad_VBO = glGenBuffers(1) # Bind the buffer glBindBuffer(GL_ARRAY_BUFFER, quad_VBO) glBufferData(GL_ARRAY_BUFFER, 48, full_screen, GL_STATIC_DRAW) position = glGetAttribLocation(sphere_ray_tracer_shader_program, 'position') glVertexAttribPointer(position, 3, GL_FLOAT, GL_FALSE, 0, None) glEnableVertexAttribArray(position) glUseProgram(sphere_ray_tracer_shader_program) glEnable(GL_BLEND) glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) glClearColor(0.3, 0.3, 0.3, 1.0) self.init_spheres() camera_position_loc = glGetUniformLocation( sphere_ray_tracer_shader_program, "camera_position") camera_look_direction_normalized_loc = glGetUniformLocation( sphere_ray_tracer_shader_program, "camera_look_direction_normalized") camera_up_direction_normalized_loc = glGetUniformLocation( sphere_ray_tracer_shader_program, "camera_up_direction_normalized") camera_right_direction_normalized_loc = glGetUniformLocation( sphere_ray_tracer_shader_program, "camera_right_direction_normalized") raytracing_max_bounces_loc = glGetUniformLocation( sphere_ray_tracer_shader_program, "raytracing_max_bounces") window_size_loc = glGetUniformLocation( sphere_ray_tracer_shader_program, "window_size") sphere_positions_loc = glGetUniformLocation( sphere_ray_tracer_shader_program, "sphere_positions") sphere_radii_loc = glGetUniformLocation( sphere_ray_tracer_shader_program, "sphere_radii") sphere_colors_loc = glGetUniformLocation( sphere_ray_tracer_shader_program, "sphere_colors") while not glfw.window_should_close(self.window): glfw.poll_events() self.update_sphere_positions() glClear(GL_COLOR_BUFFER_BIT) glUniform3fv(camera_position_loc, 1, self.camera.get_position().to_list()) glUniform3fv(camera_look_direction_normalized_loc, 1, self.camera.get_look_direction().to_list()) glUniform3fv(camera_up_direction_normalized_loc, 1, self.camera.get_up_direction().to_list()) glUniform3fv(camera_right_direction_normalized_loc, 1, self.camera.get_right_direction().to_list()) glUniform1i(raytracing_max_bounces_loc, self.raytracing_max_bounces) glUniform2fv(window_size_loc, 1, self.window_size) glUniform3fv(sphere_positions_loc, len(self.spheres), [o.get_position().to_list() for o in self.spheres]) glUniform1fv(sphere_radii_loc, len(self.spheres), [o.get_radius() for o in self.spheres]) glUniform3fv(sphere_colors_loc, len(self.spheres), [o.get_color().to_list() for o in self.spheres]) glDrawArrays(GL_QUADS, 0, 4) glfw.swap_buffers(self.window) glfw.terminate()
cv2.putText(image, str(markerID), (topLeft[0], topLeft[1] - 15), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2) #print("[INFO] ArUco marker ID: {}".format(markerID)) return image if __name__ == '__main__': from Camera import Camera import numpy as np dict_to_use = 'DICT_5X5_50' arucoDetector = ArUcoDetector(dict_to_use) camera = Camera() camera.startStreaming() while True: frame = camera.getNextFrame() depth_image, color_image = camera.extractImagesFromFrame(frame) # Remove unaligned part of the color_image to grey grey_color = 153 depth_image_3d = np.dstack( (depth_image, depth_image, depth_image)) #depth image is 1 channel, color is 3 channels masked_color_image = np.where(depth_image_3d <= 0, grey_color, color_image) # Apply colormap on depth image (image must be converted to 8-bit per pixel first) depth_colormap = cv2.applyColorMap(
player = Player() platform_controller = PlatformController() floor = Platform(0, SCREEN_HEIGHT - 36, SCREEN_WIDTH, 36) camera = Camera(player) player = Player() platform_controller = PlatformController() floor = Platform(0, SCREEN_HEIGHT - 36, SCREEN_WIDTH, 36) arrow_image = load_image("arrow.png") selected_option = 0.30 background = load_image('background.jpg') camera = Camera(player) game_state = 'Menu' game_loop = True clock = pygame.time.Clock() fps = 60 while game_loop: for event in pygame.event.get(): if event.type == pygame.QUIT: game_loop = False if event.type == pygame.KEYDOWN: if event.key == pygame.K_ESCAPE: if game_state == 'Playing' or game_state == 'Game Over' or game_state == 'About':
def __init__(self): if len(self.states) != len(ard.Pins): print "WARNING: This may not have all of the controls mapped" if platform.system() != 'Windows': self.camera = Camera() self.camera.start()
#im_greyscale = cv2.imread('/Users/marchaubenstock/Workspace/Diplomarbeit_Resources/VO_Home_Images/Images_ZR300_XTrans/image_1.png',0) #im_greyscale = cv2.imread('/Users/marchaubenstock/Workspace/Diplomarbeit_Resources/rccar_26_09_18/marc_1_full/color/966816.173323313.png',cv2.IMREAD_GRAYSCALE) #im_greyscale = cv2.imread('/Users/marchaubenstock/Workspace/Diplomarbeit_Resources/VO_Bench/rgbd_dataset_freiburg2_desk/rgb/1311868164.363181.png',cv2.IMREAD_GRAYSCALE) im_greyscale = cv2.imread('/Users/marchaubenstock/Workspace/Rust/open-cv/images/calib.png',cv2.IMREAD_GRAYSCALE) #im_greyscale = im_greyscale.astype(Utils.image_data_type) pixels_standardised = ImageProcessing.z_standardise(im_greyscale) pixels_norm = im_greyscale.astype(np.float64) pixels_normalized_disp = ImageProcessing.normalize_to_image_space(pixels_standardised) pixels_disp = ImageProcessing.normalize_to_image_space(pixels_norm) depth_image = pixels_standardised.astype(Utils.depth_data_type_int) se3_identity = np.identity(4, dtype=Utils.matrix_data_type) intrinsic_identity = Intrinsic.Intrinsic(-1, -1, 0, 0) camera_identity = Camera.Camera(intrinsic_identity, se3_identity) frame = Frame.Frame(pixels_standardised, depth_image, camera_identity, True) #cv2.imshow('grad x',frame.grad_x) cv2.imshow('grad x abs',np.abs(frame.grad_x)) #cv2.imshow('neg sobel x',-frame.grad_x) #cv2.imshow('sobel y',frame.grad_y) #cv2.imshow('image',pixels_disp) #cv2.imshow('image z-standard',pixels_normalized_disp) #grayscale_image = ImageProcessing.normalize_to_image_space(frame.grad_x) #abs = np.absolute(frame.grad_x) #normed = cv2.normalize(abs, None, alpha=0, beta=65535, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_16UC1) #cv2.imwrite("grad_x_scharr.png",abs)
if __name__ == "__main__": aspectRatio = 16.0 / 9.0 imageWidth = 500 imageHeight = int(imageWidth / aspectRatio) samplesPerPixel = 20 maxDepth = 50 world = randomSphereScene() lookFrom = Vec3(13, 2, 3) lookAt = Vec3(0, 0, 0) vUp = Vec3(0, 1, 0) distToFocus = 10.0 aperture = 0.1 cam = Camera(lookFrom, lookAt, vUp, 20, aspectRatio, aperture, distToFocus) stopwatch = Stopwatch() image = imageHeight * imageWidth * [[0, 0, 0]] index = 0 for j in range(imageHeight): showProgress(stopwatch, j, imageHeight) for i in range(imageWidth): pixelColor = Vec3(0, 0, 0) for s in range(samplesPerPixel): u = (i + random.random()) / (imageWidth - 1) v = (j + random.random()) / (imageHeight - 1) r = cam.getRay(u, v) pixelColor = pixelColor + rayColor(r, world, maxDepth) image[index] = vecToColor(pixelColor, samplesPerPixel) index += 1