La lecture bitmap monochrome couleurs des pixels

Je ne sais pas un meilleur titre, mais je vais vous décrire le problème.

Un morceau de matériel que nous utilisons a la capacité d'afficher des images.
Il peut afficher une image en noir et blanc avec une résolution de 64 × 256.

Le problème est le format de l'image que nous avons de les envoyer à l'appareil.
Ce n'est pas un standard format bitmap, mais au lieu de cela, il est tout simplement un tableau de
octets représentant de chaque pixel de l'image.

0 = noir, 1 = blanc.

Ainsi, si nous avions une image avec la taille: 4 x 4 le tableau d'octets pourrait ressembler à quelque chose comme:

1000 0100 0010 0001

Et l'image devrait ressembler à:

Bitmap http://www.mediafire.com/imgbnc.php/6ee6a28148d0170708cb10ec7ce6512e4g.jpg

Le problème est que nous avons besoin pour créer cette image par la création d'un bitmap monochrome
en C# et puis convertir le fichier en format compris par l'appareil.

Par exemple, on peut afficher du texte sur l'appareil. Pour ce faire, il serait
créer un bitmap et d'écrire du texte à:

var bitmap = new Bitmap(256, 64);

using (var graphics = Graphics.FromImage(bitmap))
{
    graphics.DrawString("Hello World", new Font("Courier", 10, FontStyle.Regular), new SolidBrush(Color.White), 1, 1);
}

Il y a 2 problèmes ici:

Le bitmap généré n'est pas monochrome
Le bitmap généré a un autre format binaire

J'ai donc besoin d'un moyen de:

Générer une image bitmap monochrome .NET
Lire les pixels individuels de couleurs pour chaque pixel de l'image bitmap

J'ai trouvé que vous pouvez régler la profondeur de pixel de 16, 24 ou 32 bits, mais je n'ai pas trouvé monochrome et je n'ai aucune idée de comment lire les données de pixel.

Suggestions sont les bienvenues.

Mise à JOUR: je ne peux pas utiliser Win32 PInvokes... qui doit être plate-forme neutre!

SUIVI: Le code suivant fonctionne pour moi maintenant. (Juste au cas où quelqu'un en a besoin)

private static byte[] GetLedBytes(Bitmap bitmap)
{
    int threshold = 127;
    int index = 0;
    int dimensions = bitmap.Height * bitmap.Width;

    BitArray bits = new BitArray(dimensions);

    //Vertically
    for (int y = 0; y < bitmap.Height; y++)
    {
        //Horizontally
        for (int x = 0; x < bitmap.Width; x++)
        {
            Color c = bitmap.GetPixel(x, y);
            int luminance = (int)(c.R * 0.3 + c.G * 0.59 + c.B * 0.11);
            bits[index] = (luminance > threshold);
            index++;
        }
    }

    byte[] data = new byte[dimensions / 8];
    bits.CopyTo(data, 0);
    return data;
}

OriginalL'auteur TimothyP | 2009-03-02

.net bitmap c#drawing graphics

6

Je voudrais calculer la luminance de chaque pixel d'une puis de le comparer à un certain seuil de valeur.
```
y=0.3*R+0.59G*G+0.11*B
```
Dire la valeur de seuil est 127:
```
const int threshold = 127;
Bitmap bm = { some source bitmap };

byte[,] buffer = new byte[64,256];

for(int y=0;y<bm.Height;y++)
{
  for(int x=0;x<bm.Width;x++)
  {
   Color c=source.GetPixel(x,y);
   int luminance = (int)(c.R*0.3 + c.G*0.59+ c.B*0.11);
   buffer[x,y] = (luminance  > 127) ? 1 : 0;
  }
}
```
Point de pour que! Mais si vous utilisez Bitmap.LockBits au lieu de Bitmap.GetPixel vous obtenez des performances supérieures!
Thnx! Avec quelques ajustements mineurs, ce code fonctionne comme un charme 🙂
danbystrom: Vous avez raison, a voulu garder l'exemple de code propre et pointeur-moins possible.

OriginalL'auteur arul
1

Je ne sais pas C#. Il y a probablement beaucoup de façons de le faire. Voici une méthode simple.
1. Créer un vide noir de l'image bitmap de taille égale à votre exigence de périphérique. Dessiner ce que vous voulez dessiner comme du texte, des chiffres, etc.
2. Maintenant seuil de l'image c'est à dire l'ensemble des pixels de l'image ci-dessous, une valeur d'intensité à zéro d'autre jeu il. par exemple, de définir toutes les valeurs d'intensité > 0 à 1.
3. Maintenant les convertir au format requis par votre appareil. Créer un tableau d'octets de la taille (64 * 256)/8. Définir les bits correspondants à 1, où le pixel correspondant valeurs antérieures bitmap sont 1, sinon remettre à 0.
Edit: L'Étape 3. Utiliser les opérateurs au niveau du bit pour définir les bits.

Le problème est que je n'ai aucune idée de comment lire les valeurs des pixels d'une image bitmap
Eh bien, vous devez vérifier à l'Api. Il doit y avoir une méthode comme la méthode getPixel(), getIntensity() ou peut-être même un simple tableau de référence de ne se.

OriginalL'auteur Xolve
1

Vous ne devriez pas utiliser la méthode GetPixel de votre image bitmap convertir toute la bitmap à partir d'un format à un autre! Ce sera inefficace. Au lieu de cela, vous devez utiliser LockBits méthode pour obtenir l'accès à une copie de l'image de la mémoire tampon et le convertir dans le format désiré. Je ne suis pas complètement sûr de convertir en monochrome, mais il est Format1bppIndexed valeur dans PixelFormat énumération qui peut vous aider.

OriginalL'auteur okutane
1

Vous pouvez essayer de fournir un pixelformat dans le constructeur:
```
var bitmap = new Bitmap(256, 64, PixelFormat.Format1bppIndexed);
```
Quand j'ai fait dessiner des images bitmaps monochromes sur d'autres plates-formes que j'ai parfois eu
pour désactiver l'anticrénelage ou le rendu de texte ne s'affichent pas:
```
graphics.SmoothingMode=SmoothingMode.None;
```
YMMV.

Vous ne pouvez pas appeler les Graphiques.FromImage sur rien de moins que 32bpp

OriginalL'auteur
1

Image a une méthode GetPixel que vous pouvez utiliser. Cela vous permettra de dessiner sur l'image et, plus tard, de le convertir au format que vous avez besoin.

Des images dans Windows forms (ie, accessibles grâce à des Graphiques.FromImage) sont 24 bpp (peut-être 32? Il est trop tôt, et honnêtement, je l'oublier). Néanmoins, la méthode GetPixel retourne un objet en Couleur, de sorte que la profondeur de bits de l'image bitmap est négligeable. Je vous suggère d'écrire votre code comme ceci:
```
MyBitmapFormat ToMyBitmap(Bitmap b)
{
    MyBitmapFormat mine = new MyBitmapFormat(b.Width, b.Height);

    for (int y=0; y < b.Height; y++) {
        for (int x=0; x < b.Width; x++) {
            mine.SetPixel(x, y, ColorIsBlackish(b.GetPixel(x, y)));
        }
    }
}

bool ColorIsBlackish(Color c)
{
    return Luminance(c) < 128; //128 is midline
}

int Luminance(c)
{
    return (int)(0.299 * Color.Red + 0.587 * Color.Green + 0.114 * Color.Blue);
}
```
Ce processus est appelé la simple seuillage. C'est braindead, mais elle fonctionnera comme une première coupe.

OriginalL'auteur plinth
1

merci pour le code ci-dessus - je suis en train de convertir une image monochrome dans un tableau 2d où 1-0 noir blanc cependant, je vais avoir quelques difficultés - j'ai utilisé votre code pour charger un 8x8 image bmp, et je suis sortie de son contenu d'une zone de texte en utilisant
```
myGrid =GetLedBytes(myBmp);
     for (int x = 1; x < 8; x++)
     {
         textBox1.Text = textBox1.Text + Convert.ToString(myGrid[x])+ "  ";
     }
```
cependant je reçois cela comme un résultat dans la zone de texte:
```
225  231  231  231  231  129  255  
```
comment puis-je obtenir c'est donc de 0 et de 1?

Si vous utiliser des pixels.GetColor vous pouvez obtenir le R, G, B, les valeurs d'un pixel à droite? Donc, puisque vous faites en noir et blanc tout ce que vous devez faire est de vérifier, R, G, B == 0, ce qui signifie noir. Tout le reste du code n'est pas nécessaire.

OriginalL'auteur user311225
0

Ce chap a du code qui crée un mono bitmap. Le SaveImage exemple est celui de l'intérêt.

Le lien est mort

OriginalL'auteur Quibblesome

Vous devez vous connecter pour publier un commentaire.