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
