Danke für die klasse Zusammenarbeit!

[Stuttgart]

Hi,

ich hab jetzt den Ablauf verstanden! Man muss das auf die Variable übertragen weil sonst die Pixel "verloren" gehen würden. Man lagert sie praktisch zwischen.

Ich hab es jetzt noch mal selber probiert und stell mir das so vor:

}

    GetBitmapBits(hBmp,sizeInBytes,(void*)Speicher);

for(x=0;x<width/2;x++) { 
  int x;
  int MyTempVar;

  Speicher[y*tagbmp.bmWidth+x]=Zeile;                 //Ausgangszeile
  Speicher[y*tagbmp.bmWidth+(width-x-1)]=MyTempVar;  //Spiegelzeile

Zeile=Speicher[y*tagbmp.bmWidth+(width-x-1)];      //Zeile wird auf Spiegelzeile gebracht
  MyTempVar=Speicher[y*tagbmp.bmWidth+x];             //Zeile wird Spiegelzeile zugewiesen

}

Fehlermeldungen die kommen:

x nicht deklarierter Bezeichner
width nicht deklarierter Bezeichner
Zeile nicht deklarierter Bezeichner

Vielleicht bin auch komplett auf dem Holzweg. Wäre ja nicht das
erste Mal.

Grüße

[_matze]

Du solltest dringend mal ein C-Grundlagen-Tutorial 'reinziehen. Du kannst eine Variable nicht benutzen, wenn du sie nicht vorher deklariert hast. Sonst existiert sie einfach nicht. Hier versuchst du aber, die Variablen x, width und Zeile zu benutzeen. Die gibt es nicht! Bei x machst du es ganz kurios. Du willst sie verwenden (im Kopf der for-Schleife), deklarierst sie aber erst in der Schleife, also darunter...

Eine Variable deklariert man so:

int x;  //es gibt jetzt eine Variable x

x=5;  //x wird der Wert 5 zugewiesen, x ist jetzt 5!

Zur Variable x: die brauchst du, da du zwei verschachtelte Schleifen benutzen musst. Eine, die die Zeile repräsentiert, und eine für die Spalte (x). y habe ich schon deklariert (am Anfang der main), auf die gleiche Art erzeugst du jetzt eine Variable x.

Zur Variable width: die brauchst du nicht erzeugen. Du hast die Breite des Bildes doch schon! Die steht in "tagbmp.bmWidth".

Zur Variable Zeile: Keine Ahnung, was du damit willst. Meinen Pseudocode von vorhin solltest du nicht so wörtlich nehmen.

Der Ablauf muss so sein:

for(y=0;y<tagbmp.bmHeight;y++) {  //gehe durch jede Zeile des Bildes
  for(x=0;x<tagbmp.bmWidth/2;x++) {  //gehe in der aktuellen Zeile durch jeden Pixel bis zur Hälfte des Bildes (denn an dem Punkt hast du bereits alle Pixel der Zeile getauscht
    //das hier sollst du schon selbst machen (wenigstens ein bisschen Lerneffekt muss sein
    //- linken Pixel in eine temporäre int-Variable speichern
    //- den Wert vom rechten Pixel in den linken speichern
    //- den Wert der temporären Variable in den rechten Pixel speichern
  }
}

Nochmal: in diesen Schleifen kannst du einen Pixel addressieren mit Speicher[y*tagbmp.bmWidth+x]. Diese Formel musst du anwenden, da Speicher kein zweidimensionales Array ist (wie es bei einem 2D-Bild eigentlich logischer wäre), sondern ein eindimensionales (eine einfache Aneinanderreihung der Pixel). Um zur zweiten Zeile und dem dritten Pixel zu hüpfen, musst du zur Nullposition einmal die Breite einer Zeile addieren (1*tagbmp.bmWidth) und eben die Spalte 3 (+3) => Speicher[1*tagbmp.bmWidth+3]. Klar?

[Stuttgart]

Abend Matze,

ja das mit Grundkurs hast du Recht. Das Problem ist, dass wir in der Schule jemanden haben der es einfach zu gut drauf hat! (Fast so wie du, nur du erklärst super) Natürlich sind nicht immer die Lehrer schuld aber sie tragen dazu bei :p

Um deinen Nerven den Rest zu geben hab ich mir mal Gedanken gemacht!

Ich hab bei main nochmal die Variablen die wir zur Spiegelung brauchen aufgeführt

int y;
	int x;
	int Temp;

Und das eigentliche Spiegeln hab ich mir jetzt mal so überlegt (so wie du gesagt hast)

for(y=0;y<tagbmp.bmHeight;y++) {													  //gehe durch jede Zeile des Bildes
    for(x=0;x<tagbmp.bmWidth/2;x++) {													 //gehe in der aktuellen Zeile durch jeden Pixel bis zur Hälfte des Bildes (denn an dem Punkt hast du bereits alle Pixel der Zeile getauscht
    Speicher[y*tagbmp.bmWidth+x]=Temp;													//- linken Pixel in eine temporäre int-Variable speichern
    Speicher[y*tagbmp.bmWidth+x]=Speicher[y*tagbmp.bmWidth-x-1];                //- den Wert vom rechten Pixel in den linken speichern
	Temp=Speicher[y*tagbmp.bmWidth-x-1];									  //- den Wert der temporären Variable in den rechten Pixel speichern

Wenn ich das Programm ausführe, kommt erstmal "Laden erfolgreich" und dann "Wegen eines schwerwiegenden Fehlers..musste das Programm beendet werden".

Na ja vielleicht findest du ja wenigstens eine richtige Zeile.

Grüße und schönen Abend noch

[_matze]

Ist ja schonmal ein Fortschritt, aber...

Stuttgart schrieb:

Speicher[y*tagbmp.bmWidth+x]=Temp;

Du vertauschst immer die Zuweisung. Hier würdest du den Wert von Temp (und Temp wurde ja zu dem Zeitpunkt noch gar nichts zugewiesen) in den Pixel x,y speichern. Das muss ja genau umgekehrt sein.

Temp=Speicher[y*tagbmp.bmWidth+x];  //so wird der Wert des Pixels x,y in Temp gespeichert

Ich denke aber nicht, dass hier das Problem mit dem Absturz liegt. Zeig bitte mal deine komplette main-Funktion.

[Stuttgart]

Ach maaaan!

Das weiß ich doch. Ich bin so hohl! Das hatten wir schon!

Klar muss Temp=... heißen. Sorry

Hab jetzt nochmal unseren gesamten Quellcode hier:

#include <stdio.h>
#include <windows.h>

void errhandler(char *szErrString) {
    printf("ERROR: %s",szErrString);
    exit(9);
}

PBITMAPINFO CreateBitmapInfoStruct(HWND hwnd, HBITMAP hBmp)
{
    BITMAP bmp;
    PBITMAPINFO pbmi;
    WORD    cClrBits;

    // Retrieve the bitmap color format, width, and height.
    if (!GetObject(hBmp, sizeof(BITMAP), (LPSTR)&bmp))
        errhandler("GetObject");

    // Convert the color format to a count of bits.
    cClrBits = (WORD)(bmp.bmPlanes * bmp.bmBitsPixel);
    if (cClrBits == 1)
        cClrBits = 1;
    else if (cClrBits <= 4)
        cClrBits = 4;
    else if (cClrBits <= 8)
        cClrBits = 8;
    else if (cClrBits <= 16)
        cClrBits = 16;
    else if (cClrBits <= 24)
        cClrBits = 24;
    else cClrBits = 32;

    // Allocate memory for the BITMAPINFO structure. (This structure
    // contains a BITMAPINFOHEADER structure and an array of RGBQUAD
    // data structures.)

    if (cClrBits != 24)
        pbmi = (PBITMAPINFO) LocalAlloc(LPTR,
        sizeof(BITMAPINFOHEADER) +
        sizeof(RGBQUAD) * (1<< cClrBits));

    // There is no RGBQUAD array for the 24-bit-per-pixel format.

    else
        pbmi = (PBITMAPINFO) LocalAlloc(LPTR,
        sizeof(BITMAPINFOHEADER));

    // Initialize the fields in the BITMAPINFO structure.

    pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    pbmi->bmiHeader.biWidth = bmp.bmWidth;
    pbmi->bmiHeader.biHeight = bmp.bmHeight;
    pbmi->bmiHeader.biPlanes = bmp.bmPlanes;
    pbmi->bmiHeader.biBitCount = bmp.bmBitsPixel;
    if (cClrBits < 24)
        pbmi->bmiHeader.biClrUsed = (1<<cClrBits);

    // If the bitmap is not compressed, set the BI_RGB flag.
    pbmi->bmiHeader.biCompression = BI_RGB;

    // Compute the number of bytes in the array of color
    // indices and store the result in biSizeImage.
    // For Windows NT, the width must be DWORD aligned unless
    // the bitmap is RLE compressed. This example shows this.
    // For Windows 95/98/Me, the width must be WORD aligned unless the
    // bitmap is RLE compressed.
    pbmi->bmiHeader.biSizeImage = ((pbmi->bmiHeader.biWidth * cClrBits +31) & ~31) /8
        * pbmi->bmiHeader.biHeight;
    // Set biClrImportant to 0, indicating that all of the
    // device colors are important.
    pbmi->bmiHeader.biClrImportant = 0;
    return pbmi;
}

void CreateBMPFile(HWND hwnd, LPTSTR pszFile, PBITMAPINFO pbi,
                                     HBITMAP hBMP, HDC hDC)
{
    HANDLE hf;                 // file handle
    BITMAPFILEHEADER hdr;       // bitmap file-header
    PBITMAPINFOHEADER pbih;     // bitmap info-header
    LPBYTE lpBits;              // memory pointer
    DWORD dwTotal;              // total count of bytes
    DWORD cb;                   // incremental count of bytes
    BYTE *hp;                   // byte pointer
    DWORD dwTmp;

    pbih = (PBITMAPINFOHEADER) pbi;
    lpBits = (LPBYTE) GlobalAlloc(GMEM_FIXED, pbih->biSizeImage);

    if (!lpBits)
        errhandler("GlobalAlloc");

    // Retrieve the color table (RGBQUAD array) and the bits
    // (array of palette indices) from the DIB.
    if (!GetDIBits(hDC, hBMP, 0, (WORD) pbih->biHeight, lpBits, pbi,
        DIB_RGB_COLORS))
    {
        errhandler("GetDIBits");
    }

    // Create the .BMP file.
    hf = CreateFile(pszFile,
        GENERIC_READ | GENERIC_WRITE,
        (DWORD) 0,
        NULL,
        CREATE_ALWAYS,
        FILE_ATTRIBUTE_NORMAL,
        (HANDLE) NULL);
    if (hf == INVALID_HANDLE_VALUE)
        errhandler("CreateFile");
    hdr.bfType = 0x4d42;        // 0x42 = "B" 0x4d = "M"
    // Compute the size of the entire file.
    hdr.bfSize = (DWORD) (sizeof(BITMAPFILEHEADER) +
        pbih->biSize + pbih->biClrUsed
        * sizeof(RGBQUAD) + pbih->biSizeImage);
    hdr.bfReserved1 = 0;
    hdr.bfReserved2 = 0;

    // Compute the offset to the array of color indices.
    hdr.bfOffBits = (DWORD) sizeof(BITMAPFILEHEADER) +
        pbih->biSize + pbih->biClrUsed
        * sizeof (RGBQUAD);

    // Copy the BITMAPFILEHEADER into the .BMP file.
    if (!WriteFile(hf, (LPVOID) &hdr, sizeof(BITMAPFILEHEADER),
        (LPDWORD) &dwTmp,  NULL))
    {
        errhandler("WriteFile");
    }

    // Copy the BITMAPINFOHEADER and RGBQUAD array into the file.
    if (!WriteFile(hf, (LPVOID) pbih, sizeof(BITMAPINFOHEADER)
        + pbih->biClrUsed * sizeof (RGBQUAD),
        (LPDWORD) &dwTmp, ( NULL)))
        errhandler("WriteFile");

    // Copy the array of color indices into the .BMP file.
    dwTotal = cb = pbih->biSizeImage;
    hp = lpBits;
    if (!WriteFile(hf, (LPSTR) hp, (int) cb, (LPDWORD) &dwTmp,NULL))
        errhandler("WriteFile");

    // Close the .BMP file.
    if (!CloseHandle(hf))
        errhandler("CloseHandle");

    // Free memory.
    GlobalFree((HGLOBAL)lpBits);
}

int main()
{
    int*Speicher;
    unsigned int sizeInBytes;
    BITMAP tagbmp;
	int y;
	int x;
	int Temp;
    BITMAPINFO *pbi;
    char *sSourceImagePath="C:\\Spiegeln.bmp";
    char *sDestinationImagePath="C:\\Spiegeln_Ergebnis.bmp";

    HBITMAP hBmp=(HBITMAP)LoadImage(NULL,sSourceImagePath,IMAGE_BITMAP,0,0,LR_LOADFROMFILE);
    if(!hBmp) {
        printf("Fehler beim Ladevorgang\n");
        return 1;
    }
    else {
        printf("Laden war erfolgreich\n");
    }

    GetObject(hBmp,sizeof(BITMAP),&tagbmp);

    sizeInBytes=tagbmp.bmWidthBytes*tagbmp.bmHeight;

    Speicher=malloc(sizeInBytes);
    if(!Speicher) {
        printf("malloc fehlgeschlagen! Kein Speicher mehr frei?\n");
        return 2;
    }

    GetBitmapBits(hBmp,sizeInBytes,(void*)Speicher);

    for(y=0;y<tagbmp.bmHeight;y++) {													  //gehe durch jede Zeile des Bildes
    for(x=0;x<tagbmp.bmWidth/2;x++) {													 //gehe in der aktuellen Zeile durch jeden Pixel bis zur Hälfte des Bildes (denn an dem Punkt hast du bereits alle Pixel der Zeile getauscht
    Temp=Speicher[y*tagbmp.bmWidth+x];													//- linken Pixel in eine temporäre int-Variable speichern
    Speicher[y*tagbmp.bmWidth+x]=Speicher[y*tagbmp.bmWidth-x-1];                //- den Wert vom rechten Pixel in den linken speichern
	Speicher[y*tagbmp.bmWidth-x-1]=Temp;									  //- den Wert der temporären Variable in den rechten Pixel speichern
  }
}

    SetBitmapBits(hBmp,sizeInBytes,(void*)Speicher);

    pbi=CreateBitmapInfoStruct(NULL,hBmp);
    CreateBMPFile(NULL,sDestinationImagePath,pbi,hBmp,GetDC(0));

    free(Speicher);
    DeleteObject(hBmp);
    printf("\nFertig! Ergebnisbild: %s\n",sDestinationImagePath);
    getchar();
}

Passt der Teil mit Spiegelung jetzt einigermaßen?
Grüße

[_matze]

Sieht gut aus, denke ich. Abgesehen vielleicht von der Einrückung, aber na ja. Klappt es denn oder kriegst du noch einen Absturz? Ich kann's grad ncht ausprobieren.

[Stuttgart]

Abend!

Ich bekomm leider immer noch eine Fehlermeldung. Es wird alles schön gestartet (Visual Studio gibt mir keine Fehlermeldung) und dann gibts die Fehlermeldung!

Grüße

[hustbaer]

Was denn, in der Fehlermeldung steht bloss "Fehlermeldung!" drin!?!
So eine Frechheit.
Normalerweise schreiben Entwickler was sinnvolles in so eine Fehlermeldung rein, womit man auch was anfangen kann. z.B. wenn man in einem Forum Hilfe sucht.
So eine Frechheit!!!einself

[Stuttgart]

Programm.exe hat ein Problem festgestellt und muss beendet werden.

<?xml version="1.0" encoding="UTF-16"?>
<DATABASE>
<EXE NAME="Programm.exe" FILTER="GRABMI_FILTER_PRIVACY">
<MATCHING_FILE NAME="Programm.exe" SIZE="30720" CHECKSUM="0xC5343328" MODULE_TYPE="WIN32" PE_CHECKSUM="0x10E5E" LINKER_VERSION="0x0" LINK_DATE="05/29/2009 21:19:13" UPTO_LINK_DATE="05/29/2009 21:19:13" />
</EXE>
<EXE NAME="kernel32.dll" FILTER="GRABMI_FILTER_THISFILEONLY">
<MATCHING_FILE NAME="kernel32.dll" SIZE="1063424" CHECKSUM="0x2E7379C2" BIN_FILE_VERSION="5.1.2600.5512" BIN_PRODUCT_VERSION="5.1.2600.5512" PRODUCT_VERSION="5.1.2600.5512" FILE_DESCRIPTION="Client-DLL für Windows NT-Basis-API" COMPANY_NAME="Microsoft Corporation" PRODUCT_NAME="Betriebssystem Microsoft Windows" FILE_VERSION="5.1.2600.5512 (xpsp.080413-2111)" ORIGINAL_FILENAME="kernel32" INTERNAL_NAME="kernel32" LEGAL_COPYRIGHT=" Microsoft Corporation. Alle Rechte vorbehalten." VERFILEDATEHI="0x0" VERFILEDATELO="0x0" VERFILEOS="0x40004" VERFILETYPE="0x2" MODULE_TYPE="WIN32" PE_CHECKSUM="0x106523" LINKER_VERSION="0x50001" UPTO_BIN_FILE_VERSION="5.1.2600.5512" UPTO_BIN_PRODUCT_VERSION="5.1.2600.5512" LINK_DATE="04/14/2008 02:21:52" UPTO_LINK_DATE="04/14/2008 02:21:52" VER_LANGUAGE="Deutsch (Deutschland) [0x407]" />
</EXE>
</DATABASE>

Das ist der Fehlerbericht den Windows gibt.
Meines Wissens ist Kernel32.dll für Vergabe im RAM und soweiter zuständig? Dann gibts da irgendwie Probleme aber wie kann man das lösen?

Grüße

[_matze]

Setz doch mal einen Haltepunkt, geh schrittweise durch das Programm und überprüfe den ganzen Ablauf Stück für Stück.

P.S.: Du erstellst doch hoffentlich die Debug-Version deines Projekts, ja (nicht Release)? Bei der Größe würde ich fast schätzen, dass es die Release-Version ist. Das ist fürs Debuggen natürlich schlecht, also stell es um, falls ich Recht habe...

[Stuttgart]

Hi,

ich hab mal ein Fehler gefunden:

ich bekomm bei der Zeile hier:

Speicher[y*tagbmp.bmWidth+x]=Speicher[y*tagbmp.bmWidth-x-1];

(Ist in der Spiegelung drin

Folgende Fehlermeldung beim Debuggen:

Unbehandelte Ausnahme bei 0x00411b8c in Programm.exe: 0xC0000005: Zugriffsverletzung beim Lesen an Position 0x008ffffc.

Mhm...allerdings versteh ich nicht warum das eine Zugriffsverletzung sein soll?

grüße

[_matze]

Welche Werte stehen zum Zeitpunkt der Zugriffsverletzung denn in x und y drin?

[_matze]

Ok, da ist noch ein Fehler drin. Das Spiegeln muss natürlich so aussehen:

for(y=0;y<tagbmp.bmHeight;y++) {                                                      //gehe durch jede Zeile des Bildes 
		for(x=0;x<tagbmp.bmWidth/2;x++) {                                                     //gehe in der aktuellen Zeile durch jeden Pixel bis zur Hälfte des Bildes (denn an dem Punkt hast du bereits alle Pixel der Zeile getauscht 
			Temp=Speicher[y*tagbmp.bmWidth+x];                                                    //- linken Pixel in eine temporäre int-Variable speichern 
			Speicher[y*tagbmp.bmWidth+x]=Speicher[y*tagbmp.bmWidth+tagbmp.bmWidth-x-1];                //- den Wert vom rechten Pixel in den linken speichern 
			Speicher[y*tagbmp.bmWidth+tagbmp.bmWidth-x-1]=Temp;                                      //- den Wert der temporären Variable in den rechten Pixel speichern 
		} 
	}

Sonst versucht man, vor dem Anfang von Speicher zu lesen (und zu schreiben). Aber so passt es.

Ich fänd es gut, wenn du jetzt mal das vertikale Spiegeln machst. Denkbar wäre z.B. eine Usereingabe (horizontal oder vertikal spiegeln, oder beides). Oder du erzeugst für diese 3 Fälle einfach 3 Ergebnis-Bilder.

[Stuttgart]

Hallo Matze,

achso! Oh mann wie kommt man aus sowas? Wie lang machst du C schon?

Das mit der Eingabe kann man doch mit scanf lösen oder?

Und das vertikale Spiegeln hab ich mir mal in Worten so überlegt:

1. gehe durch die Spalte des Bildes (Bedingung für eine Spalte x=konst. y++ )
2. gehe in der aktuellen Spalte durch jeden Pixel bis zur Hälfte des Bildes
3. untere Pixel in eine temporäre int-Variable speichern
4. den oberen auf den unteren speichern
4. den Wert der temporären Variable in den oberen Pixel speichern

Oder? So müsste das doch sein.

Grüße

[_matze]

Stuttgart schrieb:

Oh mann wie kommt man aus sowas?

Hmm, durch logisches Nachdenken?

Stuttgart schrieb:

Wie lang machst du C schon?

2 Jahre. Ich habe aber vorher auch in anderen Sprachen programmiert.

Stuttgart schrieb:

Das mit der Eingabe kann man doch mit scanf lösen oder?

Ja, zum Beispiel.

Stuttgart schrieb:

Und das vertikale Spiegeln hab ich mir mal in Worten so überlegt:

1. gehe durch die Spalte des Bildes (Bedingung für eine Spalte x=konst. y++ )
2. gehe in der aktuellen Spalte durch jeden Pixel bis zur Hälfte des Bildes
3. untere Pixel in eine temporäre int-Variable speichern
4. den oberen auf den unteren speichern
4. den Wert der temporären Variable in den oberen Pixel speichern

Oder? So müsste das doch sein.

Ja, kommt hin. Präsentier dann ruhig mal dein Ergebnis, wenn du fertig bist.

[Stuttgart]

Hi Matze,

Also ich hab die oberen beiden Bedingungen vertauscht und hab beim Speicher [] als dann 1+y gemacht!

Visual Studio findet keinen Fehler aber es kommt wieder zu einem abrupten Ende.

[_matze]

Also ich will dir diesmal nicht schon wieder die Lösung vorkauen. Du willst ja (hoffentlich) auch was lernen. Wenn du die horizontale Spiegelung verstanden hast, dann kannst du auch ganz einfach die vertikale Spiegelung realisieren. Es wird dir also von großem Nutzen sein, wenn du den bisherigen Code mal schrittweise durchspielst (der Debugger hilft dir dabei mit Haltepunkten und schrittweiser Ausführung) und die Berechnungen nachvollziehst. Das solltest du unbedingt tun. Einfach mal 2 Minuten auf den Code zu starren, bringt dir vermutlich wenig...

Aber zumindest ein paar Tipps:

Stuttgart schrieb:

Also ich hab die oberen beiden Bedingungen vertauscht und hab beim Speicher [] als dann 1+y gemacht!

Wie kommst du auf +1? Erklär bitte mal, was du denkst, was du damit erreichst?

[quote="Stuttgart"]

for(x=0;x<tagbmp.bmWidth/2;x++) {
  for(y=0;y<tagbmp.bmHeight;y++) {

So sorgst du dafür, dass nur die Hälfte der Spalten abgearbeitet werden! Du willst aber jede Spalte bis zur Hälfte bearbeiten...

Stuttgart schrieb:

Visual Studio findet keinen Fehler aber es kommt wieder zu einem abrupten Ende.

Das ist eben der Unterschied zwischen einem syntakischen Fehler, den der Compiler sofort bemerkt (ähnlich einem Rechtschreibfehler), und einem semantischen Fehler, der in der Regel viel schlimmer und viel schwerer zu finden ist (auch ohne Rechtschreibfehler kann man Blödsinn schreiben ).

Übrigens: poste bitte jedesmal die Fehlermeldung mit, auch wenn ich mir die Ursache diesmal denken kann (du überschreitest wieder Feldgrenzen).

[Stuttgart]

Da hast du allerdings recht! Aber was mir jetzt aufgefallen ist. Ich darf nie nur das eine Problem anschauen und es immer übertragen sondern des ganze Programm komplett betrachten. Und dann muss es natürlich heißen:

for(x=0;x<tagbmp.bmWidth;x++) {
  for(y=0;y<tagbmp.bmHeight/2;y++) {

So wird über gesamt x die Spalten bis zur Hälfte "angefahren". Und das reicht ja!

Und das +1 meinte ich weil wir ja jetzt nicht mehr "linke" und "rechte" Pixel vertauschen sondern "oben" und "unten". Und als oberen pixel sage ich der hat die Y-Koordinate 1+y und als x-Wert x und der untere pixel eben nur y und x.

Liebe Grüße

[_matze]

Der erste Pixel in Zeile 0, Spalte 0 hat die Koordinaten 0,0. Wenn du da nochmal +1 rechnest, gehst du in der Zeile einen nach rechts, d.h. du würdest das Bild um 1px nach rechts verschieben. Ist ja nicht in deinem Sinne...

Zur Fehlersuche: bitte rechne mal nach, welche Werte (Indizes für Speicher) du berechnest, wenn die Schleifen im letzten Durchlauf sind, also x=maximale Breite-1 und y=maximale Höhe-1 sind. Bedenke: der höchste, gültige Index für Speicher ist Breite*Höhe.

EDIT: Die Schleifenköpfe stimmen jetzt aber.

[Stuttgart]

Servus Matze,

for(x=0;x<tagbmp.bmWidth;x++) {                         
        }
    }

Stimmt es so? Bekomm genau die von dir beschriebene Fehlermeldung! Und das mit dem Nachrechnen hab ich eigentlich so verstanden, dass es halt maximal Höhe*Breite sein kann und somit ja des 1+ sinnlos.
Ich weiß nur nicht wie ich die oberen Pixel auswählen kann. In einer Zeile hab ichs jetzt verstanden aber wie geht das in einer Spale? 1-y? (Siehe C-Code oben)

Grüße