本文整理汇总了Python中renderer.Renderer.render方法的典型用法代码示例。如果您正苦于以下问题:Python Renderer.render方法的具体用法?Python Renderer.render怎么用?Python Renderer.render使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类renderer.Renderer
的用法示例。
在下文中一共展示了Renderer.render方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: run
# 需要导入模块: from renderer import Renderer [as 别名]
# 或者: from renderer.Renderer import render [as 别名]
def run(self, rhoNo=1, phiNo=1, tfNo=1):
dataset = Dataset(rhoNo, phiNo, tfNo)
self.numFiles = 0
renderer = Renderer(self.eye, self.screen)
numTextures = self.numTextures
rho = dataset.rho
phi = dataset.phi
tf = dataset.tf
phiPlane = SplinePlane(phi, self.splineInterval, 1e-5)
boundingBox = phiPlane.createBoundingBox()
refSplineModel = SplineModel(tf, phiPlane, rho, self.refTolerance)
voxelModels = np.empty(numTextures, dtype=object)
for i in range(numTextures):
texDimSize = self.texDimSizes[i]
if voxelio.exist(dataset, texDimSize, texDimSize):
samplingScalars = voxelio.read(dataset, texDimSize, texDimSize)
print "Read {}x{} texture data from file".format(texDimSize, texDimSize)
else:
samplingScalars = refSplineModel.generateScalarMatrix(boundingBox, texDimSize, texDimSize,
self.voxelizationTolerance)
voxelio.write(dataset, samplingScalars)
print "Wrote {}x{} texture data to file".format(texDimSize, texDimSize)
scalarTexture = Texture2D(samplingScalars)
voxelModels[i] = VoxelModel(tf, scalarTexture, boundingBox)
printflush("Rendering reference... ")
renderData = RenderData(ModelType.REFERENCE, self.viewRayDelta)
renderData.renderResult = renderer.render(refSplineModel, self.viewRayDelta)
self.save(dataset, renderData)
print "Done!"
for i, texSize in enumerate(self.texDimSizes):
delta = self.viewRayDelta
printflush("Rendering voxelized ({0}x{0})...".format(texSize))
renderData = RenderData(ModelType.VOXEL, delta=delta, texSize=texSize)
renderData.renderResult = renderer.render(voxelModels[i], delta)
self.save(dataset, renderData)
print "Done!"
示例2: render
# 需要导入模块: from renderer import Renderer [as 别名]
# 或者: from renderer.Renderer import render [as 别名]
def render(template, context=None, **kwargs):
"""
Return the given template string rendered using the given context.
"""
renderer = Renderer()
return renderer.render(template, context, **kwargs)
示例3: ProcessHandler
# 需要导入模块: from renderer import Renderer [as 别名]
# 或者: from renderer.Renderer import render [as 别名]
class ProcessHandler(webapp.RequestHandler):
def __init__(self):
self.template_renderer = Renderer('process.html')
self.user_handler = UserHandler()
self.user_obj = None
def setUser(self):
self.user_obj = self.user_handler.handleUser()
def get(self, step):
self.setUser()
#self.response.out.write('in step %s' % step)
if step == PROCESS_STEP_1_START:
return self.ProcessStep1()
elif step == PROCESS_STEP_2_EXECUTE:
return self.ProcessStep2()
else:
pass
def ProcessStep1(self):
self.template_renderer.template_values['process_step'] = '1'
self.template_renderer.template_values['next_step'] = PROCESS_STEP_2_EXECUTE
self.render()
def ProcessStep2(self):
self.template_renderer.template_values['process_step'] = '2'
self.render()
def render(self):
self.template_renderer.template_values['token'] = self.user_obj.spreadsheet_session_token
self.response.out.write(self.template_renderer.render())
示例4: get
# 需要导入模块: from renderer import Renderer [as 别名]
# 或者: from renderer.Renderer import render [as 别名]
def get(self):
"""Handle a GET request for the page."""
if IS_CACHING_ON and self.is_cached:
with open(self.cached_name) as cachefile:
page = cachefile.read()
else:
renderer = Renderer(view=self)
page = renderer.render()
if IS_CACHING_ON:
self.write_page_to_cache(page)
print "Content-type:text/html\n", page
示例5: render
# 需要导入模块: from renderer import Renderer [as 别名]
# 或者: from renderer.Renderer import render [as 别名]
def render(self):
"""Renders the contents of this post to be viewed in the browser"""
# title
output = ['\n', '<h1><a href="?post=%s">%s</a></h1>' %
(self.metadata.timestamp, self.metadata.title), '\n']
# content
renderer = Renderer(self.metadata.location)
content = self.read_content()
output.append(renderer.render(content))
# categories
output.append('<p><small>Posted on ')
[output.append('<a href="?category=%s">%s</a> ' % (category, category)) for category in
self.metadata.categories]
output.append('</small></p>')
return ''.join(output)
示例6: Page
# 需要导入模块: from renderer import Renderer [as 别名]
# 或者: from renderer.Renderer import render [as 别名]
class Page(dict):
def __init__(self):
self.update({
'theme': Config.get('global', 'theme'),
'template': 'page',
'menus': Menus
})
self.renderer = Renderer()
def __getattr__(self, key):
try:
return self[key]
except KeyError:
return None
def __setattr__(self, key, value):
self[key]=value
def render(self, method, *args, **kwargs):
return self.renderer.render(self)
示例7: LoginHandler
# 需要导入模块: from renderer import Renderer [as 别名]
# 或者: from renderer.Renderer import render [as 别名]
class LoginHandler(webapp.RequestHandler):
def __init__(self):
self.template_renderer = Renderer('login.html')
self.client = gdata.spreadsheet.service.SpreadsheetsService()
self.user_prefs = None
gdata.alt.appengine.run_on_appengine(self.client)
@login_required
def get(self):
self.user_prefs = UserHandler.handleUser()
self.template_renderer.self_uri = self.request.url
if self.request.get('token'):
self.upgradeToken()
else:
self.handleAuthSubLogin()
self.render()
def handleAuthSubLogin(self):
next_url = self.request.url
auth_sub_url = self.client.GenerateAuthSubURL(next_url,
config.GDATA_SCOPE_SPREADSHEETS, secure=False, session=True,
domain=config.GDATA_HOSTED_DOMAIN)
self.template_renderer.template_values['auth_sub_url'] = auth_sub_url
def upgradeToken(self):
single_use_token = gdata.auth.extract_auth_sub_token_from_url(self.request.url)
self.client.UpgradeToSessionToken(single_use_token)
session_token = self.client.GetAuthSubToken()
self.template_renderer.template_values['token'] = session_token
self.user_prefs.spreadsheet_session_token = session_token
db.put(self.user_prefs)
def render(self):
self.response.out.write(self.template_renderer.render())
示例8: MainPage
# 需要导入模块: from renderer import Renderer [as 别名]
# 或者: from renderer.Renderer import render [as 别名]
class MainPage(webapp.RequestHandler):
def __init__(self):
self.template_renderer = Renderer('index.html')
self.client = gdata.spreadsheet.service.SpreadsheetsService()
self.user_handler = UserHandler()
self.user_obj = None
#self.user_obj = UserHandler()
@login_required
def get(self):
self.response.headers['Content-Type'] = 'text/html'
self.template_renderer.self_uri = self.request.url
#self.user_obj = UserHandler.handleUser()
self.user_obj = self.user_handler.user_obj
if self.user_obj.spreadsheet_session_token is not None:
self.client.SetAuthSubToken(self.user_obj.spreadsheet_session_token)
#self.listSheets()
self.render()
# def listSheets(self):
# sheets = []
#
# feed = self.client.GetListFeed('tV7NOVp4-gbUVQglSUegsVQ','od6')
# for i, entry in enumerate(feed.entry):
# for key in entry.custom:
# value = entry.custom[key].text
# sheets.append({'title':value, 'key':key})
#
# self.template_renderer.template_values['worksheets'] = sheets
def render(self):
self.template_renderer.template_values['token'] = self.user_obj.spreadsheet_session_token
self.response.out.write(self.template_renderer.render())
示例9: run
# 需要导入模块: from renderer import Renderer [as 别名]
# 或者: from renderer.Renderer import render [as 别名]
def run(self, rhoNo=1, phiNo=1, tfNo=1):
dataset = Dataset(rhoNo, phiNo, tfNo)
self.numFiles = 0
renderer = Renderer(self.eye, self.screen)
hybridRenderer = HybridRenderer(self.eye, self.screen)
numTextures = self.numTextures
rho = dataset.rho
phi = dataset.phi
tf = dataset.tf
phiPlane = SplinePlane(phi, self.splineInterval, 1e-5)
boundingBox = phiPlane.createBoundingBox()
viewRayDeltaRef = boundingBox.getWidth() / (self.texDimSizes[-1]*2) / 2.0
refSplineModel = SplineModel(tf, phiPlane, rho, self.refTolerance)
directSplineModel = SplineModel(tf, phiPlane, rho)
voxelModels = np.empty(numTextures, dtype=object)
baModels = np.empty(numTextures, dtype=object)
hybridModels = np.empty(numTextures, dtype=object)
baHybridModels = np.empty(numTextures, dtype=object)
for i in range(numTextures):
texDimSize = self.texDimSizes[i]
if voxelio.exist(dataset, texDimSize, texDimSize):
samplingScalars = voxelio.read(dataset, texDimSize, texDimSize)
print "Read {}x{} texture data from file".format(texDimSize, texDimSize)
else:
samplingScalars = refSplineModel.generateScalarMatrix(boundingBox, texDimSize, texDimSize,
self.voxelizationTolerance)
voxelio.write(dataset, samplingScalars)
print "Wrote {}x{} texture data to file".format(texDimSize, texDimSize)
scalarTexture = Texture2D(samplingScalars)
voxelWidth = boundingBox.getWidth() / float(texDimSize)
voxelHeight = boundingBox.getHeight() / float(texDimSize)
criterion = GeometricCriterion(self.screen.pixelWidth, voxelWidth, voxelHeight)
voxelModels[i] = VoxelModel(tf, scalarTexture, boundingBox)
baModels[i] = BoundaryAccurateModel(tf, directSplineModel, voxelModels[i])
hybridModels[i] = HybridModel(tf, directSplineModel, voxelModels[i], criterion)
baHybridModels[i] = HybridModel(tf, directSplineModel, baModels[i], criterion)
printflush("Rendering reference... ")
renderData = RenderData(ModelType.REFERENCE, viewRayDeltaRef)
renderData.renderResult = renderer.render(refSplineModel, viewRayDeltaRef)
self.save(dataset, renderData)
print "Done!"
if not self.autoDelta:
printflush("Rendering direct... ")
renderData = RenderData(ModelType.DIRECT, self.viewRayDelta)
renderData.renderResult = renderer.render(directSplineModel, self.viewRayDelta)
self.save(dataset, renderData)
print "Done!"
for i, texSize in enumerate(self.texDimSizes):
if self.autoDelta:
voxelWidth = boundingBox.getWidth() / float(texSize)
delta = voxelWidth/2.0
printflush("Rendering direct...")
renderData = RenderData(ModelType.DIRECT, delta)
renderData.renderResult = renderer.render(directSplineModel, delta)
self.save(dataset, renderData)
print "Done!"
else:
delta = self.viewRayDelta
printflush("Rendering voxelized ({0}x{0})...".format(texSize))
renderData = RenderData(ModelType.VOXEL, delta=delta, texSize=texSize)
renderData.renderResult = renderer.render(voxelModels[i], delta)
self.save(dataset, renderData)
print "Done!"
printflush("Rendering boundary accurate ({0}x{0})...".format(texSize))
renderData = RenderData(ModelType.BOUNDARYACCURATE, delta=delta, texSize=texSize)
renderData.renderResult = renderer.render(baModels[i], delta)
self.save(dataset, renderData)
print "Done!"
printflush("Rendering hybrid ({0}x{0})...".format(texSize))
renderData = RenderData(ModelType.HYBRID, delta=delta, texSize=texSize)
renderData.renderResult = hybridRenderer.render(hybridModels[i], delta)
self.save(dataset, renderData)
print "Done!"
printflush("Rendering hybrid (boundary accurate) ({0}x{0})...".format(texSize))
renderData = RenderData(ModelType.BAHYBRID, delta=delta, texSize=texSize)
renderData.renderResult = hybridRenderer.render(baHybridModels[i], delta)
self.save(dataset, renderData)
print "Done!"
示例10: Launcher
# 需要导入模块: from renderer import Renderer [as 别名]
# 或者: from renderer.Renderer import render [as 别名]
class Launcher(object):
def __init__(self, screen):
self.screen = screen
self.save = SaveGame()
self.sound = SoundPlayer()
self.menu_font = pygame.font.Font('fonts/GROTESKIA.ttf', 50)
self.small_font = pygame.font.Font('fonts/C&C Red Alert [INET].ttf', 13)
self.intro_graphic = pygame.image.load('graphics/background_intro.png').convert()
self.background = pygame.image.load('graphics/background.png').convert()
self.background_menu = pygame.image.load('graphics/background_menu.png').convert()
#self.overlay_won = pygame.image.load('graphics/overlay_background.png').convert()
self.overlay_won = pygame.Surface(screen.get_size())
self.overlay_won.fill((0, 0, 0))
self.overlay_won.set_alpha(128)
self.won_animation = Animation('graphics/victory.json')
self.quitting = False
self.clock = pygame.time.Clock()
self.menu_options = (Label('Play'),
Label('Select Level'),
Label('Help'),
Label('Credits'),
Label('Quit'))
self.menu_widths = [self.menu_font.size(opt.name)[0] for opt in self.menu_options]
self.mode = MODE_INTRO
self.intro_frame = 0
@property
def mode(self):
return self._mode
@mode.setter
def mode(self, value):
self._mode = value
pygame.key.set_repeat()
if value == MODE_SELECT_LEVEL:
world = self.select_list[self.current_menu_item]
self.select_list = world.levels
self.current_menu_item = 0
elif value == MODE_SELECT_WORLD:
self.current_menu_item = 0
self.read_level_info()
self.select_list = sorted(self.worlds.values())
elif value == MODE_MAIN_MENU:
self.current_menu_item = 0
self.select_list = self.menu_options
elif value == MODE_PLAYING:
self.screen.fill((0, 0, 0))
pygame.key.set_repeat(1, 150)
def select_menu(self):
option = self.select_list[self.current_menu_item]
if self.mode == MODE_MAIN_MENU:
name = option.name
if name == 'Play':
self.read_level_info()
self.current_world, self.level_id = self.save.current()
self.play()
elif name == 'Select Level':
self.mode = MODE_SELECT_WORLD
elif name == 'Help':
return False
elif name == 'Quit':
self.quitting = True
elif self.mode == MODE_SELECT_WORLD:
self.current_world = option.name
self.mode = MODE_SELECT_LEVEL
elif self.mode == MODE_SELECT_LEVEL:
if self.save.available(self.current_world, self.current_menu_item):
self.level_id = self.current_menu_item
self.play()
else:
return False
return True
def read_level_info(self):
filenames = glob(os.path.join('levels', '*.txt'))
self.worlds = {}
for filename in filenames:
try:
world = LevelSet(filename)
except IOError:
continue
self.worlds[world.name] = world
def play(self):
self.save.set_current(self.current_world, self.level_id)
self.mode = MODE_PLAYING
if self.current_world == 'Tutorials':
if self.level_id == 0:
self.game = TutorialOne()
elif self.level_id == 1:
self.game = TutorialTwo()
else:
self.game = game.Game()
else:
self.game = game.Game()
self.renderer = Renderer()
self.game.loc_from_screen_coords = self.renderer.loc_from_screen_coords
self.game.load_level(self.worlds[self.current_world].levels[self.level_id].value)
#.........这里部分代码省略.........
示例11: MyWindow
# 需要导入模块: from renderer import Renderer [as 别名]
# 或者: from renderer.Renderer import render [as 别名]
class MyWindow(Window):
def __init__(self):
self.mouse_drag = False
self.animal_window = None
self.selected_animal = None
self.mouse_start_point = Point(0, 0)
self.start_time = time()
self.world = world.World(500, 200, constants=WorldConstants())
self.window = wpf.LoadComponent(self, 'iron_unconditioned_reflexes.xaml')
self._create_and_start_timer()
self._renderer = Renderer(self.canvas, self.world)
self.world.food_timer = self.food_slider.Value
self._renderer.draw_food_smell = self.food_smell_checkBox.IsChecked
self._renderer.draw_eat_distance = self.eat_distance_checkBox.IsChecked
self._renderer.draw_chunks = self.chunks_checkBox.IsChecked
self._renderer.draw_animal_smell = self.animal_smell_checkBox.IsChecked
self._simulation_scenario = SimulationScenario(self)
def _create_and_start_timer(self):
self.timer = DispatcherTimer()
self.timer.Tick += self.dispatcherTimer_Tick
self.timer.Interval = TimeSpan(0, 0, 0, 0, self.timer_slider.Value)
self.timer.Start()
def dispatcherTimer_Tick(self, sender, e):
self._simulation_scenario.tic()
self._check_performance()
self._show_world_info_in_ui()
self.world.update()
self._renderer.render()
if self.animal_window:
self.animal_window.update()
def _check_performance(self):
if self.world.time % 10 == 0:
performance = (time() - self.start_time) / 10.0
self.performance_textblock.Text = "performance={}".format(performance)
self.start_time = time()
def _show_world_info_in_ui(self):
self.world_time_textblock.Text = "world time={}".format(self.world.time)
self.animal_count_textblock.Text = "animal count={}".format(len(self.world.animals))
self.food_count_textblock.Text = "food count={}".format(len(self.world.food))
def timer_slider_ValueChanged(self, sender, e):
self.timer.Interval = TimeSpan(0, 0, 0, 0, sender.Value)
def scale_slider_ValueChanged(self, sender, e):
# todo fix this crutch
if hasattr(self,'canvas'):
self.canvas.RenderTransform = ScaleTransform(sender.Value, sender.Value)
def canvas_SizeChanged(self, sender, e):
self.world.width = int(sender.ActualWidth)
self.world.height= int(sender.ActualHeight)
def canvas_MouseRightButtonDown(self, sender, e):
self.mouse_drag = True
self.mouse_start_point = e.GetPosition(self.canvas)
def canvas_MouseRightButtonUp(self, sender, e):
self.mouse_drag = False
def canvas_MouseLeave(self, sender, e):
self.mouse_drag = False
def canvas_MouseMove(self, sender, e):
if self.mouse_drag:
point = e.GetPosition(self.canvas)
left = self.parent_canvas.GetLeft(self.canvas)
top = self.parent_canvas.GetTop(self.canvas)
if float.IsNaN(left):
left = 0
if float.IsNaN(top):
top = 0
self.parent_canvas.SetLeft(self.canvas, left + point.X - self.mouse_start_point.X)
self.parent_canvas.SetTop(self.canvas, top + point.Y - self.mouse_start_point.Y)
def canvas_MouseWheel(self, sender, e):
self.scale_slider.Value += (e.Delta/120)*0.05
def food_slider_ValueChanged(self, sender, e):
self.world.food_timer = int(sender.Value)
def food_smell_changed(self, sender, e):
self._renderer.draw_food_smell = self.food_smell_checkBox.IsChecked
def eat_distance_changed(self, sender, e):
self._renderer.draw_eat_distance = self.eat_distance_checkBox.IsChecked
def chunks_changed(self, sender, e):
self._renderer.draw_chunks = self.chunks_checkBox.IsChecked
#.........这里部分代码省略.........
示例12: test_render
# 需要导入模块: from renderer import Renderer [as 别名]
# 或者: from renderer.Renderer import render [as 别名]
def test_render(self):
""" """
renderer = Renderer('contents/post/2009_08_05_12_56')
for input, output in self.cases:
result = renderer.render(input)
self.assertEqual(result, output)
示例13: __init__
# 需要导入模块: from renderer import Renderer [as 别名]
# 或者: from renderer.Renderer import render [as 别名]
class World:
def __init__(self):
#self.objects = []
#self.objects_map = defaultdict(list)
self.objectives = []
self.messages = []
self.state = STATE_NORMAL
pygame.key.set_repeat(1, 50)
self.quitting = False
self.renderer = Renderer()
self.clock = pygame.time.Clock()
self.framerates = []
self.font = pygame.font.SysFont('Sans', 18)
self.player = Player(name='you', level=None, description='The Player')
self.level = TestLevel(self)
self.player.level = self.level
self.player.location = (self.level.width/2, self.level.height/2)
mq = MainQuest(self)
#def add_object(self, obj):
# if obj in self.objects:
# return
# self.objects.append(obj)
# self.objects_map[obj.location].append(obj)
# obj.world = self
#
#def remove_object(self, obj):
# if obj not in self.objects:
# return
# self.objects.remove(obj)
# self.objects_map[obj.location].remove(obj)
# obj.destroy()
def add_objective(self, objective):
self.objectives.append(objective)
def get_objects_at(self, location, test=None):
#First item at a location is always terrain
if test is None:
return self.level[location][1:]
else:
return [obj for obj in self.level[location][1:] if test(obj)]
def get_object_by_name(self, name):
#TODO this should not just work on the current level
for obj in self.level.objects:
if obj.name == name:
return obj
def can_move_to(self, obj, location):
if [1 for x in self.level[location] if x.block_move]:
return False
return True
def win(self):
self.describe("You win!")
self.quitting = True
def main_loop(self, screen):
self.update()
while not self.quitting:
delay = self.clock.tick(15)
self.framerates.insert(0, 1000.0/delay)
self.framerates = self.framerates[:50]
framerate = sum(self.framerates)/50.0
self.process_events()
self.renderer.render(self, screen)
screen.blit(self.font.render('%d fps' % framerate, True, (255,255,255)),
(1, 1))
pygame.display.flip()
def process_events(self):
took_turn = False
for e in pygame.event.get():
if e.type == pygame.QUIT:
self.quitting = True
return
if e.type == pygame.KEYDOWN:
took_turn = self.keypressed(e)
elif e.type == pygame.MOUSEBUTTONUP:
took_turn = self.clicked(e)
if took_turn:
self.update()
def keypressed(self, e):
took_turn = False
if self.state == STATE_PICK:
if e.key == pygame.K_LEFT or e.key == pygame.K_h:
self.pick_location[0] -= 1
elif e.key == pygame.K_RIGHT or e.key == pygame.K_l:
self.pick_location[0] += 1
#.........这里部分代码省略.........
示例14: Player
# 需要导入模块: from renderer import Renderer [as 别名]
# 或者: from renderer.Renderer import render [as 别名]
import sys
import pygame
from pygame.locals import *
from renderer import Renderer
from player import Player
from world import World
pygame.init()
DISPLAYSURF = pygame.display.set_mode((1024, 768))
pygame.display.set_caption('Hello World!')
player = Player("bob")
world = World('world1', [player])
c = Renderer(world, (0, 0), (1024, 768), player)
while True:
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
DISPLAYSURF.blit(c.render(), (0, 0))
pygame.display.update()
示例15: Screen
# 需要导入模块: from renderer import Renderer [as 别名]
# 或者: from renderer.Renderer import render [as 别名]
screenBottom = 0.2
screen = Screen(pixelX, screenTop, screenBottom, numPixels)
refIntersectTolerance = 1e-5
refTolerance = 1e-5
viewRayDeltaRef = 1e-5
phi = dataset.phi
rho = dataset.rho
tf = dataset.tf
refPhiPlane = SplinePlane(phi, splineInterval, refIntersectTolerance)
refSplineModel = SplineModel(tf, refPhiPlane, rho, refTolerance)
renderer = Renderer(eye, screen)
renderData = RenderData(ModelType.REFERENCE, viewRayDeltaRef)
renderData.renderResult = renderer.render(refSplineModel, viewRayDeltaRef)
fileHandler = FileHandler()
fileHandler.setFiledir('output/vgresults')
fileHandler.save(renderData, 'reference')
pref = PixelPlotter(axref)
pref.plotPixelColors(renderData.renderResult.colors)
axref.set_aspect(aspectRatio)
figref.tight_layout()
plt.figure(figref.number)
plt.savefig("output/vg/pixelsReference.pdf", format="pdf", transparent=True)