Ich möchte aus einen Array ein Image (Graustufenbild) erzeugen. Leider bekomme ich immer die Fehlermeldung "LoadFromStream Lesefehler". Ich bin mir nicht sicher wie ich die Header für eine Bitmap definieren soll. Vielleicht kann mir da jemand Helfen.

TBitmapFileHeader *BitmapFileHeader = new TBitmapFileHeader;
        TBitmapInfo *BitmapInfo = new TBitmapInfo;

        BitmapFileHeader->bfType=19778;    // ASCII CODE "BM"
        BitmapFileHeader->bfSize=sizeof(TBitmapFileHeader) + sizeof(TBitmapInfo) + 300*300;
        BitmapFileHeader->bfReserved1=0;
        BitmapFileHeader->bfReserved2=0;
        BitmapFileHeader->bfOffBits=sizeof(TBitmapFileHeader) + sizeof(TBitmapInfo);

        BitmapInfo->bmiHeader.biSize=sizeof(TBitmapInfoHeader);
        BitmapInfo->bmiHeader.biWidth=300;
        BitmapInfo->bmiHeader.biHeight=300;
        BitmapInfo->bmiHeader.biPlanes=1;
        BitmapInfo->bmiHeader.biBitCount=8;
        BitmapInfo->bmiHeader.biCompression=BI_RLE8; //BI_RGB;
        BitmapInfo->bmiHeader.biSizeImage=300*300;
        BitmapInfo->bmiHeader.biXPelsPerMeter=3780; // 96dpi
        BitmapInfo->bmiHeader.biYPelsPerMeter=3780;
        BitmapInfo->bmiHeader.biClrUsed=0;
        BitmapInfo->bmiHeader.biClrImportant=0;
        for (int i=0; i<256; i++)
        {
                BitmapInfo->bmiColors[i].rgbBlue=i;
                BitmapInfo->bmiColors[i].rgbGreen=i;
                BitmapInfo->bmiColors[i].rgbRed=i;
                BitmapInfo->bmiColors[i].rgbReserved=0;
        }

        TMemoryStream* pMemStream = new TMemoryStream;
        pMemStream->Write(BitmapFileHeader, sizeof(TBitmapFileHeader));
        pMemStream->Write(BitmapInfo, sizeof(TBitmapInfo));
        pMemStream->Write(data8bit.pixeldata, 300*300);

        pMemStream->Write(data, 300*300);
        pMemStream->Position = 0;

        Graphics::TBitmap *pBmp = new Graphics::TBitmap();
        pBmp->LoadFromStream(pMemStream);

        SnapImage->Picture->Bitmap=pBmp;

Ich Hoffe das mir jemand Helfen kann.

Ich benötige dies für das arbeiten mit einer Framegrabberkarte. Vielleich hat ja jemand es geschaft die Digitalisierten Bilddaten auf den Bildschirm darzustellen mit z.B. 25 Bilder pro Sec.

mit ScanLine habe ich das schon Versucht und es Funktioniert wunderbar. Aber ich möchte ein Livebild erzeugen. Nur das bekomme ich nicht hin. Zwar gibt es funktionen wie z.B. capCreateCaptureWindow() mit den ich ein Fenster dazu erzeugen kann. Leider bekomme ich das Livebild nicht hin. Ich weiss nicht wie ich das Anstellen soll

Geht es, wenn du myImage->Visible = false; setzt? Die Zuweisung des Bildes unsichtbar, dann wieder Visible schalten.

Hab aber auch mit sowas nicht immer Glück. myImage->Refresh(), ProzessMessages()... klappen manchmal, können aber auch als müde Fehlversuche enden. Bin also auch gespannt, was die Profis empfehlen.

super Omega-X das mit Image->Refresh() funktioniert super. Danke für den Tip. Nur Flackert das Bild ein wenig. Kann man das unterbinden?

Das mit dem Flickern hängt mit der Widerholrate zusammen. Noch geht es nicht so schnell, daß das Auge es nicht wahrnimmt. - Da du immer ganze Bilder einfügst, ist es mit einem Film vergleichbar.

Hast du eine neuere BCB-Version. Kannst mal mit DoubleBuffering probieren.

Oder:
Mach das Image unsichtbar
weis das Bild einer Speicherbitmap zu
übernimm das Bild von der Speicherbitmap ins Image
mach Image wieder sichtbar.

Warum nicht? Einen versuch könnte es wert sein. Auf die Art funktioniert ja DoubleBuffering (wenngleich es hier nicht so hilfreich sein dürfte).

Danke für den nächsten Tip. Habe BCB 6.0 und das DoubleBuffering habe ich für
die Form aktiviert. Also das hat nicht geholfen. Habe gelesen das die Funktion keinen einfluss auf das Image hat (habe in der Suchfunktion nachgesehen). Der zweite Vorschlag war schon etwas besser es Flackert immer noch aber ich glaube weniger. Hast mich aber schon sehr weit gebracht, deshalb nochmals Danke

Jetzt könnte ich zB. sagen, daß es jetzt besser zu sein scheint, rührt ggf. von der größeren Ordnung her. Das noch teilweise im Laden begriffene Bild wurde auf's bereits sichtbare Image übertragen, das bringt dann so einen Wischeffekt. Das vollständige Bild direkt aus dem Speicher mit Assign() kann die volle systemperformance nutzen. Aber ich sag es nicht. Das sind die kleinen Lerneffekte, die mit der Übung sowieso kommen.

hab ein ähnliches Problem.
Ich will den Inhalt eines Arrays in einen Stream schreiben, und aus diesem Stream dann ein TBitmap erzeugen.
Das Array habe ich vorher schon so bearbeitet, daß dort sämtliche Informationen enthalten sind(FileHeader, InfoHeader...)

Der Buffer (m_RcvBuf) ist wie folgt deklariert:

//Breite * Hoehe * Byte/Pixel(24 bit)
MAX_IMAGE_LEN_ = 640*280*3
char m_RcvBuf[MAX_IMAGE_LEN_];

TMemoryStream *pms = new TMemoryStream;
  Graphics::TBitmap *bmp = new Graphics::TBitmap();

  if(m_RcvBuf[0] == 0) return false;
  pms->WriteBuffer(m_RcvBuf, sizeof(m_RcvBuf)));
  pms->Position = 0;

  int test = pms->Size;

  bmp->LoadFromStream(pms);

  Image2->Picture->Bitmap   = bmp;

Beim LoadFromStream bekomme ich immer den Fehler: Stream Read Error.

Kann bitte jemand helfen, ich verzweifel gleich;)

Vielen Dank.

mfg

Evtl. liegt es an der Anzahl der Bytes beim Rausschreiben. Du schreibst ja hier den gesamten verfügbaren Puffer raus. Ist der aber auch vollständig belegt?
Wie beschreibst du denn m_RcvBuf?

der Buffer ist vollständig beschrieben.
Er liegt entsprechend dem HBITMAP Format vor.

Im Prinzip:

BitmapFileHeader + BitmapInfoHeader + 640*240 Pixel * 3(wegen 24 Bit-Codierung)

Mit den entsprechenden Windows-Api-Funktionen kann ich mir das Bitmap als DIB mit vorher gesetztem DeviceContext auch wunderbar anzeigen lassen.
Nur brauch ich es eben als TBitmap.

mfg