Créer CImage de tableau d'Octets

J'ai besoin de créer un CImage à partir d'un tableau d'octets (en fait, de son un tableau de unsigned char, mais je lance à n'importe quelle forme est nécessaire). Le tableau d'octets est dans la forme "RGBRGBRGB...". La nouvelle image doit contenir un copie de l'image en octets, plutôt que d'utiliser la mémoire du tableau d'octets en lui-même.

J'ai essayé beaucoup de différentes manières d'atteindre ce -- y compris en passant par plusieurs HBITMAP les fonctions de création, d'essayer de les utiliser BitBlt-et rien d'autre jusqu'à présent, a travaillé.

Pour tester si la fonction fonctionne, il doit passer ce test:

BYTE* imgBits;
int width;
int height;
int Bpp;   //BYTES per pixel (e.g. 3)
getImage(&imgBits, &width, &height, &Bpp); //get the image bits

//This is the magic function I need!!!
CImage img = createCImage(imgBits, width, height, Bpp);

//Test the image
BYTE* data = img.GetBits();  //data should now have the same data as imgBits

Toutes les implémentations de createCImage() jusqu'à présent se sont retrouvés avec data pointant vers un vide (rempli de zéros) tableau.

On dirait que vous devez remplir une structure de BITMAPINFO pour votre imgBits, instancier un CImage, appelez Create() pour créer un vide bitmap de taille correcte, GetDC() pour obtenir votre CImage du DC et ensuite utiliser ::SetDIBitsToDevice() pour tracer votre imgBits à votre CImage.
Merci, il semble que ce est le chemin à parcourir. Je suis sûr que j'ai été dans cette voie avant, mais il a abandonné parce que je ne pense pas que j'avais la tête à droite. Je vais vous donner un autre aller...

InformationsquelleAutor Lee Netherton | 2011-07-14

atl c++mfc

1

CImage prend en charge le Fric assez facilement et a un SetPixel() méthode de sorte que vous pourriez probablement faire quelque chose comme ceci (non compilé, le code non testé à l'avance!):
```
CImage img;
img.Create(width, height, 24 /* bpp */, 0 /* No alpha channel */);

int nPixel = 0;
for(int row = 0; row < height; row++)
{
    for(int col = 0; col < width; col++)
    {
        BYTE r = imgBits[nPixel++];
        BYTE g = imgBits[nPixel++];
        BYTE b = imgBits[nPixel++];
        img.SetPixel(row, col, RGB(r, g, b));
    }
}
```
Peut-être pas la méthode la plus efficace mais je pense que c'est l'approche la plus simple.
- Merci, ce sera certainement le travail, mais je cherchais quelque chose de beaucoup plus efficace que cela, comme je l'utilise sur un flux vidéo en direct @25 fps
- juste assez, si la vitesse est une question que vous aurez besoin de faire quelque chose de plus intelligent. Je pense que vous pouvez toujours créer le CImage de la même façon, l'utilisation GetBits() pour obtenir un pointeur vers le fichier DIB tableau d'octets, et la copie de votre image octets pour modifier la CImage à la volée. I pense (sur le dessus de ma tête) que DIBSections attendre BGR pas RVB de sorte que vous pouvez avoir besoin de faire des manipulations des octets malheureusement.
- J'ai utilisé cette approche à l'origine une fois (quand j'ai écrit mon premier graphique/GDI projet 🙂 ) et le SetPixel() approche était entre 100 et 250 fois plus lent que d'utiliser les raw d'un octet de la mémoire de données, en fonction de certaines variables comme la carte vidéo etc.
- Je ne suis pas surpris de la voir, j'ai vu des résultats similaires dans le passé. Il obtient quelque chose rapidement, mais n'est viable pour le code final, si la performance n'est pas un problème.
InformationsquelleAutor AAT
1

Utilisation memcpy pour copier les données, puis SetDIBits ou SetDIBitsToDevice en fonction de ce que vous devez faire. Prenez soin de bien que, les lignes de données d'image brutes sont alignés sur 4 octets limites (autant que je me souvienne, il a été quelques années depuis que je l'ai fait) de sorte que les données que vous obtenez de retour de GetDIBits ne sera jamais exactement la même chose que les données d'origine (bien qu'il pourrait, selon la taille de l'image).

Donc plus probable que vous aurez besoin de memcpy scanline par scanline.

InformationsquelleAutor Roel
1

Merci à tous, j'ai réussi à le résoudre en fin de compte, avec votre aide. Il intervient principalement @ferblantier et @Roel la suggestion d'utiliser SetDIBitsToDevice(), mais il s'agit d'un peu plus de bits de se tourner et de gestion de la mémoire, donc j'ai pensé que je devais partager mon point final ici.

Dans le code ci-dessous, je suppose que width, height et Bpp (Octets par pixel), ainsi que l' data est un pointeur vers le tableau de valeurs de pixels RVB.
```
//Create the header info
bmInfohdr.biSize = sizeof(BITMAPINFOHEADER);
bmInfohdr.biWidth = width;
bmInfohdr.biHeight = -height;
bmInfohdr.biPlanes = 1;
bmInfohdr.biBitCount = Bpp*8;
bmInfohdr.biCompression = BI_RGB;
bmInfohdr.biSizeImage = width*height*Bpp;
bmInfohdr.biXPelsPerMeter = 0;
bmInfohdr.biYPelsPerMeter = 0;
bmInfohdr.biClrUsed = 0;
bmInfohdr.biClrImportant = 0;
BITMAPINFO bmInfo;
bmInfo.bmiHeader = bmInfohdr;
bmInfo.bmiColors[0].rgbBlue=255;
//Allocate some memory and some pointers
unsigned char * p24Img = new unsigned char[width*height*3];
BYTE *pTemp,*ptr;
pTemp=(BYTE*)data;
ptr=p24Img;
//Convert image from RGB to BGR
for (DWORD index = 0; index < width*height ; index++)
{
unsigned char r = *(pTemp++);
unsigned char g = *(pTemp++);
unsigned char b = *(pTemp++);   
*(ptr++) = b;
*(ptr++) = g;
*(ptr++) = r;
}
//Create the CImage
CImage im;
im.Create(width, height, 24, NULL);
HDC dc = im.GetDC();
SetDIBitsToDevice(dc, 0,0,width,height,0,0, 0, height, p24Img, &bmInfo, DIB_RGB_COLORS);
im.ReleaseDC();
delete[] p24Img;
```
- Êtes-vous sûr que cela fonctionne pour les images de différentes tailles? Je l'ai regardé, MSDN en effet dit: "Les lignes de balayage doit être alignée sur une valeur DWORD sauf pour RLE-comprimé bitmaps." J'ai creusé un peu de code je l'ai déjà écrit, qui n'a à peu près quelque chose comme ça, je malloc ed davantage de mémoire que vous faites: int rowlength = 4 * ((nrows * 24 + 31) / 32); BYTE* pBits = (BYTE*)malloc(rowlength * nRows); et ensuite rempli les valeurs dans ce tableau comme ceci: pBits[(bitmap_r * rowlength) + bitmap_c] = GetBValue(couleur); (cette définition de la couleur des composants un par un, bitmap_c itéré (3 * n_cols))
- Homme de ces commentaires sucer, pas de mise en forme du code, ne peut même pas mettre un saut de ligne 🙁
- Hmm, c'est un bon point. Je ne suis pas sûr en fait, toutes mes images sont en 640x480, donc je n'ai pas de problème. Mais vous avez raison, d'autres dimensions peuvent causer des problèmes.
- Oh, je vois, oui quand vos images sont toujours les résolutions d'écran, vous devriez être bon - ils sont (pour l'instant) toujours des multiples de 4.
InformationsquelleAutor Lee Netherton

Ici est une solution plus simple. Vous pouvez utiliser GetPixelAddress(...) au lieu de tout cela BITMAPHEADERINFO et SedDIBitsToDevice. Un autre problème que j'ai résolu a avec les images 8 bits, qui doivent avoir la table des couleurs définies.

CImage outImage;
outImage.Create(width, height, channelCount * 8);
int lineSize = width * channelCount;
if (channelCount == 1)
{
//Define the color table
RGBQUAD* tab = new RGBQUAD[256];
for (int i = 0; i < 256; ++i)
{
tab[i].rgbRed = i;
tab[i].rgbGreen = i;
tab[i].rgbBlue = i;
tab[i].rgbReserved = 0;
}
outImage.SetColorTable(0, 256, tab);
delete[] tab;
}
//Copy pixel values
//Warining: does not convert from RGB to BGR
for ( int i = 0; i < height; i++ )
{
void*       dst = outImage.GetPixelAddress(0, i);
const void* src = /* put the pointer to the i'th source row here */;
memcpy(dst, src, lineSize);
}

InformationsquelleAutor Michal Czardybon

Vous devez vous connecter pour publier un commentaire.