Python Renderer.render方法代码示例

# 需要导入模块: 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!"

# 需要导入模块: 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)

# 需要导入模块: 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())

# 需要导入模块: 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

# 需要导入模块: 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)

# 需要导入模块: 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)

# 需要导入模块: 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())

# 需要导入模块: 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())

# 需要导入模块: 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!"

# 需要导入模块: 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)
#.........这里部分代码省略.........

# 需要导入模块: 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

#.........这里部分代码省略.........

# 需要导入模块: 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)

# 需要导入模块: 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
#.........这里部分代码省略.........

# 需要导入模块: 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()

# 需要导入模块: 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)