Danke für die klasse Zusammenarbeit!

[_matze]

Also ich benutze den Typ IplImage aus der OpenCV, aber du kannst auch mit WinAPI-Funktionen arbeiten. Woran ich mich spontan noch erinnere (alles ohne Gewähr ): wenn du ein Bitmap (Stichwort HBITMAP, guck mal nach LoadBitmap oder LoadImage) geladen hast, kannst du, glaube ich, mit GetBitmapBits direkt auf die Bilddaten zugreifen. Da liegt dein 2D-Bild dann hintereinander im eindimensionalen Speicher, so dass du eine Position x,y mit y*breite+x ansteuern kannst. Zu dem Zweck kannst du dir eine kleine Funktion oder ein Makro basteln. Das Spiegeln ist dir dann ja klar. Einfach Pixel links und rechts bzw. oben und unten tauschen.

[Stuttgart]

Guten Morgen!

also Leute ich sag euch ganz ehrlich: Ich habe grade keinen Durchblick mehr

Aber zu erst nochmal etwas anderes:
Ich glaube es gab ein Missverständnis! Ich schreibe dieses Programm in Microsoft Visual C++ 2005 Express Edition ABER in C und nicht in C++ . In C++ kenne ich auch diesen Weg des Bildaufrufes aber in "reinem" C ist alles ja sehr maschinennah.

Oder funktioniert es dort genau gleich und ich bin einfach zu blöd? :p

Also machts gut!

[_matze]

Es gab kein Missverständnis. Die WinAPI-Funktionen haben alle C-Interface, da brauchst du nix C++-spezifisches zu verwenden (wenn du nur Standard-ANSI-C nutzen willst, also komplett ohne Windows-Funktionen, ist das natürlich was anderes). Mein Vorschlag wäre, mal deinen bisherigen Stand zu posten. Dann kann man auch leichter helfen.

[Stuttgart]

Hallo Matze,

danke für deine Antwort! Das mit dem C-Interface wusste ich nicht... aber ich weiß so vieles nicht

Also ich post euch mal wie weit ich bin^^ (Ist ein Gemisch aus C und Text :-))

/* Datei: Spiegeln.c */
#include<stdio.h>
#include<math.h> /*enthält mathematische Formeln */

int main (void)

{

int d /* Abstand als integer Zahl Local Var. /
int x / X-Koordinate als integer Zahl Local Var. /
int y / Y-Koordinate als integer Zahl Local Var.*/
/* man muss hier noch die Breite des Bildes also d abfragen */

{
do
{ /* */
while d>0

for (d=0)
{/* eine Reihe nach unten und dann wieder do-while schleife*/

}

return 0;

}

Also Leute ich entschuldige mich schon mal hier für meine Unfähigkeit
Aber ich hoffe ihr nehmt es mir nicht übel und helft mir. Ich hab noch nicht so lang C.

Grüße

[Ivo]

Hast Du den Code 1:1 geposted? Sagt Dir das Wort Semikolon etwas?
Ansonsten sind Code Tags nicht schlecht und Selbsterniedrigung

stuttgart schrieb:

ich entschuldige mich schon mal hier für meine Unfähigkeit

bringt Dich auch nicht weiter.

[_matze]

Ich habe dir ja ein paar Funktionsnamen genannt. Mach dich mal in der Richtung schlau (Google, msdn.com, das Forum hier; man findet in kurzer Zeit jede Menge zum Thema...). Ein Anfang wäre, mal eine Bitmap-Datei zu laden. Dann kannst du sehen, wie du auf die Bilddaten zugreifen kannst. Und so kannst du dich Stück für Stück an die Lösung herantasten. Bei Teilproblemen melde dich einfach.

Ich habe, wie gesagt, auch nicht viel Erfahrung damit, da ich OpenCV benutze, und kann (und da so jeder Lerneffekt fehlen würden, will) dir nicht aus dem Stehgreif eine komplette Lösung posten.

[Stuttgart]

Hallo Leute,

ich meld mich mal wieder

War mehr oder weniger erfolgreich. Hab auf der Suche nach den Begriffen (Nochmal Danke an Matze) einige ganz coole Programme entdeckt!
Am eigentlichen Problem bin ich leider nicht wirklich weiter gekommen.

Ich denke dies hier wird der Knackpunkt sein: (Hab es mal probiert aber es klappt nicht wirklich:

#inlude<stdio.h>

int main(void)

{

HBITMAP hBmp =
(HBITMAP)LoadImage(NULL,"Spiegeln.bmp",IMAGE_BITMAP,0,0,LR_LOADFROMFILE);

return 0;

}

Grüße aus Stuttgart

[_matze]

Stuttgart schrieb:

Hab es mal probiert aber es klappt nicht wirklich:

Du musst dir angewöhnen, sowas besser zu beschreiben. Was klappt nicht und wie äußert sich das (Compiler- oder Linker-Fehler, oder zur Runtime)? Kommt eine Fehlermeldung? Wenn ja, welche (genauer Fehlertext und u.U. auch -code)?

In deinem Beispiel dürfte der Compiler vermutlich sagen, dass er die Funktion LoadImage nicht kennt, da du windows.h einbinden musst. Richtig?

Und "#inlude" ist sicher nur ein Tippfehler (warum auch immer du das abtippst, statt es per C&P zu machen ) und kommt in deinem Code nicht vor, oder?

[Stuttgart]

Abend Matze und natürlich Hallo an alle!

also zuerst mal zu dem Copy & Paste Thema. Ich programmier immer in Microsoft Visual 2008 und dann kopier ich den Quellcode nicht einfach hier rein sondern schreib ihn ohne noch mal in das Programm zu schauen hier hinein! Ich will da einfach was lernen :p . Aber ich poste ab sofort den "orginal" Quellcode und beschreib meine Fehler mehr.-> Versprochen

Also ich hab das jetzt so mal reingeschrieben:

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

int main(void)

{

HBITMAP hBmp =
(HBITMAP)LoadImage(NULL,"Spiegeln.bmp",IMAGE_BITMAP,0,0,LR_LOADFROMFILE);

return 0;

}

Der Tipp mit der Headerdatei war genau der Richtige! Weil woher soll das Programm die Funktion LoadImage kennen?
Ich bekomme keine Fehlermeldung und es scheint zu klappen.

Nun hab ich noch Fragen:

1. Woher kommt denn die, bis jetzt fiktive, Datei "Spiegeln.bmp" ? Müsste ich nicht eine Adresse wie C:\Dokumente und Einstellungen\.... angeben?

2. Wie geht es denn jetzt weiter? Jetzt hätte ich ja mal ein Bild "geladen".

Ich denke (war ja wieder ein Tipp von Matze ) es hat was damit zu tun:

GetBitmapBits("Spiegln.bmp",LONG cb, LPVOID lpvBit);

Die Funktion ist mir aber ganz unklar!

Herzliche Grüße

[hustbaer]

1. Jeder Prozess hat ein "current directory". Wenn kein absoluter Pfad angegeben wird, dann sucht das OS Dateien immer relativ zu diesem "current directory".

2. Wenn dir unklar ist wie man an die Bitmap Bits kommt, und wie du von dort weitermachen sollst, und wenn dir die MSDN nicht weiterhilft ... dann such dir halt Beispiele im Netz.
   Wenn man mit Google nichts brauchbares findet, ist Google Code Search meist einen Versuch Wert.

http://www.google.com/codesearch

[_matze]

Ob es klappt, siehst du am Rückgabewert von LoadImage (den solltest du prüfen). Da die Datei (noch) nicht existiert, wird NULL zurückgegeben. Das könntest du so machen:

HBITMAP hBmp = 
(HBITMAP)LoadImage(NULL,"Spiegeln.bmp",IMAGE_BITMAP,0,0,LR_LOADFROMFILE);
if(!hBmp) {  //wenn hBmp 0 ist
  //eventuell Fehlermeldung ausgeben
  return 0;  //Programm beenden
}

Einen Pfad kannst du angeben, wenn das nötig ist (s. hustbaers Post). Dabei musst du ihn so angeben: "C:\\myDir\\myFile.bmp". Doppelte Backslashes (Stichwort Escapesequenzen), sonst klappt es nicht.

Ich hab mir GetBitmapBits mal kurz angesehen. Das funktioniert so, dass du dir die Bilddaten in einen Puffer (den du selbst erzeugen musst, Stichwort malloc/free) kopierst (ich dachte, du kriegst einfach einen Pointer...). Dann führst du dein Spiegeln durch und kopierst den ganzen Quatsch wieder mit SetBitmapBits zurück.

Ich würde vorschlagen, unternimm mal zumindest folgende Schritte:
- BMP-Datei besorgen und mit LoadImage laden
- Puffer mit malloc erzeugen, der soviele Bytes hat, wie im BMP an Daten sind (Länge*Breite*4 Bytes pro Pixel). Da du nicht in den Farbkanälen rumpfuschen willst, kann das ruhig direkt ein int-Puffer sein.
- Bilddaten mit GetBitmapBits in deinen Puffer kopieren.

Das solltest du mit allen genannten Stichwörtern und entsprechendem googlen schaffen. Ansonsten meld dich.

[Stuttgart]

Guten Tag!

Also ich hab mal noch rumprobiert und hab mit Hilfe deiner Stichworte die Malloc-Geschichte auf jeden Fall verstanden!

So weit wir jetzt sind:

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

int main(void)

{

int*Speicher;

HBITMAP hBmp =
(HBITMAP)LoadImage(NULL,"C:\\Desktop\\Spiegeln.bmp",IMAGE_BITMAP,0,0,LR_LOADFROMFILE);

if(!hBmp)
{ printf("Fehler beim Ladevorgang\n");
}
else
{printf("Laden war erfolgreich\n");
}

Speicher=malloc(sizeof(int));

GetBitmapBits(HBITMAP hBmp,LONG cSize, void * lpvBits);

free(Speicher);

return 0;

}

Also das Laden der Bmp funktioniert ganz gut!

Fragen:

1. Muss ich bei sizeof(int) nicht irgendwie vorher sagen, dass des Bild eben 100 Pixel lang und 200 Pixel breit ist? Dazu habe ich leider nichts gefunden. Aber so gibt malloc ja nur für "int" Speicher frei. Oder war das richtig?

Da du nicht in den Farbkanälen rumpfuschen willst, kann das ruhig direkt ein int-Puffer sein.

2. GetBitmapBits Fehlermeldung:
Nicht genügend Argumente für Aufruf
Die Funktion habe ich aber vom Aufbau her auch noch nicht begriffen!

Grüße aus dem sonnigen Stuttgart

[_matze]

Bitte benutze in Zukunft cpp-Tags, um deinen Code schön leserlich mit Syntaxhighlighting darzustellen. Dazu umschließt du deinen Code mit [cpp] und [/cpp].

Stuttgart schrieb:

Speicher=malloc(sizeof(int));

Hier reservierst du nur 4 Bytes (unter einem 32-Bit-OS). malloc nimmt einfach einen Zahlenwert, der die Anzahl an zu allozierenden Bytes darstellt. Wenn du also für jeden Pixel 4 Bytes anfordern willst, dann musst du einfach sizeof(int)*Breite*Höhe übergeben ("Speicher=malloc(sizeof(int)*width*height)").

Ich finde es sogar besser, wenn man hier 4 statt sizeof(int) übergibt (vielleicht in Form einer Präprozessor-Konstante oder in einem weiter fortgeschrittenen Programm als zuweisbaren Member einer Struktur oder Klasse). Vielleicht ändert sich sizeof(int) ja unter einem anderen OS/Compiler, du willst aber weiterhin 32 Bit pro Pixel verarbeiten. Aber egal...

Übrigens gut, dass du auch ans free gedacht hast. Sonst hättest du direkt ein Speicherleck...

Stuttgart schrieb:

2. GetBitmapBits Fehlermeldung:
Nicht genügend Argumente für Aufruf
Die Funktion habe ich aber vom Aufbau her auch noch nicht begriffen!

Du übergibst ja hier auch nix, das ist einfach der Kopf der Funktion aus der Hilfe kopiert. Also...

1. Parameter: Dein Bitmap-Handle, dass von LoadImage kommt.
2. Parameter: Anzahl zu kopierender Bytes (also hier wieder Breite*Höhe*4, eben soviel Speicher wie du angefordert hast und im Bitmap an Daten vorhanden ist).
3. Parameter: void-Pointer auf den Puffer, in den die Daten reinkopiert werden sollen. Speicher ist ein int-Pointer, der muss gecastet werden. Das wäre wohl "(void*)Speicher".

Wenn das ganze Vorgeplänkel dann passt, bist du kurz davor, endlich mal im Bildspeicher rumpfuschen zu können...

[Stuttgart]

Super vielen Dank für die schnelle Antwort!

Mein Problem ist noch, dass ich nicht weiß wie ich die Höhe und Breite des Bildes auslesen kann? Gibt es da sowas in C wie getimagesize() ?

Grüße

[_matze]

Stuttgart schrieb:

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

Nein! Du musst einen void-Pointer auf Speicher übergeben (also den int-Pointer Speicher nach void* casten). "void * Speicher" ist aber eine Deklaration! Die hat da nix verloren. Ich habe ja bereits geschrieben, dass das so aussehen muss:

(void*)Speicher

Ok, da ich sehe, dass das noch ewig dauern wird, bis du dich mal mit dem eigentlichen Problem (Spiegeln) beschäftigen kannst (da deine C-Kenntnisse noch recht bescheiden sind), habe ich mal schnell was zusammengebastelt. Dabei habe ich selbst mal wieder gemerkt, was für ein unheiliges Gefrickel Bitmaps mit WinAPI-Funktionen doch sind. Ich bin froh, dass das mit OpenCV+IPL (und vor allem dem vorzüglichen, firmeninternen Wrapper dafür) alles irgendwie besser geht. Der Code ist teilweise aus dem Internet, da ich für's Speichern (dafür sind die 2 großen Funktionen) spontan keinen Ansatz hatte. Überhaupt ist alles ziemlich gefrickelt, aber das soll dich nicht weiter stören.

Hier wird ein Bild C:\Spiegeln.bmp geladen. Dann wird eine blaue, vertikale Linie gezeichnet, um dir zu zeigen, wie du auf den Bildspeicher zugreifen musst. Da setzt du deine Spiegelung ein (ist mit einem dicken Kommentar markiert, unten in der main-Funktion). Am Ende wird das Bild in C:\Spiegeln_Ergebnis.bmp gespeichert. Die Dateinamen kannst du natürlich anpassen, das sind String-Literale, die am Anfang der main-Funktion deklariert werden.

So, dann spiegel mal, was das Zeug hält!

Übrigens ist mathematisch das Rotieren ja viel interessanter. Vielleicht kannst du dich ja im Anschluss auch mal daran versuchen, wenn dann noch Interesse besteht. Das Grundgerüst dazu hast du ja jetzt.

#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;
	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); 

	//!!!
	//Hier zwischen GetBitmapBits und SetBitmapBits kannst du deine Spiegelung vornehmen.
	//Ich habe mal exemplarisch einfach eine blaue Linie von Position 10,0 bis 10,[Höhe des Bildes] gezeichnet (die folgende for-Schleife).
	//Daran siehst du, dass es auch funktioniert. ;)
	//Zugriff auf einen Pixel x,y funktioniert mit Index y*tagbmp.bmWidth+x.
	//!!!

	for(y=0;y<tagbmp.bmHeight;y++) {
		Speicher[y*tagbmp.bmWidth+10]=0x000000ff;
	}

	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();
}

[Stuttgart]

Wow Matze, Ich danke dir von ganzem Herzen! Was das für eine Arbeit gewesen sein muss !

Und ja ... ich gebe es zu: Mit meiner C-Kenntniss kann ich nicht wirklich prahlen.

Also ich bin grad am Durchgehen des Quellcodes. Und was ich noch nicht ganz verstanden habe ist, wie ich dann wirklich ein Bild "spiegel". Ich versteh wie die blaue Linie zu stande kommt aber wie kann ich dann wirklich jedes einzelne Pixel spiegeln? Im Internet hab ich leider nix weiteres gefunden.

(Das mit (void*) Speicher hab ich übrigens jetzt verstanden)

Herzliche Grüße

[_matze]

Stuttgart schrieb:

Wow Matze, Ich danke dir von ganzem Herzen! Was das für eine Arbeit gewesen sein muss !

Geht so, wir reden von vielleicht 20 Minuten. Ich hab meine Ziele für heute locker erreicht (und überschritten), daher war das vertretbar.

Stuttgart schrieb:

Also ich bin grad am Durchgehen des Quellcodes. Und was ich noch nicht ganz verstanden habe ist, wie ich dann wirklich ein Bild "spiegel". Ich versteh wie die blaue Linie zu stande kommt aber wie kann ich dann wirklich jedes einzelne Pixel spiegeln? Im Internet hab ich leider nix weiteres gefunden.

Na ja, du musst einfach auf der Horizontalen Pixel 0 und Pixel [breite-1] tauschen. Dazu musst du natürlich eine temporäre Variable deklarieren, die einen der Werte speichert. Dann gehts weiter mit Pixel 1 und Pixel [breite-2] usw... Für die vertikale Spiegelung (so du sie denn vorhast) musst du das natürlich entsprechend umdrehen.

Pseudeocode:

for(x=0;x<breite/2;x++) {  //Breite sollte durch 2 teilbar sein
  temp=zeile[x];
  zeile[x]=zeile[breite-x-1];
  zeile[breite-x-1]=temp;
}

[Stuttgart]

Was würde ich ohne dich nur machen! Und wenn ich das schon hör

Geht so, wir reden von vielleicht 20 Minuten

! Da kann ich nur "Oha" sagen

Also ich mach mal auf die Suche wie man temporäre Variablen deklarieren kann.

[_matze]

Stuttgart schrieb:

Also ich mach mal auf die Suche wie man temporäre Variablen deklarieren kann.

Na wie normale Variablen auch! Das temporär bezieht sich nur auf die Anwendung, da gibts kein Schlüsselwort 'temporary' oder so.

int MyTempVar;

[Stuttgart]

Ja sorry matze

Also ich hab das mal probiert:

int MyTempVar; //Temporäre Variable
int x;         //Auswahl

for(x=0;x<width/2;x++) { //kennt er die "Variable" width oder muss man die  noch  auslesen?

  MyTempVar=zeile[x];    //Zeile[x] ist ja praktisch die Nummer! Muss ich da ein Array anlegen?
  zeile[x]=zeile[width-x-1];
  zeile[width-x-1]=MyTempVar;
}

Noch mal Danke für deine Bemühungen.
Ich kenn das aus anderen Erfahrungen, dass das ganz schön stressig sein kann wenn jemand es gar nicht versteht :p .

Also bis dann