Differenze tra le versioni di "Creare un'immagine senza avere un file immagine"

Da Gambas-it.org - Wikipedia.
 
(18 versioni intermedie di uno stesso utente non sono mostrate)
Riga 4: Riga 4:
 
==Immagine monocolore==
 
==Immagine monocolore==
 
Per generare da codice una immagine monocolore, potremo utilizzare sia la Classe ''Image'' che la Classe ''Picture''.
 
Per generare da codice una immagine monocolore, potremo utilizzare sia la Classe ''Image'' che la Classe ''Picture''.
−
 
  
 
===Uso della Classe ''Image''===
 
===Uso della Classe ''Image''===
Riga 10: Riga 9:
 
   
 
   
 
   Dim i As Image
 
   Dim i As Image
−
   Dim pc As Picture
+
   Dim im As Image
−
 
 
   
 
   
 
  <FONT color=gray>' ''Istanziamo l'oggetto "Image", attribuendogli la dimensione in pixel ed un colore":''</font>
 
  <FONT color=gray>' ''Istanziamo l'oggetto "Image", attribuendogli la dimensione in pixel ed un colore":''</font>
−
  i = <FONT Color=#B22222>New Image(100, 100, Color.Red)</font>
+
  i = <FONT Color=#B22222>New Image(100, 100, Color.Red, Image.Standard)</font>
−
 
 
      
 
      
−
<FONT color=gray>' ''Trasformiamo l'oggetto "Image" in una "Picture",''
+
  <FONT color=gray>' ''Dimensioniamo la "PictureBox" come la "Image", che avrà ovviamente anche le medesime dimensioni della nuova "Picture"; e carichiamo la  "Picture" nella "PictureBox":''</font>
−
' ''al fine di poterla mostrare con la "PictureBox":''</font>
+
  With PictureBox1
−
  pc = i.Picture
+
    .W = i.W
−
 
+
    .H = i.H
−
+
    .Image = im
−
  <FONT color=gray>' ''Dimensioniamo la "PictureBox" come la "Image", che avrà ovviamente''
+
  End With
−
' ''anche le medesime dimensioni della nuova "Picture"; e carichiamo la  "Picture" nella "PictureBox":''</font>
 
−
  With PictureBox1
 
−
    .W = i.W
 
−
    .H = i.H
 
−
    .Picture = pc
 
−
  End With
 
 
   
 
   
 
  '''End'''
 
  '''End'''
−
 
  
 
===Uso della Classe ''Picture''===
 
===Uso della Classe ''Picture''===
Riga 37: Riga 27:
 
   
 
   
 
   Dim pc As Picture
 
   Dim pc As Picture
−
 
 
   
 
   
 
  <FONT color=gray>' ''Istanziamo l'oggetto "Picture", attribuendogli la dimensione in pixel ed un colore":''</font>
 
  <FONT color=gray>' ''Istanziamo l'oggetto "Picture", attribuendogli la dimensione in pixel ed un colore":''</font>
−
  With pc = <FONT Color=#B22222>New Picture(100, 100)
+
  With pc = <FONT Color=#B22222>New Picture(100, 100)
−
    .Fill(Color.Red)</font>
+
    .Fill(Color.Red)</font>
−
  End With
+
  End With
 
    
 
    
−
+
  <FONT color=gray>' ''Dimensioniamo la "PictureBox" come la "Picture"; e carichiamo la  "Picture" nella "PictureBox":''</font>
−
<FONT color=gray>' ''Dimensioniamo la "PictureBox" come la "Picture"; e carichiamo la  "Picture" nella "PictureBox":''</font>
+
  With PictureBox1
−
  With PictureBox1
+
    .W = pc.W
−
    .W = pc.W
+
    .H = pc.H
−
    .H = pc.H
+
    .Picture = pc
−
    .Picture = pc
+
  End With
−
  End With
 
 
   
 
   
 
  '''End'''
 
  '''End'''
  
  
 +
==Immagine multicolore==
 +
Per generare da codice una immagine formata da due o più colori, dovremo utilizzare le risorse della Classe ''Image'' e dei ''Memory Stream''. <SUP>&#91;[[#Note|Nota 1]]&#93;</sup>
  
−
==Immagine multicolore==
+
La procedura di realizzazione dell'immagine, consisterà nel creare innanzitutto una variabile di tipo "''Image''", impostando soltanto le dimensioni in pixel. Successivamente, l'impostazione dei colori avverrà scrivendo i valori del colore di ciascun pixel all'interno dell'area di memoria, deputata a memorizzare i valori dei pixel dell'immagine, il cui indirizzo di memoria è restituito dalla Proprietà ".Data" della variabile "Image" creata.
−
Per generare da codice una immagine formata da due o più colori, dovremo utilizzare le risorse della Classe ''Image''.
+
<BR>Ogni pixel avrà una con risoluzione a 32-bit: il primo byte è relativo al codice ''Alfa'', i restanti tre - RGB - al colore vero e proprio. <SUP>&#91;[[#Note|Nota 2]]&#93;</sup>
 +
<BR>Gestendo tale indirizzo di memoria, sarà possibile sia scrivervi che leggervi dati.
 +
<BR>L'accesso alla predetta area di memoria dell'oggetto ''Image'', appositamente destinata a conservare i valori dei colori di ciascun pixel componente l'immagine, potrà avvenire anche ottenendo preliminarmente il ''Puntatore'' alla variabile di tipo ''Image'' mediante il Metodo "Object.Address()", e dereferenziando successivamente il ''Puntatore di Puntatore'' presente al 16° byte dell'area di memoria della variabile di tipo ''Image'', alla quale si è avuto accesso in quest'ultima modalità.
 +
 
 +
La scrittura dei dati avverrà in ogni caso mediante la risorsa dei ''Memory Stream''.
 +
 
 +
In entrambe le modalità sarà possibile ''disegnare'' effettivamente l'immagine, manipolando ''pixel per pixel'' (osia ogni singolo valore di ciascun pixel) all'interno della predetta specifica area di memoria della variabile di tipo ''Image''. <SUP>&#91;[[#Note|Nota 3]]&#93;</sup>
 +
 
 +
Mostriamo di seguito alcuni codici esemplificativi, nei quali si avrà accesso all'area di memoria dell'oggetto ''Image'', destinata a contenere i dati dei pixel dell'immagine, attraverso l'indirizzo ritornato dalla Proprietà ".Data" della variabile di tipo ''Image''.
  
−
La procedura di realizzazione dell'immagine, consisterà nel creare innanzitutto una variabile di tipo "Image", impostando soltanto le dimensioni in pixel. Successivamente, l'impostazione dei colori avverrà scrivendo i valori (con risoluzione 32bit: il primo byte è relativo al codice ''Alfa'', i restanti tre al colore vero e proprio) del colore di ciascun pixel all'interno dell'area di memoria della variabile "Image" creata.
+
====Usando un vettore di tipo "Integer[]" per memorizzare i valori dei pixel====
−
<BR>Come sappiamo, per poter gestire un'area di memoria, ed in questo caso per potervi scrivere all'interno, bisognerà ottenere l'indirizzo di tale area mediante un ''Puntatore''. L'indirizzo dell'area di memoria si otterrà agevolmente attraverso la proprietà ''.Data'' della Classe ''Image'', oppure dapprima ottenendo il ''Puntatore'' alla variabile di tipo ''Image'' e dopo dereferenziando il ''Puntatore di Puntatore'' presente al 16° byte dell'area di memoria della variabile di tipo ''Image''.
+
Mostriamo un esempio, nel quale si genererà una varibile di tipo ''Image'' di dimensioni 8x8 pixel: i primi 16 byte imposteranno pixel di colore rosso; altri 16 byte imposteranno pixel di colore verde; altri 16 byte imposteranno pixel di colore giallo; ed i restanti 16 byte imposteranno pixel di colore blu. Tali valori dei pixel saranno contenuti un una variabile vettorial di tipo ''Intero'', in quanto valori a 32bit (ossia 4 byte per piciascun pixel).  
−
Infine, la scrittura dei dati avverrà mediante la risorsa dei ''Memory Stream''.
 
  
 +
L'esempio scrive con il Metodo ''Write'' della variabile vettoriale "ii" il contenuto dell'area di memoria, puntata dalla Proprietà ".Data" della predetta variabile vettoriale, nell'area di memoria puntata dalla Proprietà ".Data" della variabile di tipo "Image".
  
−
Mostriamo un esempio, nel quale si genererà una varibile di tipo ''Image'' di dimensioni 8x8 pixel: i primi 16 byte imposteranno pixel di colore rosso; altri 16 byte imposteranno pixel di colore verde; altri 16 byte imposteranno pixel di colore giallo; ed i restanti 16 byte imposteranno pixel di colore blu. Tali valori dei pixel saranno contenuti un una variabile vettorial di tipo ''Intero'', in quanto valori a 32bit (ossia 4 byte per piciascun pixel).
+
E', inoltre, previsto il caricamento dell'immagine, così ottenuta, in una ''PictureBox'', nonché la realizzazione di un file immagine di tipo png.
−
<BR>E', inoltre, previsto il caricamento dell'immagine, così ottenuta, in una ''PictureBox'', nonché la realizzazione di un file immagine di tipo png.
 
 
  '''Public''' Sub Form_Open()
 
  '''Public''' Sub Form_Open()
 
   
 
   
 
   Dim im As Image
 
   Dim im As Image
−
   Dim ii As Integer[] = [&FFFF0000, &FFFF0000, &FFFF0000, &FFFF0000, &FFFF0000, &FFFF0000, &FFFF0000, &FFFF0000,
+
   Dim ii As Integer[]
−
                        &FFFF0000, &FFFF0000, &FFFF0000, &FFFF0000, &FFFF0000, &FFFF0000, &FFFF0000, &FFFF0000,
 
−
                        &FF00FF00, &FF00FF00, &FF00FF00, &FF00FF00, &FF00FF00, &FF00FF00, &FF00FF00, &FF00FF00,
 
−
                        &FF00FF00, &FF00FF00, &FF00FF00, &FF00FF00, &FF00FF00, &FF00FF00, &FF00FF00, &FF00FF00,
 
−
                        &FFFFFF00, &FFFFFF00, &FFFFFF00, &FFFFFF00, &FFFFFF00, &FFFFFF00, &FFFFFF00, &FFFFFF00,
 
−
                        &FFFFFF00, &FFFFFF00, &FFFFFF00, &FFFFFF00, &FFFFFF00, &FFFFFF00, &FFFFFF00, &FFFFFF00,
 
−
                        &FF0000FF, &FF0000FF, &FF0000FF, &FF0000FF, &FF0000FF, &FF0000FF, &FF0000FF, &FF0000FF,
 
−
                        &FF0000FF, &FF0000FF, &FF0000FF, &FF0000FF, &FF0000FF, &FF0000FF, &FF0000FF, &FF0000FF]
 
 
   Dim st As Stream
 
   Dim st As Stream
−
    
+
   
 +
   ii = [&FFFF0000, &FFFF0000, &FFFF0000, &FFFF0000, &FFFF0000, &FFFF0000, &FFFF0000, &FFFF0000,
 +
        &FFFF0000, &FFFF0000, &FFFF0000, &FFFF0000, &FFFF0000, &FFFF0000, &FFFF0000, &FFFF0000,
 +
        &FF00FF00, &FF00FF00, &FF00FF00, &FF00FF00, &FF00FF00, &FF00FF00, &FF00FF00, &FF00FF00,
 +
        &FF00FF00, &FF00FF00, &FF00FF00, &FF00FF00, &FF00FF00, &FF00FF00, &FF00FF00, &FF00FF00,
 +
        &FFFFFF00, &FFFFFF00, &FFFFFF00, &FFFFFF00, &FFFFFF00, &FFFFFF00, &FFFFFF00, &FFFFFF00,
 +
        &FFFFFF00, &FFFFFF00, &FFFFFF00, &FFFFFF00, &FFFFFF00, &FFFFFF00, &FFFFFF00, &FFFFFF00,
 +
        &FF0000FF, &FF0000FF, &FF0000FF, &FF0000FF, &FF0000FF, &FF0000FF, &FF0000FF, &FF0000FF,
 +
        &FF0000FF, &FF0000FF, &FF0000FF, &FF0000FF, &FF0000FF, &FF0000FF, &FF0000FF, &FF0000FF]
 +
 
 
  <FONT Color=gray>' ''Generiamo una variabile di tipo "Image" attribuendo solo le dimensioni in pixel:''</font>
 
  <FONT Color=gray>' ''Generiamo una variabile di tipo "Image" attribuendo solo le dimensioni in pixel:''</font>
−
  im = New Image(8, 8)
+
  im = New Image(8, 8)
 
    
 
    
−
  st = Memory im.Data For Write
+
  st = Memory im.Data For Write
 
   
 
   
 
  <FONT Color=gray>' ''Scriviamo i dati dei 64 pixel nell'area di memoria della variabile di tipo "Image":''</font>
 
  <FONT Color=gray>' ''Scriviamo i dati dei 64 pixel nell'area di memoria della variabile di tipo "Image":''</font>
−
  ii.Write(st, 0, ii.Count)
+
  ii.Write(st, 0, ii.Count)
−
  st.Close
+
  st.Close
 
      
 
      
−
  PictureBox1.Picture = im.Picture
+
  PictureBox1.Image = im
 +
     
 +
'''End'''
 +
 
 +
 
 +
Mostriamo un altro esempio, scrivendo con ''Write'' il contenuto dell'area di memoria, puntata dalla Proprietà ".Data" della variabile vettoriale "ii", nell'area di memoria, puntata dalla Proprietà ".Data" della variabile di tipo "Image".
 +
'''Public''' Sub Form_Open()
 +
 
 +
  Dim ii As Integer[] = [&ffFF0000&, &ff00FF00&, &FF0000FF&, &ffFFFF00&]
 +
  Dim im As Image
 +
  Dim st As Stream
 +
  Dim i As Integer
 
      
 
      
−
   im.Save("/tmp/immago.png")
+
  im = New Image(2, 2, Color.Transparent, Image.Standard)
 +
       
 +
  st = Memory <FONT Color=#B22222>im.Data</font> For Write
 +
 +
<FONT Color=gray>' ''Il valore del 3° membro della seguente istruzione rappresenta il numero dei pixel, che costituiscono l'immagine (in questo caso 4 pixel), x la quantità di byte occupati dal formato dei pixel medesimi (in questo caso 4 byte = "Integer"):''</font>
 +
  Write #st, <FONT Color=#B22222>ii.Data</font>, ii.Count * SizeOf(gb.Integer) <FONT Color=gray>'</font> <SUP>&#091;[[#Note|Nota 4]]&#093;</sup>
 +
  st.Close
 +
 +
<FONT Color=gray>' ''Da considerare che l'immagine, mostrata nella "PictureBox" è piccolissima !''</font>
 +
  PictureBox1.Image = im
 +
 +
'''End'''
 +
 
 +
 
 +
Mostriamo un altro esempio:
 +
'''Public''' Sub Form_Open()
 +
 +
  Dim im As Image
 +
  Dim c, i As Integer
 +
  Dim b, j As Byte
 +
  Dim st As Stream
 +
 
 +
<FONT Color=gray>' ''Imposta la dimensione della immagine, definendo un quadrato in pixel i*i :''</font>
 +
  i = 256
 +
 
 +
<FONT Color=gray>' ''Stabilisce quante volte ciascuna riga di un colore sarà presente nell'immagine:''</font>
 +
  j = 8
 +
   
 +
<FONT Color=gray>' ''Imposta la dimensione dell'oggetto "Image" coerentemente con quella dell'immagine:''</font>
 +
  im = New Image(i, i)
 +
    
 +
<FONT Color=gray>' ''Mediante i "Memory Stream" apre in scrittura l'area di memoria, attraverso il suo indirizzo ritornato dalla Proprietà ".Data" dell'oggetto "Image", ove vengono memorizzati i dati dei pixel dell'oggetto "Image":''</font>
 +
  st = Memory im.Data For Write
 +
 
 +
<FONT Color=gray>' ''Scrive i dati dei colori di ciascun pixel (risoluzione a 32-bit) nell'apposita area di memoria:''</font>
 +
  For c = 1 To (i ^ 2) / (j * 4)
 +
    For b = 1 To j
 +
      Write #st, &FFFF0000 As Integer
 +
    Next
 +
    For b = 1 To j
 +
      Write #st, &FF00FF00 As Integer
 +
    Next
 +
    For b = 1 To j
 +
      Write #st, &FFFFFF00 As Integer
 +
    Next
 +
    For b = 1 To j
 +
      Write #st, &FF0000FF As Integer
 +
    Next
 +
  Next
 +
 
 +
  st.Close
 +
 
 +
<FONT Color=gray>' ''Imposta la "PictureBox" e vi carica l'immagine, affinché questa sia mostrata:''</font>
 +
  With PictureBox1
 +
    .X = 10
 +
    .Y = 10
 +
    .W = im.W
 +
    .H = im.H
 +
    .Image = im
 +
  End With
 +
 
 +
'''End'''
 +
 
 +
 
 +
====Usando un vettore di tipo "Byte[]" per memorizzare i valori dei pixel====
 +
Volendo usare un vettore di tipo "Byte[]", anziché di tipo "Integer[]" (come era nel precedente esempio), bisognerà invertire i valori. In questo caso il valore del canale ''Alfa'' è rappresentato dal 4° byte di ciascun gruppo di byte costituenti i valori che definiscono il colore di un pixel.
 +
 
 +
Mostriamo un esempio:
 +
'''Public''' Sub Form_Open()
 +
 
 +
  Dim im As Image
 +
  Dim bb As Byte[]
 +
  Dim st As Stream
 +
 
 +
  im = New Image(8, 8, Color.Transparent, Image.Standard)
 +
 
 +
  bb = [&00, &00, &FF, &FF, &00, &00, &FF, &FF, &00, &00, &FF, &FF, &00, &00, &FF, &FF,
 +
        &00, &00, &FF, &FF, &00, &00, &FF, &FF, &00, &00, &FF, &FF, &00, &00, &FF, &FF,
 +
        &00, &00, &FF, &FF, &00, &00, &FF, &FF, &00, &00, &FF, &FF, &00, &00, &FF, &FF,
 +
        &00, &00, &FF, &FF, &00, &00, &FF, &FF, &00, &00, &FF, &FF, &00, &00, &FF, &FF,
 +
        &00, &FF, &FF, &FF, &00, &FF, &FF, &FF, &00, &FF, &FF, &FF, &00, &FF, &FF, &FF,
 +
        &00, &FF, &FF, &FF, &00, &FF, &FF, &FF, &00, &FF, &FF, &FF, &00, &FF, &FF, &FF,
 +
        &00, &FF, &FF, &FF, &00, &FF, &FF, &FF, &00, &FF, &FF, &FF, &00, &FF, &FF, &FF,
 +
        &00, &FF, &FF, &FF, &00, &FF, &FF, &FF, &00, &FF, &FF, &FF, &00, &FF, &FF, &FF,
 +
        &00, &FF, &00, &FF, &00, &FF, &00, &FF, &00, &FF, &00, &FF, &00, &FF, &00, &FF,
 +
        &00, &FF, &00, &FF, &00, &FF, &00, &FF, &00, &FF, &00, &FF, &00, &FF, &00, &FF,
 +
        &00, &FF, &00, &FF, &00, &FF, &00, &FF, &00, &FF, &00, &FF, &00, &FF, &00, &FF,
 +
        &00, &FF, &00, &FF, &00, &FF, &00, &FF, &00, &FF, &00, &FF, &00, &FF, &00, &FF,
 +
        &FF, &00, &00, &FF, &FF, &00, &00, &FF, &FF, &00, &00, &FF, &FF, &00, &00, &FF,
 +
        &FF, &00, &00, &FF, &FF, &00, &00, &FF, &FF, &00, &00, &FF, &FF, &00, &00, &FF,
 +
        &FF, &00, &00, &FF, &FF, &00, &00, &FF, &FF, &00, &00, &FF, &FF, &00, &00, &FF,
 +
        &FF, &00, &00, &FF, &FF, &00, &00, &FF, &FF, &00, &00, &FF, &FF, &00, &00, &FF]
 +
 
 +
  st = Memory im.Data For Write
 +
  bb.Write(st, 0, bb.Count)
 +
<FONT Color=gray>' ''Oppure:''
 +
' '''Write #st, bb.Data, bb.Count * SizeOf(gb.Byte)'''</font>
 +
  st.Close
 +
 
 +
  With PictureBox1
 +
    .X = 10
 +
    .Y = 10
 +
    .W = im.W
 +
    .H = im.H
 +
    .Image = im
 +
  End With
 +
   
 +
'''End'''
 +
 
 +
 
 +
====Usando un vettore di tipo "Long[]" per memorizzare i valori dei pixel====
 +
E' anche possibile utilizzare un vettore di tipo "Long[]", al fine di restringere lo spazio in larghezza nel progetto del codice da impegnare per i dati dei colori dei pixel. In questo caso, prendendo come riferimento i valori del già visto vettore di tipo "Integer[]", si uniranno due gruppi di valori di ciascun elemento di detto vettore in un unico elemento del vettore di tipo "Long[]", avendo anche cura - qualora si utilizzi la rappresentazione esadecimale - di porre il carattere "<FONT Color=#B22222>&</font>" anche alla fine di ciascun valore ora di tipo ''Long''.
 +
 
 +
Vediamo un esempio pratico:
 +
  '''Public''' Sub Form_Open()
 +
 
 +
  Dim im As Image
 +
  Dim ll As Long[]
 +
  Dim st As Stream
 +
     
 +
  ll = [&FFFF0000FFFF0000&, &FFFF0000FFFF0000&, &FFFF0000FFFF0000&, &FFFF0000FFFF0000&,
 +
        &FFFF0000FFFF0000&, &FFFF0000FFFF0000&, &FFFF0000FFFF0000&, &FFFF0000FFFF0000&,
 +
        &FFFF0000FFFF0000&, &FFFF0000FFFF0000&, &FFFF0000FFFF0000&, &FFFF0000FFFF0000&,
 +
        &FFFF0000FFFF0000&, &FFFF0000FFFF0000&, &FFFF0000FFFF0000&, &FFFF0000FFFF0000&,
 +
        &FF00FF00FF00FF00&, &FF00FF00FF00FF00&, &FF00FF00FF00FF00&, &FF00FF00FF00FF00&,
 +
        &FF00FF00FF00FF00&, &FF00FF00FF00FF00&, &FF00FF00FF00FF00&, &FF00FF00FF00FF00&,
 +
        &FF00FF00FF00FF00&, &FF00FF00FF00FF00&, &FF00FF00FF00FF00&, &FF00FF00FF00FF00&,
 +
        &FF00FF00FF00FF00&, &FF00FF00FF00FF00&, &FF00FF00FF00FF00&, &FF00FF00FF00FF00&,
 +
        &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&,
 +
        &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&,
 +
        &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&,
 +
        &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&,
 +
        &FF0000FFFF0000FF&, &FF0000FFFF0000FF&, &FF0000FFFF0000FF&, &FF0000FFFF0000FF&,
 +
        &FF0000FFFF0000FF&, &FF0000FFFF0000FF&, &FF0000FFFF0000FF&, &FF0000FFFF0000FF&,
 +
        &FF0000FFFF0000FF&, &FF0000FFFF0000FF&, &FF0000FFFF0000FF&, &FF0000FFFF0000FF&,
 +
        &FF0000FFFF0000FF&, &FF0000FFFF0000FF&, &FF0000FFFF0000FF&, &FF0000FFFF0000FF&,
 +
        &FFFF0000FFFF0000&, &FFFF0000FFFF0000&, &FFFF0000FFFF0000&, &FFFF0000FFFF0000&,
 +
        &FFFF0000FFFF0000&, &FFFF0000FFFF0000&, &FFFF0000FFFF0000&, &FFFF0000FFFF0000&,
 +
        &FFFF0000FFFF0000&, &FFFF0000FFFF0000&, &FFFF0000FFFF0000&, &FFFF0000FFFF0000&,
 +
        &FFFF0000FFFF0000&, &FFFF0000FFFF0000&, &FFFF0000FFFF0000&, &FFFF0000FFFF0000&,
 +
        &FF00FF00FF00FF00&, &FF00FF00FF00FF00&, &FF00FF00FF00FF00&, &FF00FF00FF00FF00&,
 +
        &FF00FF00FF00FF00&, &FF00FF00FF00FF00&, &FF00FF00FF00FF00&, &FF00FF00FF00FF00&,
 +
        &FF00FF00FF00FF00&, &FF00FF00FF00FF00&, &FF00FF00FF00FF00&, &FF00FF00FF00FF00&,
 +
        &FF00FF00FF00FF00&, &FF00FF00FF00FF00&, &FF00FF00FF00FF00&, &FF00FF00FF00FF00&,
 +
        &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&,
 +
        &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&,
 +
        &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&,
 +
        &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&,
 +
        &FF0000FFFF0000FF&, &FF0000FFFF0000FF&, &FF0000FFFF0000FF&, &FF0000FFFF0000FF&,
 +
        &FF0000FFFF0000FF&, &FF0000FFFF0000FF&, &FF0000FFFF0000FF&, &FF0000FFFF0000FF&,
 +
        &FF0000FFFF0000FF&, &FF0000FFFF0000FF&, &FF0000FFFF0000FF&, &FF0000FFFF0000FF&,
 +
        &FF0000FFFF0000FF&, &FF0000FFFF0000FF&, &FF0000FFFF0000FF&, &FF0000FFFF0000FF&]
 +
 
 +
  im = New Image(8, 32, Color.Transparent, Image.Standard)
 +
 
 +
  st = Memory im.Data For Write
 +
  ll.Write(st, 0, ll.Count)
 +
<FONT Color=gray>' ''Oppure:''
 +
' '''Write #st, ll.Data, ll.Count * SizeOf(gb.Long)'''</font>
 +
  st.Close
 
    
 
    
 +
  With PictureBox1
 +
    .X = 10
 +
    .Y = 10
 +
    .W = im.W
 +
    .H = im.H
 +
    .Image = im
 +
  End With
 +
   
 
  '''End'''
 
  '''End'''
 +
 +
 +
 +
=Note=
 +
['''1'''] Gambas consente non solo di caricare un'immagine da un file, per mostrarla in una "PictureBox", ma consente anche di crearla e di disegnarla pixel per pixel direttamente via codice.
 +
 +
La definizione del colore di ciascun pixel dell'immagine è attualmente possibile solo accedendo all'area riservata dell'Oggetto "Image", destinata a contenere i dati afferenti appunto ai pixel dell'immagine e il cui indirizzo di memoria è ritornato dalla Proprietà ".Data" dell'Oggetto "Image".
 +
Dunque questa Proprietà ci consente di manipolare via codice, come in una sorta di ingegneria genetica, ogni singolo valore costituente i pixel dell'immagine contenuta dall'Oggetto "Image".
 +
 +
Ogni pixel è per lo più costituito da 4 byte, avendo così una risoluzione a 32-bit (8 bit x 4 byte = 32 bit): il 1° byte rappresenta il canale "Alfa" dell'immagine, con il quale è possibile regolare la trasparenza del colore del pixel. I restanti tre byte rappresentano i valori RGB del colore.
 +
Pertanto, ad esempio i valori di un pixel di colore rosso saranno così impostati in rappresentazione esadecimale:
 +
&FF <FONT Color=Red>FF</font> <Font Color=Green>00</font> <Font Color=Blue>00</font>
 +
laddove il primo valore (&FF) rappresenta, come già detto, il canale Alfa, ed in questo esempio è impostato alla massima opacità (quindi trasparenza completamente nulla).
 +
 +
Per poter avere allocata l'area di memoria appositamente destinata a contenere i dati costituenti tutti i pixel dell'immagine, è necessario innanzitutto creare ovviamente un Oggetto di tipo "Image", impostandone anche le Proprietà utili per definire la dimensione in pixel dell'immagine.
 +
 +
Dopo ciò, si può passare a scrivere nell'area di memoria, destinata a contenere i dati dei pixel, i 4 valori per ciascun pixel dell'immagine.
 +
Va da sé che la dimensione finale dell'immagine sarà data dalla seguente moltiplicazione: pixel_larghezza x pixel_altezza x (32_bit / 8).
 +
Poiché, come sappiamo, per scrivere nell'area di memoria puntata da un Puntatore, in Gambas è possibile esclusivamente mediante l'uso dei "Memory Stream", dovremo usare tale risorsa di Gambas per impostare i valori dei colori di ciascun pixel dell'immagine.
 +
 +
['''2'''] Sulla gestione delle immagini in Gambas, vedere questa pagina della Wiki ufficiale: http://gambaswiki.org/wiki/doc/imageconv
 +
 +
[3]  Vedere anche questa pagina: [[Assegnare a un Oggetto ''Image'' i valori pixel contenuti in un'area di memoria puntata da un Puntatore]]
 +
 +
[4] Vedere anche questo paragrafo: [[Write#Scrivere_in_un_file_i_dati_contenuti_in_un.27area_di_memoria_puntata_da_un_Puntatore|Scrivere in un file i dati contenuti in un'area di memoria puntata da un Puntatore]]

Versione attuale delle 19:27, 9 set 2022

Il caso considerato in questa pagina è quello in cui viene realizzata direttamente un'immagine, da mostrare in una PictureBox, senza che sia prelevata da un file immagine preesistente.


Immagine monocolore

Per generare da codice una immagine monocolore, potremo utilizzare sia la Classe Image che la Classe Picture.

Uso della Classe Image

Public Sub Form_Open()

 Dim i As Image
 Dim im As Image

' Istanziamo l'oggetto "Image", attribuendogli la dimensione in pixel ed un colore":
 i = New Image(100, 100, Color.Red, Image.Standard)
   
' Dimensioniamo la "PictureBox" come la "Image", che avrà ovviamente anche le medesime dimensioni della nuova "Picture"; e carichiamo la  "Picture" nella "PictureBox":
 With PictureBox1
   .W = i.W
   .H = i.H
   .Image = im
 End With

End

Uso della Classe Picture

Public Sub Form_Open()

 Dim pc As Picture

' Istanziamo l'oggetto "Picture", attribuendogli la dimensione in pixel ed un colore":
 With pc = New Picture(100, 100)
   .Fill(Color.Red)
 End With
 
 ' Dimensioniamo la "PictureBox" come la "Picture"; e carichiamo la  "Picture" nella "PictureBox":
 With PictureBox1
   .W = pc.W
   .H = pc.H
   .Picture = pc
 End With

End


Immagine multicolore

Per generare da codice una immagine formata da due o più colori, dovremo utilizzare le risorse della Classe Image e dei Memory Stream. [Nota 1]

La procedura di realizzazione dell'immagine, consisterà nel creare innanzitutto una variabile di tipo "Image", impostando soltanto le dimensioni in pixel. Successivamente, l'impostazione dei colori avverrà scrivendo i valori del colore di ciascun pixel all'interno dell'area di memoria, deputata a memorizzare i valori dei pixel dell'immagine, il cui indirizzo di memoria è restituito dalla Proprietà ".Data" della variabile "Image" creata.
Ogni pixel avrà una con risoluzione a 32-bit: il primo byte è relativo al codice Alfa, i restanti tre - RGB - al colore vero e proprio. [Nota 2]
Gestendo tale indirizzo di memoria, sarà possibile sia scrivervi che leggervi dati.
L'accesso alla predetta area di memoria dell'oggetto Image, appositamente destinata a conservare i valori dei colori di ciascun pixel componente l'immagine, potrà avvenire anche ottenendo preliminarmente il Puntatore alla variabile di tipo Image mediante il Metodo "Object.Address()", e dereferenziando successivamente il Puntatore di Puntatore presente al 16° byte dell'area di memoria della variabile di tipo Image, alla quale si è avuto accesso in quest'ultima modalità.

La scrittura dei dati avverrà in ogni caso mediante la risorsa dei Memory Stream.

In entrambe le modalità sarà possibile disegnare effettivamente l'immagine, manipolando pixel per pixel (osia ogni singolo valore di ciascun pixel) all'interno della predetta specifica area di memoria della variabile di tipo Image. [Nota 3]

Mostriamo di seguito alcuni codici esemplificativi, nei quali si avrà accesso all'area di memoria dell'oggetto Image, destinata a contenere i dati dei pixel dell'immagine, attraverso l'indirizzo ritornato dalla Proprietà ".Data" della variabile di tipo Image.

Usando un vettore di tipo "Integer[]" per memorizzare i valori dei pixel

Mostriamo un esempio, nel quale si genererà una varibile di tipo Image di dimensioni 8x8 pixel: i primi 16 byte imposteranno pixel di colore rosso; altri 16 byte imposteranno pixel di colore verde; altri 16 byte imposteranno pixel di colore giallo; ed i restanti 16 byte imposteranno pixel di colore blu. Tali valori dei pixel saranno contenuti un una variabile vettorial di tipo Intero, in quanto valori a 32bit (ossia 4 byte per piciascun pixel).

L'esempio scrive con il Metodo Write della variabile vettoriale "ii" il contenuto dell'area di memoria, puntata dalla Proprietà ".Data" della predetta variabile vettoriale, nell'area di memoria puntata dalla Proprietà ".Data" della variabile di tipo "Image".

E', inoltre, previsto il caricamento dell'immagine, così ottenuta, in una PictureBox, nonché la realizzazione di un file immagine di tipo png. 

Public Sub Form_Open()

 Dim im As Image
 Dim ii As Integer[]
 Dim st As Stream
    
 ii = [&FFFF0000, &FFFF0000, &FFFF0000, &FFFF0000, &FFFF0000, &FFFF0000, &FFFF0000, &FFFF0000,
       &FFFF0000, &FFFF0000, &FFFF0000, &FFFF0000, &FFFF0000, &FFFF0000, &FFFF0000, &FFFF0000,
       &FF00FF00, &FF00FF00, &FF00FF00, &FF00FF00, &FF00FF00, &FF00FF00, &FF00FF00, &FF00FF00,
       &FF00FF00, &FF00FF00, &FF00FF00, &FF00FF00, &FF00FF00, &FF00FF00, &FF00FF00, &FF00FF00,
       &FFFFFF00, &FFFFFF00, &FFFFFF00, &FFFFFF00, &FFFFFF00, &FFFFFF00, &FFFFFF00, &FFFFFF00,
       &FFFFFF00, &FFFFFF00, &FFFFFF00, &FFFFFF00, &FFFFFF00, &FFFFFF00, &FFFFFF00, &FFFFFF00,
       &FF0000FF, &FF0000FF, &FF0000FF, &FF0000FF, &FF0000FF, &FF0000FF, &FF0000FF, &FF0000FF,
       &FF0000FF, &FF0000FF, &FF0000FF, &FF0000FF, &FF0000FF, &FF0000FF, &FF0000FF, &FF0000FF]
  
' Generiamo una variabile di tipo "Image" attribuendo solo le dimensioni in pixel:
 im = New Image(8, 8)
 
 st = Memory im.Data For Write

' Scriviamo i dati dei 64 pixel nell'area di memoria della variabile di tipo "Image":
 ii.Write(st, 0, ii.Count)
 st.Close
   
 PictureBox1.Image = im
     
End


Mostriamo un altro esempio, scrivendo con Write il contenuto dell'area di memoria, puntata dalla Proprietà ".Data" della variabile vettoriale "ii", nell'area di memoria, puntata dalla Proprietà ".Data" della variabile di tipo "Image". 

Public Sub Form_Open()
 
 Dim ii As Integer[] = [&ffFF0000&, &ff00FF00&, &FF0000FF&, &ffFFFF00&]
 Dim im As Image
 Dim st As Stream
 Dim i As Integer
   
 im = New Image(2, 2, Color.Transparent, Image.Standard)
        
 st = Memory im.Data For Write

' Il valore del 3° membro della seguente istruzione rappresenta il numero dei pixel, che costituiscono l'immagine (in questo caso 4 pixel), x la quantità di byte occupati dal formato dei pixel medesimi (in questo caso 4 byte = "Integer"):
 Write #st, ii.Data, ii.Count * SizeOf(gb.Integer) ' [Nota 4]
 st.Close

' Da considerare che l'immagine, mostrata nella "PictureBox" è piccolissima !
 PictureBox1.Image = im

End


Mostriamo un altro esempio: 

Public Sub Form_Open()

 Dim im As Image
 Dim c, i As Integer
 Dim b, j As Byte
 Dim st As Stream
 
' Imposta la dimensione della immagine, definendo un quadrato in pixel i*i :
 i = 256
  
' Stabilisce quante volte ciascuna riga di un colore sarà presente nell'immagine:
 j = 8
    
' Imposta la dimensione dell'oggetto "Image" coerentemente con quella dell'immagine:
 im = New Image(i, i)
  
' Mediante i "Memory Stream" apre in scrittura l'area di memoria, attraverso il suo indirizzo ritornato dalla Proprietà ".Data" dell'oggetto "Image", ove vengono memorizzati i dati dei pixel dell'oggetto "Image":
 st = Memory im.Data For Write
  
' Scrive i dati dei colori di ciascun pixel (risoluzione a 32-bit) nell'apposita area di memoria:
 For c = 1 To (i ^ 2) / (j * 4)
   For b = 1 To j
     Write #st, &FFFF0000 As Integer
   Next
   For b = 1 To j
     Write #st, &FF00FF00 As Integer
   Next
   For b = 1 To j
     Write #st, &FFFFFF00 As Integer
   Next
   For b = 1 To j
     Write #st, &FF0000FF As Integer
   Next
 Next
  
 st.Close
  
' Imposta la "PictureBox" e vi carica l'immagine, affinché questa sia mostrata:
 With PictureBox1
   .X = 10
   .Y = 10
   .W = im.W
   .H = im.H
   .Image = im
 End With
  
End


Usando un vettore di tipo "Byte[]" per memorizzare i valori dei pixel

Volendo usare un vettore di tipo "Byte[]", anziché di tipo "Integer[]" (come era nel precedente esempio), bisognerà invertire i valori. In questo caso il valore del canale Alfa è rappresentato dal 4° byte di ciascun gruppo di byte costituenti i valori che definiscono il colore di un pixel.

Mostriamo un esempio: 

Public Sub Form_Open()
 
 Dim im As Image
 Dim bb As Byte[]
 Dim st As Stream
  
 im = New Image(8, 8, Color.Transparent, Image.Standard)
  
 bb = [&00, &00, &FF, &FF, &00, &00, &FF, &FF, &00, &00, &FF, &FF, &00, &00, &FF, &FF,
       &00, &00, &FF, &FF, &00, &00, &FF, &FF, &00, &00, &FF, &FF, &00, &00, &FF, &FF,
       &00, &00, &FF, &FF, &00, &00, &FF, &FF, &00, &00, &FF, &FF, &00, &00, &FF, &FF,
       &00, &00, &FF, &FF, &00, &00, &FF, &FF, &00, &00, &FF, &FF, &00, &00, &FF, &FF,
       &00, &FF, &FF, &FF, &00, &FF, &FF, &FF, &00, &FF, &FF, &FF, &00, &FF, &FF, &FF,
       &00, &FF, &FF, &FF, &00, &FF, &FF, &FF, &00, &FF, &FF, &FF, &00, &FF, &FF, &FF,
       &00, &FF, &FF, &FF, &00, &FF, &FF, &FF, &00, &FF, &FF, &FF, &00, &FF, &FF, &FF,
       &00, &FF, &FF, &FF, &00, &FF, &FF, &FF, &00, &FF, &FF, &FF, &00, &FF, &FF, &FF,
       &00, &FF, &00, &FF, &00, &FF, &00, &FF, &00, &FF, &00, &FF, &00, &FF, &00, &FF,
       &00, &FF, &00, &FF, &00, &FF, &00, &FF, &00, &FF, &00, &FF, &00, &FF, &00, &FF,
       &00, &FF, &00, &FF, &00, &FF, &00, &FF, &00, &FF, &00, &FF, &00, &FF, &00, &FF,
       &00, &FF, &00, &FF, &00, &FF, &00, &FF, &00, &FF, &00, &FF, &00, &FF, &00, &FF,
       &FF, &00, &00, &FF, &FF, &00, &00, &FF, &FF, &00, &00, &FF, &FF, &00, &00, &FF,
       &FF, &00, &00, &FF, &FF, &00, &00, &FF, &FF, &00, &00, &FF, &FF, &00, &00, &FF,
       &FF, &00, &00, &FF, &FF, &00, &00, &FF, &FF, &00, &00, &FF, &FF, &00, &00, &FF,
       &FF, &00, &00, &FF, &FF, &00, &00, &FF, &FF, &00, &00, &FF, &FF, &00, &00, &FF]
  
 st = Memory im.Data For Write
 bb.Write(st, 0, bb.Count)
' Oppure:
' Write #st, bb.Data, bb.Count * SizeOf(gb.Byte)
 st.Close
  
 With PictureBox1
   .X = 10
   .Y = 10
   .W = im.W
   .H = im.H
   .Image = im
 End With
    
End


Usando un vettore di tipo "Long[]" per memorizzare i valori dei pixel

E' anche possibile utilizzare un vettore di tipo "Long[]", al fine di restringere lo spazio in larghezza nel progetto del codice da impegnare per i dati dei colori dei pixel. In questo caso, prendendo come riferimento i valori del già visto vettore di tipo "Integer[]", si uniranno due gruppi di valori di ciascun elemento di detto vettore in un unico elemento del vettore di tipo "Long[]", avendo anche cura - qualora si utilizzi la rappresentazione esadecimale - di porre il carattere "&" anche alla fine di ciascun valore ora di tipo Long.

Vediamo un esempio pratico: 

 Public Sub Form_Open()
 
 Dim im As Image
 Dim ll As Long[]
 Dim st As Stream
     
 ll = [&FFFF0000FFFF0000&, &FFFF0000FFFF0000&, &FFFF0000FFFF0000&, &FFFF0000FFFF0000&,
       &FFFF0000FFFF0000&, &FFFF0000FFFF0000&, &FFFF0000FFFF0000&, &FFFF0000FFFF0000&,
       &FFFF0000FFFF0000&, &FFFF0000FFFF0000&, &FFFF0000FFFF0000&, &FFFF0000FFFF0000&,
       &FFFF0000FFFF0000&, &FFFF0000FFFF0000&, &FFFF0000FFFF0000&, &FFFF0000FFFF0000&,
       &FF00FF00FF00FF00&, &FF00FF00FF00FF00&, &FF00FF00FF00FF00&, &FF00FF00FF00FF00&,
       &FF00FF00FF00FF00&, &FF00FF00FF00FF00&, &FF00FF00FF00FF00&, &FF00FF00FF00FF00&,
       &FF00FF00FF00FF00&, &FF00FF00FF00FF00&, &FF00FF00FF00FF00&, &FF00FF00FF00FF00&,
       &FF00FF00FF00FF00&, &FF00FF00FF00FF00&, &FF00FF00FF00FF00&, &FF00FF00FF00FF00&,
       &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&,
       &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&,
       &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&,
       &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&,
       &FF0000FFFF0000FF&, &FF0000FFFF0000FF&, &FF0000FFFF0000FF&, &FF0000FFFF0000FF&,
       &FF0000FFFF0000FF&, &FF0000FFFF0000FF&, &FF0000FFFF0000FF&, &FF0000FFFF0000FF&,
       &FF0000FFFF0000FF&, &FF0000FFFF0000FF&, &FF0000FFFF0000FF&, &FF0000FFFF0000FF&,
       &FF0000FFFF0000FF&, &FF0000FFFF0000FF&, &FF0000FFFF0000FF&, &FF0000FFFF0000FF&,
       &FFFF0000FFFF0000&, &FFFF0000FFFF0000&, &FFFF0000FFFF0000&, &FFFF0000FFFF0000&,
       &FFFF0000FFFF0000&, &FFFF0000FFFF0000&, &FFFF0000FFFF0000&, &FFFF0000FFFF0000&,
       &FFFF0000FFFF0000&, &FFFF0000FFFF0000&, &FFFF0000FFFF0000&, &FFFF0000FFFF0000&,
       &FFFF0000FFFF0000&, &FFFF0000FFFF0000&, &FFFF0000FFFF0000&, &FFFF0000FFFF0000&,
       &FF00FF00FF00FF00&, &FF00FF00FF00FF00&, &FF00FF00FF00FF00&, &FF00FF00FF00FF00&,
       &FF00FF00FF00FF00&, &FF00FF00FF00FF00&, &FF00FF00FF00FF00&, &FF00FF00FF00FF00&,
       &FF00FF00FF00FF00&, &FF00FF00FF00FF00&, &FF00FF00FF00FF00&, &FF00FF00FF00FF00&,
       &FF00FF00FF00FF00&, &FF00FF00FF00FF00&, &FF00FF00FF00FF00&, &FF00FF00FF00FF00&,
       &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&,
       &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&,
       &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&,
       &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&, &FFFFFF00FFFFFF00&,
       &FF0000FFFF0000FF&, &FF0000FFFF0000FF&, &FF0000FFFF0000FF&, &FF0000FFFF0000FF&,
       &FF0000FFFF0000FF&, &FF0000FFFF0000FF&, &FF0000FFFF0000FF&, &FF0000FFFF0000FF&,
       &FF0000FFFF0000FF&, &FF0000FFFF0000FF&, &FF0000FFFF0000FF&, &FF0000FFFF0000FF&,
       &FF0000FFFF0000FF&, &FF0000FFFF0000FF&, &FF0000FFFF0000FF&, &FF0000FFFF0000FF&]
  
 im = New Image(8, 32, Color.Transparent, Image.Standard)
  
 st = Memory im.Data For Write
 ll.Write(st, 0, ll.Count)
' Oppure:
' Write #st, ll.Data, ll.Count * SizeOf(gb.Long)
 st.Close
  
 With PictureBox1
   .X = 10
   .Y = 10
   .W = im.W
   .H = im.H
   .Image = im
 End With
    
End


Note

[1] Gambas consente non solo di caricare un'immagine da un file, per mostrarla in una "PictureBox", ma consente anche di crearla e di disegnarla pixel per pixel direttamente via codice.

La definizione del colore di ciascun pixel dell'immagine è attualmente possibile solo accedendo all'area riservata dell'Oggetto "Image", destinata a contenere i dati afferenti appunto ai pixel dell'immagine e il cui indirizzo di memoria è ritornato dalla Proprietà ".Data" dell'Oggetto "Image". Dunque questa Proprietà ci consente di manipolare via codice, come in una sorta di ingegneria genetica, ogni singolo valore costituente i pixel dell'immagine contenuta dall'Oggetto "Image".

Ogni pixel è per lo più costituito da 4 byte, avendo così una risoluzione a 32-bit (8 bit x 4 byte = 32 bit): il 1° byte rappresenta il canale "Alfa" dell'immagine, con il quale è possibile regolare la trasparenza del colore del pixel. I restanti tre byte rappresentano i valori RGB del colore. Pertanto, ad esempio i valori di un pixel di colore rosso saranno così impostati in rappresentazione esadecimale: 

&FF FF 00 00

laddove il primo valore (&FF) rappresenta, come già detto, il canale Alfa, ed in questo esempio è impostato alla massima opacità (quindi trasparenza completamente nulla).

Per poter avere allocata l'area di memoria appositamente destinata a contenere i dati costituenti tutti i pixel dell'immagine, è necessario innanzitutto creare ovviamente un Oggetto di tipo "Image", impostandone anche le Proprietà utili per definire la dimensione in pixel dell'immagine.

Dopo ciò, si può passare a scrivere nell'area di memoria, destinata a contenere i dati dei pixel, i 4 valori per ciascun pixel dell'immagine. Va da sé che la dimensione finale dell'immagine sarà data dalla seguente moltiplicazione: pixel_larghezza x pixel_altezza x (32_bit / 8). Poiché, come sappiamo, per scrivere nell'area di memoria puntata da un Puntatore, in Gambas è possibile esclusivamente mediante l'uso dei "Memory Stream", dovremo usare tale risorsa di Gambas per impostare i valori dei colori di ciascun pixel dell'immagine.

[2] Sulla gestione delle immagini in Gambas, vedere questa pagina della Wiki ufficiale: http://gambaswiki.org/wiki/doc/imageconv

[3] Vedere anche questa pagina: Assegnare a un Oggetto ''Image'' i valori pixel contenuti in un'area di memoria puntata da un Puntatore

[4] Vedere anche questo paragrafo: Scrivere in un file i dati contenuti in un'area di memoria puntata da un Puntatore

Estratto da "https://www.gambas-it.org/wiki/index.php?title=Creare_un%27immagine_senza_avere_un_file_immagine&oldid=31735"