Datei einlesen -> Matrix füllen

[Zakum]

Es ist mir sogar ein bisschen Peinlich, aber momentan scheitere ich an einer Aufgabe, die ich für relativ einfach erachtet habe:

Gegeben habe ich eine Datei, die nach eine bestimmsten Muster aufgebaut ist:

1 Zeile entspricht: 255 mal (Zahl, Tabulator) und 1 mal (Zahl, Zeilenumbruch)

und von diesen Zeilen hab ich 256 Stück.

255	255	255	249   ...

249	167	76	25   ...

165	17	0	0   ...

31	4	0	0   ...

...

Und das Ding will ich in eine 1d Matrix (passt der begriff Vektor? *grübel*) überführen.

(zur Übersichlichkeit: siehe nächsten Post)

[Zakum]

Nun habe ich mir folgendes Gedacht:

Ich gehe mit getc Zeile für Zeile, Buchstabe für Buchstabe durch, und fülle jedes Zeichen in eine Variable, bis ein Tabulator oder Zeilenumbruch kommt.

Sobald der Umbruch da ist, wird der Inhalt der Variable genommen, und in die entsprechende Zelle der Matrix gehaun. Anschließend die Variable geleert, und das Spiel geht von vorne los.

Leider bekomme ich zwei Warnungen und nach erfolgreichem compilieren und generieren mit gcc beium ausführen die Meldung: segmentation fault

Der Quelltext sieht so aus:

#include <stdio.h>


int main () {

	FILE *f1;

	f1=fopen("256*256.txt","r");

	int grauwert[256*256];

	int Xpos,Ypos,count;

	int i,j;

	char c[1],tmp[3];

	count=0;


	for(Ypos=1;Ypos<257;++Ypos) { 		

		for(Xpos=1;Xpos<257;++Xpos) {

			c[1]=getc(f1);

			if (c[1]!='\t') {

				count++;

				if (count==1) tmp[1]=c[1];

				else strcat(tmp,c);

			}

			else {

				grauwert[Ypos*256+Xpos]=tmp;

				count=0;


			}

		}

	}


	...

Momentan bin ich ziemlich verwirrt, da der gleiche Ansatz mir in Delphi bisher immer gelungen ist. :confused:

Weiß vlt. jemand, was ich falsch mache?

[Zakum]

Ok, ein Problem beseitigt, neues erscheint:

Fehler lag an der (ja, man glaubt es kaum ) Segmentierung...

bei einer 256*256 Matric kann ich nicht mit

for(Ypos=1;Ypos<257;++Ypos) {

befüllenn sondern natürlich

for(Ypos=0;Ypos<256;++Ypos) {

verwenden. Doch wenn ich nun testen will, ob die Matrix korrekt befüllt wurde, stelle ich fest:

Nein, da sind überall 0 drin

Ich versteh die Welt nicht mehr!

[Crush]

Dein Array enthält Integer-Werte und tmp ist ein Character-String. Du mußt beim Befüllen tmp in Interger konvertieren grauwert[Ypos*256+Xpos]=atoi(tmp); z.B.

tmp[1] und c[1] sind falsch, weil Du da wieder den gleichen Fehler machst: Der erste Eintrag ist 0 und außerdem sollte lieber der Zähler in tmp hochgezählt werden, damit die Zahlen (in Form von Buchstaben) korrekt aneinandergereiht werden.

Außerdem ist es recht unfein char-weise die Zahlen nach tmp rüberzuschaufeln. Dafür gibt es feinere Methoden. Z.B. über fgets(), strtok() strstr() und strcat() oder besser noch Strings, die sich dynamisch in der Größe anpassen, kann man das besser nachvollziehbar und flexibler machen.

[Zakum]

Mhh, mir ist gestern aufgefallen, wie ich das umgehe.

Atoi hat leider nicht geklappt, da ich mit C programmieren MUSS und atoi hat da leider versagt.

Ich bin jetzt soweit, dass ich über einen sehr unfeinen Trick (manuelles umrechnen von tmp in eine Zahl) die Daten in meine Matrix bekomme.

Allerdings bin ich jetzt einem mysteriösen Problem aufgessesen.

Das 0-te Array Element wird ganz brav befüllt. Der Zyklus wird wiederholt, und während das 1-te Element befüllt wird, überschreibt irgendetwas wieder das 0-te Element mit einer 9.

Der Rest des Arrays wird problemlos befüllt.

#include <stdio.h>


int main () {

	FILE *f1;

	f1=fopen("256*256.txt","r");

	int grauwert[256*256];

	int Xpos,Ypos,count,tmp_int,zahler;

	char c[1],tmp[3];

	count=0;

	Xpos=0;

//	Ypos=0;

	zahler=0;



	grauwert[0]=0;

	while (zahler<10/*256*256*/){

		printf("\nGrauwert/tmp_int: %u / %u\n",grauwert[0], tmp_int);

		c[1]=getc(f1);

		printf("\nwhilezahler= %u\n",zahler);		//Prüfe ob in While-Schleife 

		if (c[1]!='\t') {

			count++;

			tmp[count]=c[1];

			printf("tmp[1][2][3]= %c ",tmp[1]); printf("%c ",tmp[2]); printf("%c\n",tmp[3]);  //Prüfe was in tmp ist

		}

		else {

			tmp_int=(tmp[1]-'0')*100+(tmp[2]-'0')*10+tmp[3]-'0';

			tmp[1]=0; tmp[2]=0; tmp[3]=0;

			grauwert[zahler]=tmp_int;

		    printf("\nGrauwert/tmp_int: %u / %u\n",grauwert[0], tmp_int);		  //Prüfe ab welchem Durchgang grauwert[0]=9 ist

		    printf("\nelsezahler %u\n",zahler);									//Prüfe ob in Else

			count=0;

			++zahler;

		}

   }







	/*for(Ypos=0;Ypos<5;++Ypos) { 		

		for(Xpos=0;Xpos<5;++Xpos) {

			if (Xpos!=4) printf("%d ", grauwert[Ypos*256+Xpos]);

			else printf("%d\n", grauwert[Ypos*256+Xpos]);

			}

	}*/

	for (Xpos=0;Xpos<10;++Xpos)printf("%d ",grauwert[Xpos]);

	return 0;


}

Ich weiß nicht, wird das 0-te Element eines Arrays eventuel dafür verwendet, dass das "System" (?) irgendwas speichert. Wäre mir neu.

[Klotzkopp]

Atoi hat leider nicht geklappt, da ich mit C programmieren MUSS und atoi hat da leider versagt.

atoi ist C. Deklariert wird die Funktion in <stdlib.h>. Wenn das bei dir nicht funktioniert, machst du etwas falsch. Was du falsch machst, kann man wegen der unzureichenden Fehlerbeschreibung ("hat leider versagt") nicht feststellen.

Ich weiß nicht, wird das 0-te Element eines Arrays eventuel dafür verwendet, dass das "System" (?) irgendwas speichert. Wäre mir neu.

Das Problem ist, dass du - obwohl du bereits auf diesen Fehler hingewiesen wurdest - immer noch ungültige Indizes beim Zugriff auf die Arrays c und tmp benutzt.

Nochmal ganz deutlich: Der erlaubte Index für tmp geht von 0 bis 2. Der einzige erlaubte Index für c ist 0.

Du darfst nicht auf c[1] zugreifen. Du darfst nicht auf tmp[3] zugreifen.

Was du da machst, erzeugt undefiniertes Verhalten, da kann alles passieren. Hier ist es vermutlich so, dass du dir mit den ungültigen Zugriffen die Werte der übrigen Variablen zerlegst.

[Crush]

Ich dachte immer, daß das Array-Verhalten in C und Delphi gleich wären. Ist das denn nicht so? Es hieß ja, daß das gleiche Programm in Delphi funktioniert hätte. Warum dann nicht gleich den Code 1:1 umsetzen? (Vielleicht würde es auch helfen, den Delphi-Code zu posten)

[Zakum]

*arg* Mea culpa! Du hast natürlich völlig recht @Klotzkopp.

Danke, daran lags auch.

Hatte den Inhalt von Crushs post wohl nur zur Hälfte realisiert!

Muss mal schaun, atoi hatte nichts in den Integer geschrieben, ich gugg mal was da los war.

@Crush: Nun Delphi hat im ggs zu C sehr angenehme Strings, die gerne auch dynamisch sein können. Außerdem ist die Indizierung der Arrays etwas anders...

Beginnt z.B. mit 1

Im Allgemeinen aber schon intersannt! Bis auf das 0-te Element hatte alles wie am Schnürchen geklappt, und das trotz völlig falscher Indizierung. :eek

Nochmal danke euch beiden, ich wär am Ende noch völlig verzweifelt!

[Crush]

Außerdem ist die Indizierung der Arrays etwas anders... Beginnt z.B. mit 1

Ganz sicher? Das mit der 1 scheint nur bei einer bestimmten Art der Deklaration wie Array[1..10] z.B. zu stimmen. Ansonsten beginnen die wohl auch bei 0.

[Pointerman]

Moin!

@Zakum

Da in Deinem Quellcode etwas von Grauwert steht wollte ich mal fragen, ob dieser Thread im Zusammenhang mit Deinem anderen Projekt (Objekterkennung/Bildverarbeitung) steht.

Wenn ja, geht es gleich weiter mit den Fragen:

- Willst Du so die Objekte einlesen, die erkannt werden sollen?

- Wenn ja, warum öffnest Du die Bilder dann nicht in ImageJ (mit dem Du ja auch arbeitest), wandelst sie in 8Bit Graustufen-Bilder um und speicherst sie als "Raw Data"? Dann kannst Du die Werte einfach Byte für Byte (entsprechend Pixel für Pixel) einlesen und musst Dich nicht um die Umwandlung kümmern.