Danke für die klasse Zusammenarbeit!

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

_matze

Stuttgart schrieb:

du musst Nerven haben Mit jemandem über C reden der es grade mal fertig bekommt Visual Studio zu öffnen, musss echt hart sein

Ich staune über mich selbst...

Stuttgart schrieb:

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

Was denkst du, welche Pixel du hier adressierst? 1-[...]?? Ist dir nicht klar, dass du hier einen negativen Index errechnest, sobald y>0 ist? Was denkst du passiert, wenn du an Stelle Speicher[-1279] schreiben willst?

Stuttgart schrieb:

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?

Ich verstehe deinen Satz nicht. Das mit dem Nachrechnen habe ich so gemeint, dass du dir ein Blatt und einen Stift nimmst und das Ganze mal nachrechnest! Du sagtest doch, dass du eher der Mathematiker bist. Wenn du eine Wertetabelle erstellst, fütterst du auch eine Funktion mit Werten und rechnest die jeweiligen Ergebnisse aus. Genauso musst du das auch machen. Was passiert bei x=0 und y=0? Und was passiert bei x=1,y=0 oder x=0,y=1? Ich denke nämlich nicht, dass du diese Adressierung bis jetzt verstanden hast. Das beweisen dein letzter Code und deine Frage, wie du das in einer Spalte machen musst. Koordinaten beziehen sich immer auf Zeile und Spalte, und die Formel y*breite+x ist unter allen Umständen gültig und ohne Änderungen anwendbar, um zu Pixel x,y zu gelangen. Alles was du nun machen musst, ist zu entscheiden, welche Pixel du adressieren willst. Und das heißt, du musst nur gedanklich nachvollziehen, welche Pixel du beim Spiegeln tauschen musst.

Stuttgart

Hi Matze,

bin nur wieder aus dem Urlaub zurück gekehrt! Bin leider recht müde und schau mir deshalb die "Addressierung" erst Morgen an.
Das Horizontale habe ich eigentlich verstanden aber wie gesagt: Ich schaus mir morgen mal an und melde mich

Grüße aus Stuttgart

Stuttgart

Servus,

also ich hab mal, so wie du mir geraten hast, ein Blatt genommen und mir den Spiegelvorgang nochmal klargemacht.
Damit du siehst wo vielleicht mein Fehler ist oder ob es gar richtig ist, mache ich ein Beispiel:

Nehmen wir an mein Bild ist 10px hoch und 3px breit.

Und x bleibt ja gleich! Ist ja immer in der selben Spalte

**
Die Probe:**

Ich will, beim oben genannten Bild, den Pixel mit y=2 vertikal spiegeln.
Die Y-Koordinate des "entsprechenden oberen" Pixel wäre dann (10-2+1)=9!

Für y=3 ergibt sich 8 usw. das passt doch, oder?

Belehre mich eines Besseren, ich freu mich drauf

_matze

Tach!

Deine Überlegung ist ja eigentlich schon richtig. Nur, dass ich die Bezeichnungen ändern würde, denn wenn dein 'oberer Pixel' 9 ist, ist es ja eigentlich der untere Pixel (0,0 ist die obere, linke Ecke). Außerdem ist natürlich alles null-basiert (dein Pixel 1 ist also Pixel 0).

Pixel_y=Pixel_(Höhe-y-1)

und umgedreht:

Pixel_(Höhe-y-1)=Pixel_y

So tauschst du (bei Höhe 10) Pixel 0 mit Pixel 9, Pixel 1 mit Pixel 8 usw.

Vermisch das mit der genannten Adressierung y*Breite+x und zwei Schleifen, und schon hast du deine vertikale Spiegelung!

Stuttgart

Abend Matze!

Also hab mich jetzt nochmal versucht und ich habe das Gefühl, dass ich die "Addressierung" verstanden habe. Mir war nicht bewusst, dass es links oben anfängt! Danke!

Leider bringt Visual Studio eine Fehlermeldung mit Zugriffsverletzung. Schade

Grüße aus dem jetzt verregnetem Stuttgart

_matze

Speicher[(tagbmp.bmHeight-y+1)*tagbmp.bmWidth+tagbmp.bmWidth+x]

Das ist ja auch Quatsch. Damit kommst du aus dem gültigen Bereich raus (hatte ich auch nicht so geschrieben). Wenn y=0 ist, dann kommst du bei einer Höhe von 10 (also 0-9, maximale Zeile ist also 9) auf 10-0+1, also 11. Ist ein bisschen zuviel, oder? Außerdem kommst du, unabhängig von der Zeile auch in die falsche Spalte. Wenn beispielsweise x auf Maximum steht, addierst du nicht nur einmal x, sondern zweimal (+tagbmp.bmWidth+x).

Ersetze das mal an beiden Stellen durch das hier:

Speicher[(tagbmp.bmHeight-y-1)*tagbmp.bmWidth+x]

Macht mehr Sinn, denke ich. Klappt?

Stuttgart

Servus Matze!

Danke. Ich war mir eigentlich so sicher aber du hattest natürlich recht! Macht ja anders gar keinen Sinn! Aber das hab ich jetzt echt verstanden. Hab jetzt mal noch ein bisschen was gemacht:

Hinweis: Hab die Variable Spig oben deklariert.
Weiß nicht ob das elegant ist oder nicht! Was sagst du dazu?

Außerdem ist was ganz komisches passiert: Wenn ich ganz am Ende der Main ge hab dann schließt sich die Konsole nach der Eingabe gleich! Wenn ich ch() hab dann bleibt es wie gewünscht offen! Komisch oder?

Muss ich auch was machen, dass wenn man was anderes als 1/2 eingibt, dass es dann eine Fehlermeldung oder so gibt? Da komm ich noch nicht dahinter! Hast du da einen Tipp?

Grüße

_matze

Stuttgart schrieb:

Danke. Ich war mir eigentlich so sicher aber du hattest natürlich recht! Macht ja anders gar keinen Sinn! Aber das hab ich jetzt echt verstanden. Hab jetzt mal noch ein bisschen was gemacht:

Das heißt, das Spiegeln funktioniert jetzt?

Stuttgart schrieb:

Hinweis: Hab die Variable Spiegelung oben deklariert.
Weiß nicht ob das elegant ist oder nicht! Was sagst du dazu?

Globale Variablen sollte man eher vermeiden. Deklariere die Variable lieber am Anfang der main-Funktion.

Stuttgart schrieb:

Muss ich auch was machen, dass wenn man was anderes als 1/2 eingibt, dass es dann eine Fehlermeldung oder so gibt? Da komm ich noch nicht dahinter! Hast du da einen Tipp?

Da musst du die Eingabe in eine Schleife packen, die solange läuft, bis eine gültige Eingabe gemacht wurde. Eine do-while-Schleife eignet sich da am besten. Zusätzlich solltest du dem Benutzer noch eine dritte Eingabemöglichkeit, nämlich zum Abbruch, bieten.

Stuttgart

Abend Matze

Hab gerade noch den Teil mit dem Abbruch rein gebracht!

Passt also meiner Meinung nach alles. Funktioniert auch ganz gut!

Wenn du damit einverstanden bist

Hab danach noch ein paar Fragen wegen "Vereinfachung" an dich

Grüße

_matze

Schön, dass es klappt. Du solltest aber dringend mal an deiner Einrückung arbeiten. Das sollte alles schön strukturiert sein, so dass man Blockanfang und -ende auch erkennen kann.

http://de.wikipedia.org/wiki/Einrückungsstil