• PyGameTutorial
• IntroduzioneSurfarray

Introduzione

Questo tutorial cercherà di introdurre agli utenti sia il modulo numerico che quello Surfarray. Per i principianti, il codice che utilizza surfarray può essere abbastanza intimidatorio. Ma in realtà ci sono solo pochi concetti per renderlo sarà attivo e funzionante. Usando il modulo surfarray, è possibile eseguire operazioni a livello di pixel direttamente dal codice python. . La performance può diventare molto vicino al livello che si ottiene scrivendo il codice in C.

Magari ora vorrai fare un salto verso la sezione "Esempi" per avere un'idea di ciò che è possibile fare con questo modulo, quindi cominciamo qui secondo il tuo modo di lavorare.

Ora io non cercherò di ingannare facendoti pensare che tutto è molto semplice. Ottenere effetti più avanzati, modificando i valori dei pixel, è molto delicato. Solo la padronanza del Numeric Python costa un sacco di apprendimento. In questo tutorial sarò in aderenza con le basi e con un sacco di esempi, nel tentativo di “piantarvi” un po' di saggezza. Dopo aver terminato il tutorial dovresti avere una base su come gestire i Surfarray.

Numeric Python

Se non hai il pacchetto Python Numeric installato, è necessario farlo ora. Puoi scaricare il pacchetto da Numeric Downloads Page. Per assicurarsi che Numeric stia lavorando, si dovrebbe ottenere qualcosa come questo dal prompt di Python.

>>> from Numeric import * #importa Numeric 
>>> a = array((1,2,3,4,5)) #crea un'array 
>>> a #ritorna l'array
([1, 2, 3, 4, 5]) 
>>> a[2] #l'inizio dell'array
3 
>>> a*2 #una nuova array con le value a due a due
([ 2,  4,  6,  8, 10])

Come si può vedere, il modulo numerico ci dà un nuovo tipo di dati, l'array. Questo oggetto contiene un array di dimensioni fisse, e tutti i valori all'interno sono dello stesso tipo. L'array può anche essere multidimensionale, che è come noi li useremo con le immagini. Ci sarebbe un po' più da dire riguardo questo argomento, ma è sufficiente per cominciare.

Se guardi l'ultimo comando sopra, vedrai che le operazioni matematiche su Numeric array si applicano a tutti i valori in un array. Si tratta della cosiddetta "operazione tra elementi". Questi arrays possono anche essere usati come normali elenchi. La sintassi dello slicing è la stessa utilizzata sugli oggetti standard di Python. (quindi studia se ne hai bisogno :] ). Ecco qui qualche altro esempio su come lavorare con gli array.

>>> len(a) #restituisce le dimensioni dell'array 
5 
>>> a[2:] #gli elementi dell'array dal secondo in su
([3, 4, 5]) 
>>> a[:-2] #tutto eccetto gli ultimi due array
([1, 2, 3])
>>> a[2:] + a[:-2] #aggiunge primi e ultimi array
([4, 6, 8])
>>> array((1,2,3)) + array((3,4)) #aggiunge array di dimensioni sbagliate
Traceback (innermost last):   File "<interactive input>", line 1, in ?  

Otteniamo un errore con l'ultimo comando, perché cerchiamo aggiungere due matrici di diverse dimensioni. Nell'ordine di due array a due, esse operano le une con le altre, compresi i confronti e l' assegnazione, e quindi devono avere le stesse dimensioni. È molto importante sapere che il nuovo array creato dallo slicing dell'originale ha gli stessi valori di riferimento. Quindi, cambiando i valori in una fetta cambierai anche i valori originali. È importante sapere come è fatto questo.

>>> a #mostra la nostra array di partenza
([1, 2, 3, 4, 5]) 
>>> aa = a[1:3] #taglia a metà due elementi 
>>> aa #mostra gli array tagliati
([2, 3])
>>> aa[1] = 13 #imposta un numero in una parte
>>> a #mostra la scelta nell'array originale
([ 1, 2, 13,  4,  5]) 
>>> aaa = array(a) #fa una copia dell'array 
>>> aaa #mostra la copia dell'array
([ 1, 2, 13,  4,  5]) 
>>> aaa[1:4] = 0 #imposta come numeri nel mezzo 0 
>>> aaa #mostra una copia dell'array
([1, 0, 0, 0, 5]) 
>>> a #mostra di nuovo l'array originale
([ 1, 2, 13,  4,  5]) 

Ora vedremo array con due piccole dimensioni. Non essere troppo preoccupato, per iniziare è la stessa di avere una tupla a due dimensioni (un tupla all'interno di una tupla). Iniziamo subito con due array.

>>> row1 = (1,2,3) #crea una tupla di vals 
>>> row2 = (3,4,5) #un'altra tupla 
>>> (row1,row2) #mostra come tupla a 2D
((1, 2, 3), (3, 4, 5)) 
>>> b = array((row1, row2)) #cre un array a 2D 
>>> b #mostra l'array
([[1, 2, 3],[3, 4, 5]]) 
>>> array(((1,2),(3,4),(5,6))) #mostra un nuovo array a 2D
([[1, 2],[3, 4],[5, 6]]) 

Ora con questa matrice bidimensionale (d'ora in poi come "2D"), siamo in grado di indicizzare valori specifici e di fare dello slicing su entrambe le dimensioni. Semplicemente utilizzando una virgola per separare gli indici ci permette di ricercare / tagliare in più dimensioni. Usando solo ":" come un indice (o non fornendo sufficienti indici) ci dà tutti i valori di quella dimensione. Vediamo come funziona.

>>> b #mostra i nostri array dal precedente array
([[1, 2, 3], [3, 4, 5]]) 
>>> b[0,1] #indice di un singolo valore 
2 
>>> b[1,:] #divide il secondo row array
([3, 4, 5]) 
>>> b[1] #divide il secondo array (come sopra)
([3, 4, 5]) 
>>> b[:,2] #divide l'ultima colonna di array
([3, 5]) 
>>> b[:,:2] #divide l'array in un array 2x2 
([[1, 2],[3, 4]])

Ok, rimanete qui con me, è una questione difficile come si ottiene. Quando si utilizza Numeric non vi è ancora una funzione di slicing. Lo slicing dell'array consente anche di specificare un'incremento di slice. La sintassi per l'incremento di slice è start_index: end_index: incremento.

>>> c = arange(10) #come range, ma crea un'array
>>> c #mostra l'array
([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) 
>>> c[1:6:2] #taglia i vecchi valori di array da 1 a 6
([1, 3, 5])
>>> c[4::4] #taglia ogni quarto valore spartendo dal quarto array
([4, 8])
>>> c[8:1:-1] #taglia tall'1 all'8, reversed array
([8, 7, 6, 5, 4, 3, 2]) 

E' questo. Lì ci sono abbastanza informazioni per cominciare ad usare Numeric con il modulo surfarray. C'è sicuramente molto di più da dire su Numeric, ma questa è solo un'introduzione. Inoltre, vogliamo arrivare alla roba divertente, giusto?

Importazione di Surfarray

Al fine di utilizzare il modulo surfarray abbiamo bisogno di importarlo. Dal momento che sia surfarray che Numeric sono componenti opzionali per pygame, sarebbe bene assicurarsi che l'importazione avvenga correttamente prima di utilizzarle. In questi esempi ho intenzione di importare Numeric in una variabile di nome N. Ciò ti consentirà di sapere quali delle funzioni che sto usando provengono dal pacchetto Numeric. (Ed è molto più breve rispetto a digitare Numeric prima di ogni funzione)

try:
     import Numeric as N 
     import pygame.surfarray as surfarray 
except ImportError:
     raise 
ImportError, "Numeric and Surfarray are required." 

Introduzione al Surfarray

Ci sono due tipi principali di funzioni in surfarray. Un insieme di funzioni per la creazione di un array è una copia dei dati di una surface di pixel. L'altra funzione crea una copia della'array di dati dei pixel, in modo che le modifiche dell'array incidano direttamente sulla superficie originale. Ci sono altre funzioni che permettono di accedere ai valori di pixel per pixel come array con alcune altre utili funzioni. Vedremo queste altre funzioni più tardi.

Quando si lavora con queste surface di array, ci sono due modi di rappresentare i valori dei pixel. In primo luogo, essi possono essere rappresentati come un mappato di interi. Questo tipo di array è un semplice array a 2D con un unico intero rappresentante l'intero e il colore della superficie del tracciato. Questo tipo di array è un bene per le parti in movimento di un'immagine intorno. L'altro tipo di matrice utilizza tre valori RGB per rappresentare ciascun colore dei pixel. Questo tipo di matrice rende estremamente semplice fare tipi di effetti che cambiano il colore di ciascun pixel. Questo tipo di array è anche uleggermente migliore da affrontare, dal momento che è essenzialmente un array 3D numerico. Ancora, una volta che la vostra mente va nel modo giusto, non è molto più difficile che usare il normale 2D array.

Il modulo numerico utilizza una macchina di numeri naturali per rappresentare i valori, così un Numeric array può essere costituito da interi che sono 8bits, 16bits, e 32bits. (Gli array possono utilizzare anche altri tipi come galleggianti e doppie, ma per la nostra immagine di manipolazione abbiamo soprattutto bisogno di preoccuparsi per i tipi interi). A causa di questa limitazione delle dimensioni intero, è necessario prendere un po 'di attenzione che il tipo di array pixel di dati di riferimento che possa essere opportunamente tracciato da un vero e proprio tipo di dati. Le funzioni che creano questi array dalle surface sono:

surfarray.pixels2d(surface)

• Crea un array a 2D (pixel di valori interi), che si riferisce all'originale superficie dati. Questo andrà bene per tutti i formati di superficie, tranne 24bit.

surfarray.array2d(surface)

• Crea un array a 2D matrice (pixel di valori interi), che viene copiato da qualsiasi tipo di superficie.

surfarray.pixels3d(surface)

• Crea un array 3D matrice (RGB valori dei pixel), che il riferimento originale superficie dati. Questo funzionerà solo su superfici con 24bit e 32bit che hanno una formattazione RGB o BGR.

surfarray.array3d(surface)

• Crea un array 3D matrice (RGB valori dei pixel), che viene copiato da qualsiasi tipo di superficie.

Qui è un piccolo grafico che potrebbe illustrare meglio quali tipi di funzioni dovrebbero essere utilizzate tra le varie superfici. Come si può vedere, sia la funzione array2D collaborerà con qualsiasi tipo di superficie.

Esempi

Con queste informazioni, siamo attrezzati per iniziare a provare le cose con la superficie degli array. I seguenti sono brevi dimostrazioni che creano un Numeric array e li visualizzano in pygame. Queste diverse prove si trovano negli esempi arraydemo.py . Vi è una semplice funzione di nome surfdemo_show che visualizza un array sullo schermo.

# Da includere la tabella.

CategoryDocumentazione