Home > Gtk3, PyGObject, python > PyGObject: GdkPixbuf.Pixbuf

PyGObject: GdkPixbuf.Pixbuf

13 Aprile 2020

torna all’indice appunti

Pixbuf

Il widget GdkPixbuf.Pixbuf è la struttura principale della libreria GdkPixbuf.
Viene usato per rappresentare un’immagine e contiene tutte le informazioni della stessa come:
i dati dei pixel dell’immagine, il suo color space, i bits per sample,
larghezza e altezza e il rowstride (il numero dibytes tra l’inizio di una riga e
l’inizio della successiva).

Ne consegue che le properties relative alla classe GdkPixbuf.Pixbuf sono:

Name Type Flags Short Description
bits-per-sample int r/w/co/en il numero di bit per sample
colorspace GdkPixbuf.Colorspace r/w/co/en Il colorspace nel quale i samples sono interpretati
has-alpha bool r/w/co/en Se il pixbuf ha un canale alpha
height int r/w/co/en il numero di righe del pixbuf
n-channels int r/w/co/en Il numero di samples per pixel
pixel-bytes GLib.Bytes r/w/co/en I dati del pixel ReadOnly
pixels int r/w/co/en I pixel data del pixbuf
rowstride int r/w/co/en I bytes tra l’inizio di una riga e l’inizio della successiva
width int r/w/co/en Il numero di colonne del pixbuf

Metodi

Oltre ai soliti getter e setter relativi alle properties dell’oggetto GdkPixbuf.Pixbuf,
i principali metodi sono:

calculate_rowstride(colorspace, has_alpha, bits_per_sample, width, height)

Calcola il rowstride che un’immagine creata con i parametri passati come argomenti dovrebbe avere.
Parametri:
colorspace: il GdkPixbuf.Colorspace per l’immagine;
has_alpha: un boolean per avere informazioni sulla trasparenza;
bits_per_sample: il numero di bit per color sample;
width: larghezza dell’immagine in pixels, deve essere > 0;
height: altezza dell’immagine in pixels, deve essere > 0;

get_file_info(filename)

Esegue il parsing di un file immagine e ritorna una tupla con il formato dell’immagine come
oggetto GdkPixbuf.PixbufFormat e le dimensioni dell’immagine stessa.
Se il formato dell’immagine non viene riconosciuto viene ritornato None e lo
stesso discorso vale per le dimensioni:

>>> import gi
... gi.require_version('Gtk', '3.0')
... from gi.repository import Gtk
... from gi.repository import GdkPixbuf
>>> GdkPixbuf.Pixbuf.get_file_info("image.png")
(<GdkPixbuf.PixbufFormat object at 0x00000000040c6be0 (GdkPixbufFormat at 0x0000000004fa90c0)>, width=48, height=48)
>>> GdkPixbuf.Pixbuf.get_file_info("unknown.png")
(None, width=0, height=0)

Parametri:
filename: il nome del file da identificare;

get_file_info_async(filename, cancellable, callback, *user_data)

In modo asincrono esegue il parsing di un file immagine e ritorna una tupla contenente il formato
e le dimensioni dell’immagine. Per maggiorni dettagli vedi GdkPixbuf.Pixbuf.get_file_info(),
che è la versione sincrona di questo metodo.
Quando l’operazione è terminata la callback in argomento, verrà chiamata nel thread principale.
A quel punto si chiamerà il metodo GdkPixbuf.Pixbuf.get_file_info_finish() per avere il risultato.

Parametri:
filename: la stringa con il nome del file da identificare;
cancellable: un oggetto Gio.Cancellable opzionale o None;
callback: una callback Gio.AsyncReadyCallback da invocare quando
le informazioni dell’immagine sono disponibili, o None;
user_data: i dati opzionali da passare alla callback;

get_file_info_finish(async_result)

Termina un’operazione di parsing asincrona, iniziata con GdkPixbuf.Pixbuf.get_file_info_async() e
ritorna un oggetto GdkPixbuf.PixbufFormat che descrive il formato dell’immagine del file, o
None se il file non è stato riconosciuto.
Parametri:
async_result: un oggetto Gio.AsyncResult;

get_formats()

Ritorna la lista degli oggetti GdkPixbuf.PixbufFormat,
che rappresentano i formati supportati dal pixbuf.

>>> for format in GdkPixbuf.Pixbuf.get_formats():
...     print(format.get_description())    
...     
WMF
EMF
Windows animated cursor
BMP
GIF
MacOS X icon
...

init_modules(path)

Inizializza i moduli del loader di gdkpixbuf referenziati dal file loaders.cache presente nella
directory.
Parametri:
path: la stringa col percorso della directory dove il file
loaders.cache è installato.

new(colorspace, has_alpha, bits_per_sample, width, height)

Crea un nuovo GdkPixbuf.Pixbuf e alloca un buffer per esso. Il buffer ha un rowstride ottimale:

>>> pixbuf = GdkPixbuf.Pixbuf.new(colorspace=colorspace, has_alpha=True,
...                               bits_per_sample=8, width=48, height=48)
>>> pixbuf.get_rowstride()
192

Parametri:
colorspace: il GdkPixbuf.Colorspace per l’immagine;
has_alpha: un boolean per avere informazioni sulla trasparenza;
bits_per_sample: il numero di bit per color sample;
width: larghezza dell’immagine in pixels, deve essere > 0;
height: altezza dell’immagine in pixels, deve essere > 0;

new_from_bytes(data, colorspace, has_alpha, bits_per_sample, width, height, rowstride)

Crea un nuovo GdkPixbuf.Pixbuf out of in-memory readonly image data.
Al momento sono supportate solo immagini RGB con 8 bits per sample.
Questa è la variante GLib.Bytes del metodo GdkPixbuf.Pixbuf.new_from_data().
Parametri:
data: i dati immagine in formato 8-bit/sample;
colorspace: il GdkPixbuf.Colorspace per l’immagine;
has_alpha: un boolean per avere informazioni sulla trasparenza;
bits_per_sample: il numero di bit per color sample;
width: larghezza dell’immagine in pixels, deve essere > 0;
height: altezza dell’immagine in pixels, deve essere > 0;
rowstride: distanza in bytes tra gli inizi riga;

new_from_data(data, colorspace, has_alpha, bits_per_sample, width, height, rowstride, destroy_fn, *destroy_fn_data)

Crea un nuovo GdkPixbuf.Pixbuf out of in-memory image data.
Al momento sono supportate solo immagini RGB con 8 bits per sample.
Dal momento che forniamo un pixel buffer pre allocato, dobbiamo anche specificare un modo per
liberare quei dati. Questo è ottenuto con una funzione GdkPixbuf.PixbufDestroyNotify.
Quando un pixbuf è finalizzato la nostra “destroy notification function” viene chiamata e sarà
incaricata di liberare i dati relativi ai pixel. Vedere anche GdkPixbuf.Pixbuf.new_from_bytes().
Parametri:
data: i dati immagine in formato 8-bit/sample;
colorspace: il GdkPixbuf.Colorspace per l’immagine;
has_alpha: un boolean per avere informazioni sulla trasparenza;
bits_per_sample: il numero di bit per color sample;
width: larghezza dell’immagine in pixels, deve essere > 0;
height: altezza dell’immagine in pixels, deve essere > 0;
rowstride: distanza in bytes tra gli inizi riga;
destroy_fn: la funzione GdkPixbuf.PixbufDestroyNotify utilizzata
a pixbuf finalizzato, o None se non importa distruggere i dati;
destroy_fn_data: i dati da passare alla destroy notification
function;

new_from_file(filename)

Crea un nuovo pixbuf caricando l’immagine da un file. Il formato del file viene riconosciuto
automaticamente. Se si dovessere verificare errori nell’operazione, verrà ritornato None.
Parametri:
filename: la stringa con il nome del file da caricare;

new_from_file_at_scale(filename, width, height, preserve_aspect_ratio)

Crea un nuovo pixbuf caricando l’immagine da un file. Il formato del file viene riconosciuto
automaticamente. Se si dovessere verificare errori nell’operazione, verrà ritornato None.
L’immagine sarà scalata sulle dimensioni richieste, opzionalmente preservando l’aspect ratio.
Quando preserviamo l’aspect ratio, con width=-1 scaliamo l’immagine sull’altezza data,
con height=-1 scaliamo l’immagine sulla larghezza data.
Se non preserviamo l’aspect ratio, width=-1 o height=-1 significa non scalare l’immagine su
quella dimensione.

>>> pixbuf = GdkPixbuf.Pixbuf.new_from_file("image.png")
>>> pixbuf.get_width()
48
>>> pixbuf.get_height()
48
>>> sc_pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_scale("image.png", width=64, height=82, 
...                                                     preserve_aspect_ratio=True)
>>> sc_pixbuf.get_width()
64
>>> sc_pixbuf.get_height()  # forced by aspect ratio
64

Parametri:
filename: la stringa con il nome del file da caricare;
width: la larghezza che l’immagine dovrà avere o -1 per non
forzare la dimensione;
height: : l’altezza che l’immagine dovrà avere o -1 per non
forzare la dimensione;
preserve_aspect_ratio il boolean che decide se preservare o meno
l’aspect ratio dell’immagine;

new_from_file_at_size(filename, width, height)

Crea un nuovo pixbuf caricando l’immagine da un file. Il formato del file viene riconosciuto
automaticamente. Se si dovessere verificare errori nell’operazione, verrà ritornato None.
L’immagine sarà scalata sulle dimensioni richieste, preservando però l’aspect ratio,
potrebbe quindi capitare che il pixbuf risultante sia più piccolo rispetto a larghezza e altezza
richieste, proprio a causa dell’aspect ratio.
Per rispettare in toto le dimensioni richieste senza tenere conto dell’aspect ratio,
utilizzare il metodo GdkPixbuf.Pixbuf.new_from_file_at_scale().
Parametri:
filename: la stringa con il nome del file da caricare;
width: la larghezza che l’immagine dovrebbe avere;
height: l’altezza che l’immagine dovrebbe avere;

new_from_resource(resource_path)

Crea un nuovo pixbuf caricando un’immagine da una “resource”.
Il formato del file viene riconosciuto
automaticamente. Se si dovessere verificare errori nell’operazione, verrà ritornato None.
Parametri:
resource_path: la stringa con il path della risorsa;

new_from_resource_at_scale(resource_path, width, height, preserve_aspect_ratio)

Crea un nuovo pixbuf caricando un’immagine da una “resource”.
Il formato del file viene riconosciuto automaticamente.
Se si dovessere verificare errori nell’operazione, verrà ritornato None.
L’immagine sarà scalata sulle dimensioni richieste, opzionalmente preservando l’aspect ratio.
Quando preserviamo l’aspect ratio, con width=-1 scaliamo l’immagine sull’altezza data,
con height=-1 scaliamo l’immagine sulla larghezza data.
Se non preserviamo l’aspect ratio, width=-1 o height=-1 significa non scalare l’immagine su
quella dimensione.
Nota: Lo stream non viene chiuso da questo metodo.
Parametri:
resource_path: la stringa con il path della risorsa;
width: la larghezza che l’immagine dovrà avere o -1 per non
forzare la dimensione;
height: : l’altezza che l’immagine dovrà avere o -1 per non
forzare la dimensione;
preserve_aspect_ratio il boolean che decide se preservare o meno
l’aspect ratio dell’immagine;

new_from_stream(stream, cancellable)

Crea un nuovo pixbuf caricando un’immagine da uno stream in input.
Il formato del file viene riconosciuto automaticamente.
Se si dovessere verificare errori nell’operazione, verrà ritornato None.
Il cancellable può essere usato per abortire l’operazione da un altro thread.
Se l’operazione viene cancellata viene ritornato l’errore Gio.IOErrorEnum.CANCELLED.
Nota: Lo stream non viene chiuso da questo metodo.
Parametri:
stream: un Gio.InputStream dal quale caricare il pixbuf;
cancellable: un Gio.Cancellable opzionale o None;

new_from_stream_async(stream, cancellable, callback, *user_data)

Crea un nuovo pixbuf in maniera asincrona, caricando un’immagine da uno stream in input.
Per maggiori dettagli vedere GdkPixbuf.Pixbuf.new_from_stream(), che è la versione sincrona del
metodo in oggetto. Quando l’operazione è terminata, una callback viene invocata nel main thread.
E’ possibile quindi chiamare il metodo GdkPixbuf.Pixbuf.new_from_stream_finish() per ottenere il
risultato di questa operazione.
Parametri:
stream: un Gio.InputStream dal quale caricare il pixbuf;
cancellable: un oggetto Gio.Cancellable opzionale o None;
callback: una callback Gio.AsyncReadyCallback da invocare quando
le informazioni dell’immagine sono disponibili, o None;
user_data: i dati opzionali da passare alla callback;

new_from_stream_at_scale(stream, width, height, preserve_aspect_ratio, cancellable)

Crea un nuovo pixbuf caricando un’immagine da uno stream in input.
Il formato del file viene riconosciuto automaticamente.
Se si dovessere verificare errori nell’operazione, verrà ritornato None.
Il cancellable può essere usato per abortire l’operazione da un altro thread.
Se l’operazione viene cancellata viene ritornato l’errore Gio.IOErrorEnum.CANCELLED.
L’immagine sarà scalata sulle dimensioni richieste, opzionalmente preservando l’aspect ratio.
Quando preserviamo l’aspect ratio, con width=-1 scaliamo l’immagine sull’altezza data,
con height=-1 scaliamo l’immagine sulla larghezza data.
Se non preserviamo l’aspect ratio, width=-1 o height=-1 significa non scalare l’immagine su
quella dimensione.
Nota: Lo stream non viene chiuso da questo metodo.
Parametri:
stream: un Gio.InputStream dal quale caricare il pixbuf;
width: la larghezza che l’immagine dovrà avere o -1 per non
forzare la dimensione;
height: : l’altezza che l’immagine dovrà avere o -1 per non
forzare la dimensione;
preserve_aspect_ratio il boolean che decide se preservare o meno
l’aspect ratio dell’immagine;
cancellable: un oggetto Gio.Cancellable opzionale o None;

new_from_stream_at_scale_async(stream, width, height, preserve_aspect_ratio, cancellable, callback, *user_data)

Crea un nuovo pixbuf in maniera asincrona, caricando un’immagine da uno stream in input.
Per maggiori dettagli vedere GdkPixbuf.Pixbuf.new_from_stream_at_scale(), che è la versione
sincrona del metodo in oggetto. Quando l’operazione è terminata, una callback viene invocata nel
main thread. E’ possibile quindi chiamare il metodo GdkPixbuf.Pixbuf.new_from_stream_finish() per
ottenere il risultato di questa operazione.
Parametri:
stream: un Gio.InputStream dal quale caricare il pixbuf;
width: la larghezza che l’immagine dovrà avere o -1 per non
forzare la dimensione;
height: : l’altezza che l’immagine dovrà avere o -1 per non
forzare la dimensione;
preserve_aspect_ratio il boolean che decide se preservare o meno
l’aspect ratio dell’immagine;
cancellable: un oggetto Gio.Cancellable opzionale o None;
callback (Gio.AsyncReadyCallback or None) – a Gio.AsyncReadyCallback to call when the pixbuf is loaded
user_data (object or None) – the data to pass to the callback function
callback: una callback Gio.AsyncReadyCallback da invocare quando
le informazioni dell’immagine sono disponibili, o None;
user_data: i dati opzionali da passare alla callback;

new_from_stream_finish(async_result)

Termina un’operazione asincrona di creazione di un pixbuf iniziata con il metodo
GdkPixbuf.Pixbuf.new_from_stream_async().
Parametri:
async_result: un oggetto Gio.AsyncResult;

new_from_xpm_data(data)

Crea un nuovo pixbuf analizzando i dati XPM in memoria.
Questi dati sono comunemente il risultato dell’inclusione di un file XPM in una sorgente C.
Parametri:
data: i dati XPM inline;

save_to_stream_finish(async_result)

Termina un’operazione asincrona di salvataggio pixbuf.
Parametri:
async_result: un oggetto Gio.AsyncResult;

add_alpha(substitute_color, r, g, b)

Prende un pixbuf esistente e aggiunge un canale alpha (trasparenza) ad esso.
Se il pixbuf ha già un canale alpha, i valori del canale sono copiati dall’originale,
altrimenti il canale alpha viene inizializzato a 255 (opacità piena).
Se substitute_color è True, allora ai colori specificati da “r”, “g”, “b”, sarà
assegnata opacità zero. Esempio, se passiamo (255, 255, 255) per il substitute color,
tutti i pixel bianchi diventeranno completamente trasparenti.
Parametri:
substitute_color: boolean per settare un colore a opacità zero;
Se falso, gli argomenti r, g, b vengono ignorati.
r: il valore Red da sostituire;
g: il valore Green da sostituire;
b: il valore Blue da sostituire;

apply_embedded_orientation()

Prende un pixbuf esistente e controlla che sia presente un’opzione/tag “orientation”associato,
il quale può essere fornito dal loader jpeg (che legge il teg “exif orientation”), o dal loader
tiff (che legge il tag tiff orientation e lo compensa per le trasformazioni eseguite da libtiff).
Se è presente un’opzione/tag “orientation”, verrà eseguita l’appropriata trasformazione, così
da orientare il pixbuf correttamente. Verrà quindi ritornato il nuovo Pixbuf o None.

composite(dest, dest_x, dest_y, dest_width, dest_height, offset_x, offset_y, scale_x, scale_y, interp_type, overall_alpha)

Crea una trasformazione del pixbuf scalandolo secondo “scale_x” e “scale_y” e traslandolo secondo
gli offset “offset_x” e “offset_y”. Questo da un’immagine nelle coordinate del pixbuf di
destinazione. Il rettangolo (dest_x, dest_y, dest_width, dest_height) è quindi “alpha blended” sul
rettangolo corrispondente dell’immagine di destinazione originale.
Quando il rettangolo di destinazione contiene parti non presenti nell’immagine sorgente,
i dati ai bordi dell’immagine sorgente vengono replicati all’infinito.
Vedere Alpha compositing/blending

Parametri:
dest: il GdkPixbuf.Pixbuf nel quale fare il render del risultato;
dest_x: la coord. X (sx) della regione su cui fare il render;
dest_y: la coord. Y (top) della regione su cui fare il render;
dest_width: la larghezza della regione su cui fare il render;
dest_height: l’altezza della regione su cui fare il render;
offset_x: l’offset (float) in direzione X;
offset_y: l’offset (float) in direzione Y;
scale_x: il fattore di scala (float) in direzione X;
scale_y: il fattore di scala (float) in direzione Y;
interp_type: l’interpolazione GdkPixbuf.InterpType per la trasf.;
overall_alpha: l’alpha totale per l’immagine sorgente (0-255);

composite_color(dest, dest_x, dest_y, dest_width, dest_height, offset_x, offset_y, scale_x, scale_y, interp_type, overall_alpha, check_x, check_y, check_size, color1, color2)

Crea una trasformazione del pixbuf scalandola secondo “scale_x” e “scale_y” e traslandolo secondo
gli offset “offset_x” e “offset_y”, quindi esegue l’alpha blending del risultato, sul rettangolo
di destinazione (“dest_x”, “dest_y”, “dest_width”, “dest_height”) con un checkboard dei colori
“color1” e “color2” ed esegue il render sull’immagine di destinazione.
Se l’immagine di sorgente non ha un alpha channel, e overall_alpha=255, viene usata una
scorciatoia omettendo l’alpha blending ed eseguendo solo la scalatura dell’immagine.
Parametri:
dest: il GdkPixbuf.Pixbuf nel quale fare il render del risultato;
dest_x: la coord. X (sx) della regione su cui fare il render;
dest_y: la coord. Y (top) della regione su cui fare il render;
dest_width: la larghezza della regione su cui fare il render;
dest_height: l’altezza della regione su cui fare il render;
offset_x: l’offset (float) in direzione X;
offset_y: l’offset (float) in direzione Y;
scale_x: il fattore di scala (float) in direzione X;
scale_y: il fattore di scala (float) in direzione Y;
interp_type: l’interpolazione GdkPixbuf.InterpType per la trasf.;
overall_alpha: l’alpha totale per l’immagine sorgente (0-255);
check_x: l’offset X del checkboard;
check_y: l’offset Y del checkboard;
check_size: il size dei controlli nel checkboard (potenza di 2)
color1: il colore del check al superiore sinistro (checkboard);
color2: il colore dell’altro check;

Vedere GdkPixbuf.Pixbuf.composite_color_simple() per una variante più semplice di questo metodo.

composite_color_simple(dest_width, dest_height, interp_type, overall_alpha, check_size, color1, color2)

Crea un nuovo GdkPixbuf.Pixbuf scalandolo con “dest_width x dest_height” ed eseguendo l’alpha
blending del risultato con un checkboard di colori “color1” e “color2”.
Parametri:
dest_width: la larghezza dell’immagine di destinazione;
dest_height: l’altezza dell’immagine di destinazione;
interp_type: l’interpolazione GdkPixbuf.InterpType per la trasf.;
overall_alpha: l’alpha totale per l’immagine sorgente (0-255);
check_size: il size dei controlli nel checkboard (potenza di 2)
color1: il colore del check al superiore sinistro (checkboard);
color2: il colore dell’altro check;

copy()

Crea un nuovo GdkPixbuf.Pixbuf con una copia delle informazioni presenti nel pixbuf.
Questo non copia le opzioni settate nel pixbuf originali, per eseguire una copia completa usare
il metodo GdkPixbuf.Pixbuf.copy_options().

copy_area(src_x, src_y, width, height, dest_pixbuf, dest_x, dest_y)

Copia un’area rettangolare dal pixbuf, al “dest_pixbuf”. La conversione del formato, avviene in
maniera automatica. Se il rettangolo sorgente si sovrappone al rettangolo di destinazione sullo
stesso pixbuf, sarà sovrascritto durante la copia, perciò non possiamo usare questo metodo per
fare lo scroll di un pixbuf.
Parametri:
src_x: La coord. X del rettangolo sorgente;
src_y: La coord. Y del rettangolo sorgente;
width: La larghezza dell’area da copiare;
height: L’altezza dell’area da copiare;
dest_pixbuf: il GdkPixbuf.Pixbuf di destinazione;
dest_x: La coord. X del pixbuf di destinazione;
dest_y: La coord. Y del pixbuf di destinazione;

copy_options(dest_pixbuf)

Copia le coppie key/value relative alle opzioni di un GdkPixbuf.Pixbuf, in un altro.
Questo è comodo per mantenere i metadata originali dopo aver modificato un file.
Comunque fare attenzione a rimuovere i metadata che abbiamo già applicato, come ad esempio
l’opzione “orientation” dopo la rotazione dell’immagine.
Parametri:
dest_pixbuf: il GdkPixbuf.Pixbuf su cui copiare le opzioni;

fill(pixel)

Cancella un pixbuf al valore RGBA dato, convertendo il valore RGBA nel formato pixel del pixbuf.
Il valore alpha sarà ignorato se il pixbuf non ha un alpha channel.
Parametri:
pixel: il pixel RGBA da cancellare (0xffffffff è bianco opaco,
mentre 0x00000000 è nero trasparente)

flip(horizontal)

Capovolge un pixbuf orizzontalmente o verticalmente e ritorna il pixbuf risultante.
Parametri:
horizontal: il boolean che settato a True
capovolge il pixbuf orizzontalmente, mentre a False, verticalmente;

get_bits_per_sample()

Ritorna il numero di bits per color sample nel pixbuf.

get_byte_length()

Ritorna la lunghezza in bytes dei pixel data.

get_colorspace()

Ritorna il GdkPixbuf.Colorspace del pixbuf.

get_has_alpha()

Ritorna True se il pixbuf ha un alpha channel, altrimenti False.
L’alpha channel è l’informazione relativa all’opacità del pixbuf.

get_height()

Ritorna l’altezza del pixbuf espressa in pixels.

get_n_channels()

Ritorna il numero di canali di un pixbuf.

get_option(key)

Cerca la chiave nel dizionario i opzioni che sono state associate al pixbuf quando questo è stato
caricato o che potrebbe essere stata settata in seguito con GdkPixbuf.Pixbuf.set_option().
Alcuni esempi:
Il loader ANI fornisce le opzioni “Title” e “Artist”.
I loaders ICO, XBM, e XPM forniscono le opzioni hot-spot “x_hot” e “y_hot” per la definizione del
cursore. Il loader PNG fornisce, come opzioni, le coppie chiave/valore tEXt-ancillary-chunk.
I loaders TIFF e JPEG ritornano un’opzione “orientation” corrispondente al tag “orientation”
TIFF/Exif (se presente).
Il loader TIFF setta l’opzione “multipage” a “yes” quando un TIFF multi-page viene caricato.
I loaders JPEG e PNG settano le opzioni “x-dpi” e “y-dpi” se il file contiene informazioni
sulla densitò di immagine in punti per pollice.
Il loader JPEG setta l’opzione “comment” con il tag EXIF.
Parametri:
key: la stringa con la quale della quale chiediamo il valore;

get_options()

Ritorna un dizionario GLib.HashTable di chiavi/valori contenente le opzioni che possono essere
state settate, quando il pixbuf è stato caricato o che potrebbero essere state aggiunte in seguito
con GdkPixbuf.Pixbuf.set_option().
Vedere GdkPixbuf.Pixbuf.get_option() per maggiori dettagli.

get_pixels()

Ritorna i pixel data di un pixbuf.

>>> pixbuf.get_pixels()
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0...

get_rowstride()

Ritorna il rowrowstride del pixbuf, ovvero la distanza, in bytes, tra l’inizio di una riga e
l’inizio della riga successiva.

>>> pixbuf.get_rowstride()
192
>>> len(pixbuf.get_pixels())/pixbuf.get_rowstride()
48.0
>>> pixbuf.get_height()
48

get_width()

Ritorna la larghezza in pixels di un pixbuf.

new_subpixbuf(src_x, src_y, width, height)

Crea un nuovo pixbuf che rappresenta una “sottoregione” del pixbuf in oggetto.
Il nuovo pixbuf condivide i propri pixels con il pixbuf originale, così facendo la scrittura
di un bixbuf ha effetto su entrambi.
Il nuovo pixbuf mantiene un riferimento sul pixbuf di partenza, così il pixbuf in oggetto non
verrà finalizzato fino a che il nuovo pixbuf non lo sarà.
Se il pixbuf di partenza è in sola lettura, questo metodo lo forzerà in scrittura.
Parametri:
src_x: la coordinata X del pixbuf sorgente;
src_y: la coordinata Y del pixbuf sorgente;
width: la larghezza della regione nel pixbuf;
height: l’altezza della regione nel pixbuf;

read_pixel_bytes()

Ritorna un oggetto GLib.Bytes contenente i dati raw del pixel.
Questi dati non devono essere modificati.
Questo metodo permette di saltare la copia implicita che deve essere fatta se il metodo
GdkPixbuf.Pixbuf.get_pixels() viene chiamato su un pixbuf read-only.

>>> pixbuf.read_pixel_bytes()
<GLib.Bytes object at 0x000000000396f5e0 (GBytes at 0x0000000004a45960)>

read_pixels()

Ritorna il raw pixel data.
Questi dati non devono essere modificati.
Questo metodo permette di saltare la copia implicita che deve essere fatta se il metodo
GdkPixbuf.Pixbuf.get_pixels() viene chiamato su un pixbuf read-only.

>>> pixbuf.read_pixels()
32

remove_option(key)

Rimuove l’opzione (key) dal dizionario delle opzioni/valori creata quando il pixbuf è stato
caricato. Ritorna True se l’eliminazione va a buon fine.

Parametri:
key: la stringa con il nome dell’opzione (key) da rimuovere;

rotate_simple(angle)

Ruota il pixbuf di un multiplo di 90 gradi e ritorna il risultato in un nuovo pixbuf.
Se l’angolo è 0, viene ritornata una copia del pixbuf senza rotazione.
Parametri:
angle: il GdkPixbuf.PixbufRotation, cioè quanto ruotare il pixbuf;

saturate_and_pixelate(dest, saturation, pixelate)

Modifica la saturazione e opzionalmente esegue la pixelatura del pixbuf, mettendo il risultato
dell’operazione nel pixbuf di destinazione.
Se la saturation=1.0 la saturazione non viene modificata.
Con valori minori di 1.0, la saturazione viene ridotta (l’immagine si trasforma in scala di
grigio); se saturation è maggiore di 1.0, la saturazione viene incrementata (l’immagine assume
colori più vividi). Se pixelate=True, allora i pixels vengono sbiaditi in un pattern
“checkerboard” per creare un’immagine pixelata.
Il pixbuf sorgente e di destinazione devono avere lo stesso formato, dimensione e rowstride.
Parametri:
dest: il GdkPixbuf.Pixbuf su cui piazzare il pixbuf modificato;
saturation: il fattore di saturazione (float);
pixelate: il boolean per pixelare o meno il pixbuf risultante;

save_to_bufferv(type, option_keys, option_values)

Salva il pixbuf in un nuovo buffer nel tipo di formato “jpeg”, “tiff”, “png”, “ico” o “bmp”.
Parametri:
type: stringa con il nome del formato file;
option_keys: una di chiavi corrispondenti alla opzioni da settare;
option_values: una lista di valori corrispondenti alle opzioni;

save_to_callbackv(save_func, user_data, type, option_keys, option_values)

Salva il pixbuf in una callback nel tipo di formato “jpeg”, “png”, “tiff”, “ico” o “bmp”.
Se si verifica un errore, viene ritornato False.
Parametri:
save_func: un oggetto GdkPixbuf.PixbufSaveFunc, ovvero una
funzione chiamata per salvare ogni blocco di dati generata dalla routine di salvataggio;
user_data: i dati da passare alla funzione;
type: stringa con il nome del formato file;
option_keys: una di chiavi corrispondenti alla opzioni da settare;
option_values: una lista di valori corrispondenti alle opzioni;

save_to_streamv(stream, type, option_keys, option_values, cancellable)

Salva il pixbuf in uno stream di output. I formati di file supportati sono “jpeg”, “tiff”, “png”,
“ico” or “bmp”. Se il pixbuf viene salvato correttamente, il metodo ritorna True,
altrimenti False.
Parametri:
stream: un Gio.OutputStream su cui salvare il pixbuf;
type: stringa con il nome del formato file;
option_keys: una di chiavi corrispondenti alla opzioni da settare;
option_values: una lista di valori corrispondenti alle opzioni;
cancellable: un Gio.Cancellable opzionale o None;

save_to_streamv_async(stream, type, option_keys, option_values, cancellable, callback, *user_data)

Salva il pixbuf in uno stream di output in modo asincrono.
Per maggiori dettagli, vedere GdkPixbuf.Pixbuf.save_to_streamv(), che è la versione sincrona del
metodo in oggetto. Quando l’operazione è terminata la callback sarà chiamata nel thread
principale e quindi possiamo chiamare GdkPixbuf.Pixbuf.save_to_stream_finish() per ottenere il
risultato dell’operazione.
Parametri:
stream: un Gio.OutputStream su cui salvare il pixbuf;
type: stringa con il nome del formato file;
option_keys: una di chiavi corrispondenti alla opzioni da settare;
option_values: una lista di valori corrispondenti alle opzioni;
cancellable: un Gio.Cancellable opzionale o None;
callback: un Gio.AsyncReadyCallback da invocare quandi il pixbuf
viene salvato;
user_data: i dati da passare alla callback;

savev(filename, type, option_keys, option_values)

Salva il pixbuf in un file di tipo “jpeg”, “png”, “tiff”, “ico” or “bmp”.
Se il pixbuf viene salvato correttamente, il metodo ritorna True, altrimenti
False.
Parametri:
filename:la stringa con il nome del file da salvare;
type: stringa con il nome del formato file;
option_keys: una di chiavi corrispondenti alla opzioni da settare;
option_values: una lista di valori corrispondenti alle opzioni;

scale(dest, dest_x, dest_y, dest_width, dest_height, offset_x, offset_y, scale_x, scale_y, interp_type)

Trasforma l’immagine sorgente scalandola su “scale_x” e “scale_y” e imposta l’offset definito da
“offset_x” e “offset_y”, quindi rappresenta il rettangolo (dest_x, dest_y, dest_width,
dest_height) dell’immagine risultante, sull’immagine di destinazione, rimpiazzando i contenuti
precedenti. Se non ci sono esigenze particolari si consiglia l’utilizzo del metodo
GdkPixbuf.Pixbuf.scale_simple().
Se il rettangolo del sorgente si sovrappone al rettangolo di destinazione sullo stesso pixbuf,
sarà sovrascritto durante la scalatura generando dei “rendering artifacts”.
Parametri:
dest: il GdkPixbuf.Pixbuf nel quale fare il render del risultato;
dest_x: la coord. X (sx) della regione su cui fare il render;
dest_y: la coord. Y (top) della regione su cui fare il render;
dest_width: la larghezza della regione su cui fare il render;
dest_height: l’altezza della regione su cui fare il render;
offset_x: l’offset (float) in direzione X;
offset_y: l’offset (float) in direzione Y;
scale_x: il fattore di scala (float) in direzione X;
scale_y: il fattore di scala (float) in direzione Y;
interp_type: l’interpolazione GdkPixbuf.InterpType per la trasf.;

scale_simple(dest_width, dest_height, interp_type)

Crea un nuovo GdkPixbuf.Pixbuf contenente una copia del pixbuf scalato a dest_width x dest_height.
Non influenza il pixbuf di origine. Per avere la massima velocità nell’operazione, il valore del
tipo di interpolazione deve essere settato a GdkPixbuf.InterpType.NEAREST.
(ma nelle operazioni if you want maximum speed
(but nelle operazioni di ridimensionamento è molto poco efficiente).
Il tipo di interpolazione di default dovrebbe essere GdkPixbuf.InterpType.BILINEAR, che offre
un rapporto qualità/velocità ragionevole.
Possiamo scalare una porzione di pixbuf, creando un sub-pixbuf (GdkPixbuf.Pixbuf.new_subpixbuf()).
Se “dest_width” e “dest_height” sono uguali alla larghezza e altezza del pixbuf di origine,
viene ritornata una copia del pixbuf di origine stesso, evitando la scalatura.
Per scalature e alpha-blending più complicati, consultare rispettivamente i metodi
GdkPixbuf.Pixbuf.scale() e GdkPixbuf.Pixbuf.composite().
Parametri:
dest_width: la larghezza dell’immagine di destinazione;
dest_height: l’altezza dell’immagine di destinazione;
interp_type: il tipo di interpolazione (GdkPixbuf.InterpType);

set_option(key, value)

Associa un’opzione in forma chiave/valore al GdkPixbuf.Pixbuf.
Se la chiave esiste già nel dizionario delle opzioni, il nuovo valore viene ignorato ed il metodo
ritorna False.
Parametri:
key: l’opzione (chiave del dizionario) da associare al pixbuf;
value: il valore dell’opzione;

Di seguito un codice di esempio:

import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk
from gi.repository import GdkPixbuf


class GWindow(Gtk.Window):
    def __init__(self):
        super().__init__(title="Pixbuf example")
        self.set_default_size(300, 150)
        box = Gtk.Box(spacing=6)
        box.set_homogeneous(True)
        pixbuf = GdkPixbuf.Pixbuf.new_from_file("image.png")
        image = Gtk.Image.new_from_pixbuf(pixbuf)
        pixbuf2 = pixbuf.rotate_simple(90)
        pixbuf2.saturate_and_pixelate(pixbuf2, 3.0, True)
        image2 = Gtk.Image.new_from_pixbuf(pixbuf2)
        s_height = pixbuf.get_height() * 2
        s_width = pixbuf.get_width() * 2
        pixbuf3 = pixbuf.scale_simple(dest_width=s_width, dest_height=s_height,
                                      interp_type=GdkPixbuf.InterpType.BILINEAR)
        image3 = Gtk.Image.new_from_pixbuf(pixbuf3)
        box.pack_start(image, True, True, 0)
        box.pack_start(image2, True, True, 0)
        box.pack_start(image3, True, True, 0)
        self.add(box)


if __name__ == "__main__":
    win = GWindow()
    win.connect("destroy", Gtk.main_quit)
    win.show_all()
    Gtk.main()

link di riferimento:

torna all’indice degli appunti
Gtk3 Pixbuf

Categorie:Gtk3, PyGObject, python Tag: , ,
I commenti sono chiusi.