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

Da Gambas-it.org - Wikipedia.
Riga 66: Riga 66:
  
  
 +
====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).
 
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).
 
<BR>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.
Riga 97: Riga 98:
  
  
 +
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
 +
    .Picture = im.Picture
 +
  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.
 
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.
  
Riga 132: Riga 185:
  
  
 +
====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''.
 
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''.
  

Versione delle 10:10, 31 dic 2016

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 pc As Picture


' Istanziamo l'oggetto "Image", attribuendogli la dimensione in pixel ed un colore":
  i = New Image(100, 100, Color.Red)

   
' Trasformiamo l'oggetto "Image" in una "Picture",
' al fine di poterla mostrare con la "PictureBox":
  pc = i.Picture
 

' 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
    .Picture = pc
  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.

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.
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. Infine, la scrittura dei dati avverrà mediante la risorsa dei Memory Stream.

In questo modo potremo disegnare effettivamente l'immagine, manipolando pixel per pixel all'interno dell'area di memoria della variabile predetta.


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).
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.Picture = im.Picture
     
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
    .Picture = im.Picture
  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)
  
  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)
  st.Close
  
  With PictureBox1
    .X = 10
    .Y = 10
    .W = im.W
    .H = im.H
    .Picture = im.Picture
  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)
  
  st = Memory im.Data For Write
  ll.Write(st, 0, ll.Count)
  st.Close
  
  With PictureBox1
    .X = 10
    .Y = 10
    .W = im.W
    .H = im.H
    .Picture = im.Picture
  End With
    
End
Estratto da "https://www.gambas-it.org/wiki/index.php?title=Creare_un%27immagine_senza_avere_un_file_immagine&oldid=21600"