Re: [pygame] Re: Drawing/Surface performance

["René Dudfield" <renesd@xxxxxxxxx>]

Could you cache an image with each of the different palettes set, then
instead of set_palette do copy(), then blit?  I'm not sure if that'd
be faster.

Have you timed each part of your function to make sure that's the slow part?

If on linux/osx use time.time otherwise time.clock on windows.

t0 = time.time()
# part 1
t1 = time.time()
# part 2
t2 = time.time()
# part 3
t3 = time.time()


cu.


On Feb 1, 2008 12:35 PM, René Dudfield <renesd@xxxxxxxxx> wrote:
> what os?
>
> Have you tried using convert() and convert_alpha() on the surfaces?
>
> I think some OS's are emulating palette changes slowly these days.
> Well at least some X11 implementations.
>
>
>
>
> On Feb 1, 2008 12:22 PM, Stuart Axon <stu.axon+pygame@xxxxxxxxx> wrote:
> > I simplified my create_surface... by keeping copies of the indexed
> > (greyscale) image and it's palette; but still slow...
> > I'm wondering -
> >   Would locking surfaces help
> >   Is the pygame 1.8 buffer object relevant here?
> >   Would surarray be quicker?
> >   The palette manipulation seems like it could def be quicker; but my
> > python knowledge isn't good enough here.
> >
> > For performance reference I'm using a 1.5ghz centrino core 2 thingy.
> >
> > Simplified create_surface:
> >
> >     def create_surface(self, colour):
> >         # Check cache
> >         #p_colour = utils.pack_colour(colour)
> >         #if p_colour in Block.surface_cache:
> >         #    return Block.surface_cache[p_colour]
> >
> >         pal_image = Block.indexed_image.copy()
> >         # Manipulate the palette
> >         pal_image.set_palette(self.colourise_palette(Block.indexed_palette,
> > colour))
> >
> >         image = pygame.Surface((Block.width, Block.height), pygame.SRCALPHA, 32)
> >         image.blit(pal_image, (0, 0), image.get_rect())
> >
> >         # Apply the alpha to our newly colourised image
> >         pygame.surfarray.pixels_alpha(image)[...] = Block.alpha_channel
> >
> >         # Add to cache; eviction policy might be nice ;)
> >         #Block.surface_cache[p_colour] = image
> >
> >         return image
> >
> >
> > On 31/01/2008, Stuart Axon <stu.axon+pygame@xxxxxxxxx> wrote:
> > > Hello,
> > >   I'm combining a paletted surface and an alpha surface so I can
> > > manipulate the colours. As I'm quite new to python + pygame so
> > > slowness is probably down to me :)
> > >
> > > At the moment I cache the surfaces, but if it was realtime it would be
> > > simpler and not use shedloads of memory.
> > >
> > > Both methods seem too slow - especially the palette manipulation
> > > (commenting that out speeds things up quite a bit).  The rest of the
> > > code still seems to be slower than I'd expect without the palette code
> > > enabled; I thought pygame 1.8 might hardware accelerate this, but it
> > > doesn't seem to make a difference (so I'm using 1.7.1 as 1.8 isn't
> > > finished).
> > >
> > > The game (in progress):                                  (python ballbreaker.py)
> > > stuartaxon.com/ballbreaker/pygame.zip          - shows the performance
> > > stuartaxon.com/ballbreaker                             - build with caching
> > >
> > >
> > > Cheers :)
> > >
> > > ---------------------------------------------------------------
> > > These are the relevant two methods from block.py
> > >
> > >     ##
> > >     # Return a surface to represent the block
> > >     #
> > >     def create_surface(self, colour):
> > >         # Check cache
> > >         #p_colour = utils.pack_colour(colour)
> > >         #if p_colour in Block.surface_cache:
> > >         #    return Block.surface_cache[p_colour]
> > >
> > >         # Create 8 bit surface and copy our image there
> > >         pal_image = pygame.Surface((Block.width, Block.height), 0, 8)
> > >         pal_image.set_palette(Block.indexed_image.get_palette())
> > >         pal_image.blit(Block.indexed_image, (0, 0))
> > >
> > >         palette = Block.indexed_image.get_palette()
> > >
> > >         # Manipulate the palette
> > >         pal_image.set_palette(self.colourise_palette(palette, colour))
> > >
> > >         # Create our image palette
> > >         image = pygame.Surface((Block.width, Block.height), pygame.SRCALPHA, 32)
> > >         image.blit(pal_image, (0, 0), image.get_rect())
> > >
> > >         # Get the alpha channel from our alpha image
> > >         alpha_channel = pygame.surfarray.array_alpha(Block.alpha_image)
> > >
> > >         # Apply the alpha to our newly colourised image
> > >         pygame.surfarray.pixels_alpha(image)[...] = alpha_channel
> > >
> > >         # Add to cache; eviction policy might be nice ;)
> > >         # Block.surface_cache[p_colour] = image
> > >
> > >         return image
> > >
> > >     def colourise_palette(self, palette, colour):
> > >         hls_colour = colorsys.rgb_to_hls(*utils.normalize_colour(colour))
> > >
> > >         ##
> > >         # Function for actually altering the colour
> > >         def alter_colour(colour):
> > >             h, l, s = colorsys.rgb_to_hls(*utils.normalize_colour(colour))
> > >             h = hls_colour[0]
> > >             l = (hls_colour[1] + l) / 2.0
> > >             s = 0.95
> > >             return utils.reformat_colour( colorsys.hls_to_rgb(h, l, s) )
> > >
> > >         return map(alter_colour, palette)
> > >
> >
>