Color, imatges i transparència
==============================

Color
-----

* `La física del color <http://en.wikipedia.org/wiki/Color#Physics_of_color>`__

* `Percepció del color <http://en.wikipedia.org/wiki/Color#Color_in_the_eye>`__

* `Models de color <http://ca.wikipedia.org/wiki/Color#Models_de_color>`__

  -  `El model RGB <http://en.wikipedia.org/wiki/RGB_color_model>`__
  -  `Els models HLS i HSV <http://en.wikipedia.org/wiki/HSL_and_HSV>`__

* Una `breu història de l'evolució del color als videojocs <http://www.colourlovers.com/business/blog/2011/11/03/the-colorful-history-of-video-games-infographic-2>`__.

Imatges
-------

Tipus d'imatges digitals: `mapa de bits (raster o pixmap) i
vectorials <http://en.wikipedia.org/wiki/Digital_image>`__.

Les imatges digitals es poden representar utilitzant una `paleta de
colors <http://en.wikipedia.org/wiki/Palette_%28computing%29>`__.

Els mapes de bits solen estar en el format
`RGBA <http://en.wikipedia.org/wiki/RGBA_color_space>`__, que inclou
informació sobre la `transparència (canal
alfa). <http://en.wikipedia.org/wiki/Transparency_%28graphic%29>`__

`Formats de fitxers d'imatges
<http://en.wikipedia.org/wiki/Image_file_formats#Major_graphic_file_formats>`__.
Els més usats en internet són:

-  JPEG: escala de grisos (8 bits) o bé
   `truecolor <http://en.wikipedia.org/wiki/Color_depth#True_color_.2824-bit.29>`__
   (24 bits). No admet transparència. Compressió amb pèrdues.
-  PNG: paleta de 256 colors o bé truecolor (24/48 bits). Admet
   transparència. Compressió sense pèrdues.
-  GIF: paleta de 256 colors. Admet transparència i animacions (no
   suportades per pygame; vegeu però, `[1] <http://www.pygame.org/project-GIFImage-1039-.html>`_).

Les imatges en Pygame
---------------------

-  Les imatges són objectes de classe
   `Surface <http://www.pygame.org/docs/ref/surface.html>`__.
-  L'operació més habitual és
   `blit <http://www.pygame.org/docs/ref/surface.html#pygame.Surface.blit>`__:
   enganxar una imatge damunt d'una altra.
-  El mòdul
   `transform <http://www.pygame.org/docs/ref/transform.html>`__
   proporciona operacions sobre la imatge completa: mirall, rotació,
   escalat, ...
-  El mòdul `draw <http://www.pygame.org/docs/ref/draw.html>`__
   proporciona funcions per dibuixar damunt d'una imatge: línies,
   polígons, cercles, el·lipses, ...
-  El mòdul
   `surfarray <http://www.pygame.org/docs/ref/surfarray.html>`__ permet
   treballar a nivell de píxel accedint-hi com a les matrius de la
   biblioteca `numpy <http://www.numpy.org/>`__.
-  La instanciació d'objectes de classe ``Surface`` té els paràmetres
   opcionals ``flags`` i ``depth`` que permeten controlar algunes
   característiques de la imatge com ara el tipus de transparència o
   l'ús de paleta.

Altres biblioteques de Python per treballar amb imatges: `Pyhton Image
Library (PIL) <http://www.pythonware.com/products/pil/>`__,
`scikit-image <http://scikit-image.org/>`__.

Gestió de la transparència en pygame
------------------------------------

La transparència és un valor, que sovint s'anomena alfa (alpha), que pot
variar des de 0 (totalment transparent) fins a 255 (totalment opac).
Així, un valor alfa=127 correspon a una transparència del 50%.

En pygame hi ha tres maneres d'aconseguir imatges
transparents/translúcides:

#. *Per-image transparency*. Les surfaces [sense píxels transparents]
   poden tenir un valor (global) de transparència. Vegeu
   `[2] <http://www.pygame.org/docs/ref/surface.html#pygame.Surface.set_alpha>`__.
#. Utilitzant un color clau (*color-key transparency*). D'això se'n diu
   "tintar". Tots els píxels d'un cert color d'una surface [sense píxels
   transparents] són transparents. Vegeu
   `[3] <http://www.pygame.org/docs/ref/surface.html#pygame.Surface.set_colorkey>`__.
#. *Per-pixel transparency*. Cada píxel d'una surface de tipus RGBA té
   un valor alpha (A) de transparència. el "quart canal", també anomenat
   canal alfa, correspon al nivell de transparència. Vegeu el *flag*
   ``pygame.SRCALPHA`` a
   `[4] <http://www.pygame.org/docs/ref/surface.html#pygame.Surface>`__.

Les imatges RGBA només són suportades per segons quins formats de fitxer
d'imatges (per exemple PNG, però no JPG). Per tant, si la imatge es
carrega de fitxer, potser s'haurà de convertir a RGBA, si es vol
transparència. En qualsevol cas, si volem mantenir la transparència en
llegir de fitxer, caldrà utilitzar el mètode ``convert_alpha``. Per
exemple, si disposem de la imatge de més avall desada en el fitxer
``exemple_colors.png``, podem provar de fer

.. image:: Exemple_colors.png
   :height: 50
   :align: center

.. code:: python

    >>> import pygame
    >>> pygame.init()
    (6, 0)
    >>> finestra = pygame.display.set_mode((600, 400))
    >>> surf = pygame.image.load('exemple_colors.png').convert_alpha()

I després la visualitzem en diversos llocs:

.. code:: python

    >>> finestra.fill((255,255,255))
    <rect(0, 0, 600, 400)>
    >>> finestra.blit(surf, (0,0))
    <rect(0, 0, 256, 256)>
    >>> finestra.blit(surf, (250,0))
    <rect(250, 0, 256, 256)>
    >>> finestra.blit(surf, (280,40))
    <rect(280, 40, 256, 256)>
    >>> pygame.display.flip()

Tingueu en compte que encara que la imatge tingui píxels transparents,
el rectangle de la surface sempre serà el de la tota la imatge; això és
important a l'hora de :doc:`calcular col·lisions <../Col·lisions/index>`.