C# / VB.NET - File bmp

Mi sono reso conto adesso di essere stato un po' criptico, vedo di spiegarmi meglio.
Quando genero il bmp, lo genero direttamente a 4bpp e assegno il valore che voglio, questo è ok .
Quando invece devo usare un bmp 1bpp lo devo convertire a 4bpp e assegnare il valore che voglio. Con i bmp 8bpp devo rimappare la palette originale su una a 8 livelli ( alcune volte a 5 livelli) .
Quindi a memoria, direi che tutte queste cose le avevamo viste .
A questo punto penso che rimango un altro punto da chiarire e poi dovrei essere quasi in dirittura d'arrivo.
Stavo pensando, visto l'ingente numero di esempi volevo trovare il modo di salvare la discussione per future necessità.

La via più semplice è salvarsi il link, finquando Pierotofy esiste e hai una connessione la discussione la trovi subito:
pierotofy.it/pages/extras/forum/…

Per avere la discussione archiviata e leggibile anche senza connessione a internet: con Mozilla Ctrl+s, salva la pagina visualizzata al momento, oppure menù in alto a destra, tre righette orizzontali: Salva pagina con nome.

Tutto l'Html, le immagini, i CSS e i js, vengono organizzati in cartelle e all'esterno della cartella ci sarà un file htm apribile con un browser.
Devi tenere presente che potrai scorrere tutta la pagina salvata e copiare eventuali testi di interesse, ma se clicchi qualsiasi collegamento o tastino verrà aperto il link reale alla pagina internet, che se presente funzionerà regolarmente, ma non sarai più nella tua pagina salvata.
Questo implica che per salvare questa discussione dovrai effettuare 5 salvataggi, uno per ogni pagina e che eventuali allegati li dovrai scaricare separatamente per averli disponibili senza internet attivo.

Capito, probabilmente salvero tutto off line.
Ho trovato questo esempio online per ridimensionare una grafica

Public Shared Function ResizeImage(img As Image, width As Integer, height As Integer) As Image
    Dim newImage = New Bitmap(width, height)
    Using gr = Graphics.FromImage(newImage)
        gr.SmoothingMode = SmoothingMode.HighQuality
        gr.InterpolationMode = InterpolationMode.HighQualityBicubic
        gr.PixelOffsetMode = PixelOffsetMode.HighQuality
        gr.DrawImage(img, New Rectangle(0, 0, width, height))
    End Using
    Return newImage
End Function
 
Public Shared Function ResizeImage(img As Image, size As Size) As Image
    Return ResizeImage(img, size.Width, size.Height)
End Function
 
Public Shared Function ResizeImage(bmp As Bitmap, width As Integer, height As Integer) As Image
    Return ResizeImage(DirectCast(bmp, Image), width, height)
End Function
 
Public Shared Function ResizeImage(bmp As Bitmap, size As Size) As Image
    Return ResizeImage(DirectCast(bmp, Image), size.Width, size.Height)
End Function

Mi aiuteresti a capirlo?
Il mio scopo è di ingrandire una grafica, a volte solo una dimensione, altre volte entrambe le dimensioni ma con ratio differente.
Grazie

Ti ho remmato il siglificato delle righe, ma questa è un'altra domanda, non è più pertinente in questa discussione

Hai ragione, scusa per OT.
Ritornando in tema, quando rimappiamo una palette 256 toni in una a 16, la divisione è a step di 16. Io però anche avendo un 4bpp devo usare solo 8 livelli, quindi il quarto bit dovrebbe sempre essere a 0, quindi step di 32. E nel caso che non volessi una suddivisione lineare?

una palette lineare a tre bit (nero...bianco):

'creo la palette scala di grigio 3bit
        Dim palette As Imaging.ColorPalette = clone4bpp.Palette
        For i = 0 To palette.Entries.Length - 1
            If i > 7 Then
                palette.Entries(i) = Color.Black
            Else
                palette.Entries(i) = Color.FromArgb(i * 36.4, i * 36.4, i * 36.4)
            End If
        Next i

i livelli oltre il 7 conterranno (0,0,0), esistono ma li puoi ignorare

una palette di grigi non lineari arbitrari:

'creo la palette scala di grigio 3bit
Dim palette As Imaging.ColorPalette = clone4bpp.Palette
palette.Entries(0) = Color.FromArgb(0, 0, 0)
palette.Entries(1) = Color.FromArgb(10, 10, 10)
palette.Entries(2) = Color.FromArgb(20, 20, 20)
palette.Entries(3) = Color.FromArgb(30, 30, 30)
palette.Entries(4) = Color.FromArgb(100, 100, 100)
palette.Entries(5) = Color.FromArgb(101, 101, 101)
palette.Entries(6) = Color.FromArgb(200, 200, 200)
palette.Entries(7) = Color.FromArgb(255, 255, 255)

i livelli 0...7 li inventi tu l'essenziale è che i tre valori RGB siano uguali per ottenere un grigio
i livelli oltre il 7 li puoi azzerare o lasciare come sono

Quando rimappo una grafica con palette da 8bpp a 4bpp come avviene la cosa ? raggruppa n colori e li associa al nuovo colore ?
Per esempio da 255 a 230 diventa 15 , da 229 a 200 diventa 14 e via così?

Non so di preciso come funziona so che di default da 8bpp a 4bpp è molto grossolano, ci dovrebbero essere delle istruzioni per rimappare la palette e quantizzarla per ottenere risultati molto raffinati, in GDI+ c'è anche colorMatrix.

La cosa si può fare anche a mano usando le conoscenze di base.
Apri un nuovo progetto WinForm e nel form metti due picturebox affiancate.
La prima parte del codice crea un'immagine con una sfumatura da 256 livelli di grigio e i dati sono contenuti nel vettore colorValues
La seconda parte del codice crea un'immagine vuota con palette a 16 livelli di grigio e i dati sono contenuti nel vettore vuoto levelValues
La terza parte del codice legge colorValues e lo usa per scrivere con palette scalata in levelValues
La quarta parte del codice mette i dati contenuti nei vettori creati in bmp8bpp e bmp4bpp, per mostrarli su due picturebox

Public Class Form1
    Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load

        Dim bmp8bpp As New Bitmap(255, 255, Imaging.PixelFormat.Format8bppIndexed) ' immagine 8bpp
        ' blocco i bit della bitmap     
        Dim area8 As Rectangle = New Rectangle(0, 0, bmp8bpp.Width, bmp8bpp.Height)
        Dim bmpData8 As System.Drawing.Imaging.BitmapData = bmp8bpp.LockBits(area8, Drawing.Imaging.ImageLockMode.ReadWrite, bmp8bpp.PixelFormat)

        ' creo una palette con 256 livelli di grigio
        Dim palette256 As Imaging.ColorPalette = bmp8bpp.Palette
        For i = 0 To palette256.Entries.Length - 1
            palette256.Entries(i) = Color.FromArgb(i, i, i)
        Next i
        ' associo la palette creata alla bitmap 8bpp,
        ' i valori 0...255 ora corrispondono alla scala dal nero al bianco
        bmp8bpp.Palette = palette256
        Dim ptr8 As IntPtr = bmpData8.Scan0 ' puntatore all'indirizzo di memoria del primo byte.
        Dim bytes8 As Integer = Math.Abs(bmpData8.Stride) * bmp8bpp.Height ' calcolo dei bytes necessari
        Dim colorValues(bytes8 - 1) As Byte ' un array che conterrà tutti i bytes della bitmap.
        ' creo una sfumatura
        For colonna = 0 To bmp8bpp.Width
            For riga = 0 To Math.Abs(bmpData8.Stride) - 2
                Dim ind As Integer = colonna + riga * Math.Abs(bmpData8.Stride) 'calcolo l'indice
                ' per semplificare l'esempio, la bitmap è larga 256 pixel,
                ' la colonna viene usata anche per impostare il colore
                colorValues(ind) = colonna ' il valore di colonna come valore del byte di grigio 0...255
            Next
        Next

        ' dichiaro bmp4bpp
        Dim bmp4bpp As New Bitmap(255, 255, Imaging.PixelFormat.Format4bppIndexed)
        ' blocco i bit della bitmap     
        Dim area4 As Rectangle = New Rectangle(0, 0, bmp4bpp.Width, bmp4bpp.Height)
        Dim bmpData4 As System.Drawing.Imaging.BitmapData = bmp4bpp.LockBits(area4, Drawing.Imaging.ImageLockMode.ReadWrite, bmp4bpp.PixelFormat)
        ' creo una palette con 16 livelli di grigio
        Dim palette16 As Imaging.ColorPalette = bmp4bpp.Palette
        For i = 0 To palette16.Entries.Length - 1
            palette16.Entries(i) = Color.FromArgb(i * 17, i * 17, i * 17)
        Next i
        ' associo la palette creata alla bitmap 4bpp,
        ' i valori 0...15 ora corrispondono alla scala dal nero al bianco
        bmp4bpp.Palette = palette16
        Dim ptr4 As IntPtr = bmpData4.Scan0
        Dim bytes4 As Long = Math.Abs(bmpData4.Stride) * bmp4bpp.Height ' calcolo dei bytes necessari
        Dim levelValues(bytes4 - 1) As Byte

        ' nel vettore che rappresenta bmp4bpp ci copio i dati dal vettore che rappresenta bmp8bpp, scalati
        ' scorro tutto il vettore colorValues che rappresenta bmp8bpp
        For ind = 0 To bytes8 - 1
            ' il vettore levelValues che rappresenta bmp4bpp è lungo la metà rispetto a colorValues
            ' il valore di un pixel di colorValues, in un byte replicato per due pixel
            levelValues(ind \ 2) = (colorValues(ind) \ 16) + (colorValues(ind) \ 16) * 16
        Next

        ' ripristino vettore su immagine
        System.Runtime.InteropServices.Marshal.Copy(colorValues, 0, ptr8, bytes8)
        bmp8bpp.UnlockBits(bmpData8) ' sblocco bit
        PictureBox1.Width = bmp8bpp.Width
        PictureBox1.Height = bmp8bpp.Height
        PictureBox1.Image = bmp8bpp

        ' ripristino vettore su immagine
        System.Runtime.InteropServices.Marshal.Copy(levelValues, 0, ptr4, bytes4)
        bmp4bpp.UnlockBits(bmpData4) ' sblocco bit
        PictureBox2.Left = PictureBox1.Left + PictureBox1.Width + 20
        PictureBox2.Width = bmp4bpp.Width
        PictureBox2.Height = bmp4bpp.Height
        PictureBox2.Image = bmp4bpp

    End Sub
End Class

niente di nuovo.
se ti servono più info su:
levelValues(ind \ 2) = (colorValues(ind) \ 16) + (colorValues(ind) \ 16) * 16
chiedi