Python Renderer.start方法代码示例

# 需要导入模块: from renderer import Renderer [as 别名]
# 或者: from renderer.Renderer import start [as 别名]
def start(options, imageFinder):
	pygame.init()
	screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN | pygame.DOUBLEBUF | pygame.HWSURFACE)
	if not options.debug:
		pygame.mouse.set_visible(0)

	process = psutil.Process(os.getpid())

	slideLoader = SlideLoader(process, screen, imageFinder, options.minimumBufferLength, options.maxMemoryUsage)
	slideLoader.start()

	renderer = Renderer(process, screen, slideLoader, options.fps, options.debug)
	renderer.start()

	clock = pygame.time.Clock()
	quit = False
	while not quit:
		clock.tick(5)
		for event in pygame.event.get():
			if event.type == pygame.QUIT:
				quit = True
			elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
				quit = True

	slideLoader.stop()
	renderer.stop()
	slideLoader.join()
	renderer.join()

# 需要导入模块: from renderer import Renderer [as 别名]
# 或者: from renderer.Renderer import start [as 别名]
    for y in range(-8, 8, 2):
        for z in range(1):
            points.append(((x+1)*spacing, (y+1)*spacing+1, z))
points = np.array(points)



#Project it on 2D plane and move origin to center of screen
projected = E.project(points)
projected = E.translate(projected, 320)
R.points = points#projected

D = Distortion(np.array([[20,20,5]]), 30)

#Render and handle events
R.start()
F.start(points)

endRun = False
space = points
while not endRun:
    R.points = F.space#E.translate(E.project(F.space), 320)
    for event in pygame.event.get():
        if event.type == QUIT:
            R.stop()
            F.stop()
            endRun = True
        elif event.type == MOUSEMOTION:
            pass
            # x, y = event.pos
            # point = np.array([x-320, y-320, 3])

# 需要导入模块: from renderer import Renderer [as 别名]
# 或者: from renderer.Renderer import start [as 别名]
from pybrain.rl.agents.linearfa import LinearFA_Agent
from pybrain.rl.experiments import EpisodicExperiment

from environment import Environment
from tasks import LinearFATileCoding3456BalanceTask
from training import LinearFATraining
from learners import SARSALambda_LinFA_ReplacingTraces
from renderer import Renderer

task = LinearFATileCoding3456BalanceTask()
renderer = Renderer()
task.env.setRenderer(renderer)
renderer.start()
learner = SARSALambda_LinFA_ReplacingTraces(task.nactions, task.outdim,
        learningRateDecay=1500, randomInit=False)
learner._lambda = 0.95
task.discount = learner.rewardDiscount
agent = LinearFA_Agent(learner)
agent.epsilonGreedy = True
agent.init_exploration = 0.5
# The state has a huge number of dimensions, and the logging causes me to run
# out of memory. We needn't log, since learning is done online.
agent.logging = False
performance_agent = LinearFA_Agent(learner)
performance_agent.logging = False
performance_agent.greedy = True
performance_agent.learning = False
experiment = EpisodicExperiment(task, agent)

# TODO PyBrain says that the learning rate needs to decay, but I don't see that

# 需要导入模块: from renderer import Renderer [as 别名]
# 或者: from renderer.Renderer import start [as 别名]
class Interface(object):

    def init(self):
        info("Initializing interface")
        Globals().load(self)

        self.renderer = Renderer()
        return True


    def __del__(self):
        info("Deleting Interface")

        self.renderer.__del__()

        if(self.server):
           self.server.__del___()


    def start(self):
        info("Starting interface")

        # create input handlers
        self.mouse_handler = eval(self.app.mouse_handler + "()")
        self.keyboard_handler = eval(self.app.keyboard_handler + "()")

        # create_console
        if config.PIL_available:
            console = Console()
            self.renderer.register_console_callbacks(console.render_console, console.console_keyboard)

        # register callbacks & console with Renderer
        self.renderer.register_callbacks(self.keyboard_handler.do_key, self.mouse_handler.do_button, self.mouse_handler.do_motion)

        # register cmdcenter with renderer
        self.renderer.cmdcenter = self.cmdcenter

        # start server
        if(self.app.server):
            self.server = Server()
            self.server.start()
        else:
            self.server = None

        # start midi
        if(self.app.midi_enabled):
            self.app.last_midi_event = self.cmdcenter.time()
            self.midi = MidiHandler()

            # sync par & zn lists to controller
            if(self.app.midi_echo):
                self.cmdcenter.state.par.add_observer(midi.mirror)
                self.cmdcenter.state.zn.add_observer(midi.mirror)

            # start midi
            self.midi.start()
        else:
            self.midi = None

        # start osc
        if(self.app.OSC_enabled):
            self.osc = eval(self.app.OSC_handler + "()")
            self.osc.start()
            
            # sync par & zn lists to controller
            
            if(self.app.OSC_echo):
                self.cmdcenter.state.par.add_observer(self.osc.mirror)
                self.cmdcenter.state.zn.add_observer(self.osc.mirror)            
                self.cmdcenter.state.components.add_observer(self.osc.mirror)            
                self.cmdcenter.state.add_observer(self.osc.mirror)            

        self.renderer.start()


    def do(self):
        # execute renderer
        self.renderer.do()