Purtroppo con quel tipo di formato non puoi usare l'oggetto graphics, e nemmeno "setPixel" mi sa...
In questo caso la cosa diventa un po' più complicata, forse anche troppo a meno che non sia davvero necessario usare bitmap così grandi.
In pratica si tratta di scrivere pixel per pixel l'immagine usando LockBits. Chiaramente essendo davvero complicato calcolare i colori dei pixel uno per uno per creare le scritte, ti potresti aiutare scrivendo bitmap piu piccole (ma a 32 bit in modo
da poter usare l'oggetto graphics su essa) come stai facendo ora, dopo copi i pixel risultanti dalle bitmap a 32 bit vai a formare un "collage" sull'immagine più grande (ma ad 1 bit) composta da tutte le bitmap piccole.
in pratica usi questo metodo:
public static Bitmap BitmapTo1Bpp(Bitmap dest, Bitmap src,Rectangle rect)
{
int w = dest.Width;
int h = dest.Height;
BitmapData data = src.LockBits(rect, ImageLockMode.ReadWrite, PixelFormat.Format1bppIndexed);
byte[] scan = new byte[(w + 7) / 8];
for (int y = 0; y < h; y++)
{
for (int x = 0; x < w; x++)
{
if (x % 8 == 0) scan[x / 8] = 0;
Color c = dest.GetPixel(x, y);
if (c.GetBrightness() >= 0.5) scan[x / 8] |= (byte)(0x80 >> (x % 8));
}
Marshal.Copy(scan, 0, (IntPtr)((long)data.Scan0 + data.Stride * y), scan.Length);
}
src.UnlockBits(data);
return src;
}
Che ti permette di copiare il contenuto di un immagine sorgente a 32 bit (una normale bitmap su cui hai scritto usando l'oggetto graphics), in una bitmap di destinazione a 1 bit in un punto preciso. Il punto in cui scrivere ovviamente devi inserirlo tu,
ovvero dividi "idealmente" la bitmap di destinazione in tanti quadranti della stessa dimensione e li affianchi andando a formare "righe", poi riga per riga formi l'altezza.
esempio:
private static void CreateBtm()
{
//bitmap risultante a 1 bit
var finalBitmap = new Bitmap(10000, 10000, PixelFormat.Format1bppIndexed);
//bitmap che uso per scrivere con graphics
var src = new Bitmap(100, 100);
//numero di riquadri in larghezza
var wDim = finalBitmap.Width / src.Width;
//numero di riquadri in altezza
var hDim = finalBitmap.Height / src.Height;
//ciclo che compone i riquadri
for (int w=0;w<wDim ;w++ )
{
for (int h = 0; h < hDim; h++)
{
//scrivo sulla bitmap "riquadro" a 32 bit
using (var gr = Graphics.FromImage(src))
{
gr.Clear(Color.White);
gr.DrawString($"({w} {h})", new Font("Arial", 12), Brushes.Black, new PointF(0, 0));
}
//scrivo il riquadro nell'immagine grande a 1 bit
BitmapTo1Bpp(src, finalBitmap, new Rectangle(w* src.Width, h* src.Height, 100, 100));
}
}
finalBitmap.Save("finalBitmap.bmp");
}
In questo caso su un immagine di 10000 x 10000 uso dei "quadrati" di 100x100.
Ho usato un immagine di 10000x10000 per questioni di tempo... infatti elaborare e salvare immagini grandi richiede un sacco di risorse anche solo per aprirlo. Ma se sicuro di volere usare immagini così grandi? é davvero necessario?
