Scaricare una immagine da un sito internet

Da Gambas-it.org - Wikipedia.

Vedremo di seguito alcune modalità per scaricare dal WEB i dati di file immagini, di cui si conoscono gli indirizzi web.


Usando le sole risorse e funzioni di Gambas

L'esempio prevede il posizionamento sul Form di una PictureBox e di un Button, nonché l'attivazione dei componenti: gb.net e gb.net.curl:

Public Sub Form_Open()
 
 Dim tp As New HttpClient
 Dim s As String
 Dim im As New Image
 
  s = tp.Download("indirizzo/web/del/file/immagine/da/scaricare")
  
  tp.Close
  
  PictureBox1.Image = im.FromString(s)
  
End

oppure:

Private ht As New HttpClient As "MyHTTP"  
  

Public Sub Button1_Click()

 With ht
' Invia_richiesta al server per scaricare il file immagine:   [nota 1]
   .URL = "indirizzo/web/del/file/immagine/da/scaricare"
   .Timeout = 15
' Scarica i dati del file immagine in un percorso prescelto, contenente anche il nome del file immagine ricreato:
   .Get(Null, "/percorso/del/file/immagine/scaricato_e_ricreato") 
 End With
     
End  
 

Public Sub MyHTTP_Finished()  
    
  ht.Close  
   
' Carichiamo nella "PictureBox" il file immagine ricreato:
  PictureBox1.Picture = Picture["/percorso/del/file/immagine/scaricato_e_ricreato"]

End


oppure anche utilizzando l'evento _Read():

Private ht As New HttpClient As "MyHTTP"  
Private stringa As String


Public Sub Button1_Click()
 
 With ht
' Invia_richiesta al server per scaricare il file immagine:   [nota 1]
   .URL = "indirizzo/web/del/file/immagine/da/scaricare"
   .Timeout = 15  
   .Get()
 End With
     
End  
  

Public Sub MyHTTP_Read()  
     
 Dim sBuf As String  
    
' Andiamo a leggere il flusso di dati del file immagine:
   If Lof(ht) Then   
     Read #ht, sBuf, Lof(ht)
     stringa = stringa & sBuf
   End If

End


Public Sub MyHTTP_Finished()  
    
  Label1.Text = ("Immagine scaricata !")  
       
  Wait   
        

  ht.Close  
             

' Ricreiamo il file: [nota 2]
  File.Save("/percorso/del/file/ricreato", stringa)


' Carichiamo nella "PictureBox" il file immagine ricreato:
  PictureBox1.Picture = Picture["/percorso/del/file/ricreato"]

End


Usando le funzioni esterne della libreria Libcurl

Libcurl è una libreria gratuita lato-client di trasferimento dati con la sintassi URL, capace di supportare diversi protocolli.

Per poter fruire in Gambas delle risorse della libreria Libcurl, è necessario avere installata nel sistema e richiamare la libreria dinamica condivisa: "libcurl.so"


Mostriamo un esempio pratico, nel quale immaginiamo di dover scaricare un file immagine di formato .png:

Library "libcurl"

Private Const CURLOPT_WRITEDATA As Integer = 10001
Private Const CURLOPT_URL As Integer = 10002
   
' CURL *curl_easy_init(void)
' Start a libcurl easy session.
Private Extern curl_easy_init() As Pointer

' CURLcode curl_easy_setopt(CURL *curl, CURLoption option, ...)
' Set options for a curl easy handle
Private Extern curl_easy_setopt(curl As Pointer, optionI As Integer, optionP As Pointer) As Integer
 
' CURLcode curl_easy_perform(CURL *curl)
' Perform a blocking file transfer.
Private Extern curl_easy_perform(curl As Pointer) As Pointer

' const char *curl_easy_strerror(CURLcode)
' Turn a CURLcode value into the equivalent human readable error string.
Private Extern curl_easy_strerror(CURLcode As Integer) As String

' void curl_easy_cleanup(CURL *curl)
' End a libcurl easy handle.
Private Extern curl_easy_cleanup(curl As Pointer)


Library "libc:6"

' FILE *fopen (const char *__restrict __filename, const char *__restrict __modes)
' Open a file and create a new stream for it.
Private Extern fopen(__filename As String, __modes As String) As Pointer

' int fclose (FILE *__stream)
' Close STREAM.
Private Extern fclose(__stream As Pointer) As Integer


Public Sub Main()

 Dim cu, url, fl As Pointer
 Dim file_finale As String
 Dim ris As Integer
 
' Imposta l'indirizzo web del file immagine .png da scaricare:
  url = Alloc("indirizzo/web/del/file.png")
  
' Imposta il percorso del nuovo file immagine generato con i dati del file immagine scaricato:
  file_finale = "/percorso/del/nuovo/file.png"
    
' Inizilizza la libreria Libcurl':
  cu = curl_easy_init()
  If cu = 0 Then Error.Raise("Impossibile inizializzare la libreria 'curl' !")
  
  curl_easy_setopt(cu, CURLOPT_URL, url)
   
' Apre in scrittura il percorso del nuovo file immagine .png da salvare:
  fl = fopen(file_finale, "wb")
   
' Scrive i dati scaricati del file nella variabile handle per la gestione del nuovo file immagine .png da salvare:
  curl_easy_setopt(cu, CURLOPT_WRITEDATA, fl)
  
' Scrive il nuovo file immagine .png :
  ris = curl_easy_perform(cu)
  If ris <> 0 Then Error.Raise("Errore nella scrittura del file: " & curl_easy_strerror(i))
   
   
' Va in chiusura e libera tutta la memoria precedentemente allocata:
  fclose(pagina)
  Free(url)
  curl_easy_cleanup(cu)
  
End


Usando le funzioni esterne della libreria libgtk-3

In questo caso l'immagine da scaricare deve avere il canale Alfa e dunque sia di formato a 32-bit - RGBA.
Per utilizzare alcune funzioni esterne di gdk_pixbuf, si dovrà richiamando nel progetto Gambas la libreria condivisa: "libgtk-3.so.0.2404.16 ".

Mostriamo di seguito il codice con un esistente indirizzo web di un'immagine PNG da scaricare (è necessario attivare anche i Componenti "gb.net" e "gb.net.curl").

Private myhttp As New HttpClient As "myhttp"  


Library "libgtk-3:0.2404.16"

' GdkPixbufLoader * gdk_pixbuf_loader_new(void)
' Creates a new pixbuf loader object.
Private Extern gdk_pixbuf_loader_new() As Pointer

' gboolean gdk_pixbuf_loader_write (GdkPixbufLoader *loader, const guchar *buf, gsize count, GError **error)'
' Cause a pixbuf loader to parse the next count bytes of an image.
Private Extern gdk_pixbuf_loader_write(lo As Pointer, buf As Pointer, i As Integer, po As Pointer)

' gboolean gdk_pixbuf_loader_close (GdkPixbufLoader *loader, GError **error)'
' Informs a pixbuf loader that no further writes.
Private Extern gdk_pixbuf_loader_close(lo As Pointer, po As Pointer)

' GdkPixbuf * gdk_pixbuf_loader_get_pixbuf (GdkPixbufLoader *loader)'
' Queries the GdkPixbuf that a pixbuf loader is currently creating.
Private Extern gdk_pixbuf_loader_get_pixbuf(lo As Pointer) As Pointer

' guchar * gdk_pixbuf_get_pixels (const GdkPixbuf *pixbuf)'
' Queries a pointer to the pixel data of a pixbuf.
Private Extern gdk_pixbuf_get_pixels(GdkPixbuf As Pointer) As Pointer

' int gdk_pixbuf_get_width (const GdkPixbuf *pixbuf)'
' Queries the width of a pixbuf.
Private Extern gdk_pixbuf_get_width(GdkPixbuf As Pointer) As Integer

' int gdk_pixbuf_get_height (const GdkPixbuf *pixbuf)'
' Queries the height of a pixbuf.
Private Extern gdk_pixbuf_get_height(GdkPixbuf As Pointer) As Integer

' int gdk_pixbuf_get_n_channels (const GdkPixbuf *pixbuf)'
' Queries the number of channels of a pixbuf.
Private Extern gdk_pixbuf_get_n_channels(GdkPixbuf As Pointer) As Integer

' gboolean gdk_pixbuf_get_has_alpha (const GdkPixbuf *pixbuf)'
' Queries whether a pixbuf has an alpha channel (opacity information).
Private Extern gdk_pixbuf_get_has_alpha(GdkPixbuf As Pointer) As Boolean


Public Sub Button1_Click()
 
' Invia la richiesta al server per scaricare un file immagine:
  myhttp.URL = "https://www.freepnglogos.com/uploads/eye-png/eye-psd-vector-vectorhqm-18.png"
  myhttp.Timeout = 15

' Lasciando il secondo parametro vuoto, i dati dell'immagine vengono salvati soltanto in memoria:
  myhttp.Get()
    
End

Public Sub MyHTTP_Finished()

 Dim s As String

 MyHTTP.Close
 
' Trasferiamo in una variabile stringa i dati dell'immagine scaricata e salvata in memoria:
 s = myhttp.Peek()
 Print "Immagine scaricata !\n\nDimensione: "; Len(s); " byte"
 
 Immagine(s)
  
End

Private Procedure Immagine(im As String)
 
 Dim bb, bb2 As Byte[]
 Dim w, h As Integer
 Dim loader, pixbuf, dati As Pointer
 Dim c As Byte
 Dim bo As Boolean
 Dim st As Stream
 Dim imago As Image
  
 bb = Byte[].FromString(im)
 
 loader = gdk_pixbuf_loader_new()
 If loader == 0 Then Error.Raise("Errore !")
 
 gdk_pixbuf_loader_write(loader, bb.data, bb.count, 0)
 
 gdk_pixbuf_loader_close(loader, 0)
 
 pixbuf = gdk_pixbuf_loader_get_pixbuf(loader)
 If pixbuf == 0 Then Error.Raise("Errore !")
 
 w = gdk_pixbuf_get_width(Pixbuf)
 Print "Larghezza: "; w; " pixel"
 h = gdk_pixbuf_get_height(Pixbuf)
 Print "Altezza:   "; h; " pixel"
 c = gdk_pixbuf_get_n_channels(Pixbuf)
 Print "Canali:    "; c
  
' Verifichiamo che l'immagine scaricata abbia il canale Alfa:
 bo = gdk_pixbuf_get_has_alpha(Pixbuf)
 If bo = False Then Error.Raise("L'immagine scaricata è priva del canale Alfa !")
  
 dati = gdk_pixbuf_get_pixels(Pixbuf)
 If dati == 0 Then Error.Raise("Impossibile ottenere un 'Puntatore' ai dati dei pixel dell'immagine !")
  
' Carichiamo i dati nel vettore "bb[]" per gestire successivamente i dati grezzi dei pixel:
 st = Memory dati For Read
  
 With bb = New Byte[w * h * c]
   .Read(st, 0, .count)
 End With
 
' Effettua la correzione della disposizione dei dati RGB dei pixel dell'immagine scaricata:
 bb2 = Corregge(bb)
  
 st.Close
 
' Viene preparata la variabile di tipo Image per la gestione dei dati del futuro nuovo file immagine:
 With imago = New Image(w, h, 0, 0)
   st = Memory .Data For Write
 End With
 
' Scrive i dati presenti nel vettore "bb[]" nell'area di memoria puntata dal Puntatore ".Data" della variabile di tipo "Image":
 bb2.Write(st, 0, bb2.Count)
 
 st.Close
 
 With PictureBox1
   .W = w
   .H = h
   .Image = imago
 End With
 
End

Private Function Corregge(vett As Byte[]) As Byte[]
 
 Dim i As Integer
 Dim bb As Byte[]
 
 bb = New Byte[vett.Count]
  
 For i = 0 To vett.Max Step 4
   bb[i + 1] = vett[i + 1]
   bb[i + 2] = vett[i]
   bb[i] = vett[i + 2]
   bb[i + 3] = vett[i + 3]
 Next
  
 Return bb
  
End


Usando Shell ed il comando wget

Nell'esempio che segue sul Form del programma saranno posti semplicemente una PictureBox ed un Button. Scaricheremo un'immagine da un sito internet mediante wget (che sarà lanciato nel nostro programma mediante il comando Shell), e successivamente la caricheremo nella PictureBox:

Public Sub Button1_Click()

' Scarichiamo l'immagine dal sito web:
 Shell "wget indirizzo/web/della/immagine/da/scaricare --directory-prefix /percorso/ove/l'immagine/sarà/scaricata" Wait [nota 4]

' Carichiamo l'immagine nella PictureBox:
 PictureBox1.Picture = Picture["/percorso/ove/l'immagine/è/stata/scaricata"]

End


Mostrare un file presente in una pagina internet

In questo caso non sarà possibile gestire direttamente i dati del file immagine, ma si provvedere più semplicemente a mostrare il file immagine presente in una pagina web.

Uso del Metodo "Desktop.Open()"

Questa procedura (è necessario attivare il componente gb.desktop) prevede l'utilizzo del solo codice Gambas, ma prevede che il file immagine sia aperto dal programma preimpostato nel nostro sistema per l'apertura, appunto, dei file immagine:

Public Sub Button1_Click()

  Desktop.Open("indirizzo/web/del/file/immagine/da/scaricare")

End

Usando la Classe "URLLabel"

Effetto simile a quello precedente si ottiene usando un Oggetto della Classe "URLLabel".
E' necessario attivare anche il Componente "gb.desktop".

Public Sub Form_Open()

 With URLLabel1
   .Link = "https://www.gambas-it.org"
' Cliccando sul testo del collegamento si aprirà nel browser la pagina dell'indirizzo web impostato:
   .Text = "Sito gambas-it.org"
 End With 

End


Utilizzo del codice HTML

Si potrà effettuare il collegamento ad un file immagine richiamandolo da un oggetto specifico, che supporta il codice html, come la WebView. In tal caso è necessario attivare, come si sa, anche il componente gb.qt4.webkit:

Public Sub Form_Open()  

  WebView1.Html = "<HTML><A HREF='http://www.indirizzo/web/della/immagine'>Collegamento ipertestuale con l'immagine da mostrare.</a></html>"  

End

Nella WebView verrà mostrato il testo, sul quale si dovrà cliccare per far apparire l'immagine.

Se si vuole far apparire l'immagine direttamente, senza dover cliccare su un ipertesto, allora il codice sarà il seguente:

Public Sub Form_Open()  

  WebView1.Html = "<HTML><IMG SRC='http://www.indirizzo/web/della/immagine'>Eventuale testo</img></html>"  

End

Usando la la proprietà ".Url" dell'oggetto WebView

Si potrà usare anche la proprietà ".Url" dell'oggetto WebView:

WebView1.Url = "http://www.indirizzo/web/della/immagine"



Note

[1] In vero, con questa metodo è possibile scaricare qualsiasi tipo di file.

[2] E' possibile ricreare utilmente con questo metodo qualsiasi tipo di file.

[3] Se si vuole inserire l'immagine in una nuova cartella da creare, questa deve essere aggiunta alla fine del pecorso ove si intende scaricare il file:

--directory-prefix /percorso/nuova_cartella


Riferimenti