Ein- und Auslesen von Dateien



  • Hallo zusammen,

    ich habe hier ein "kleines" Problem. Und zwar progge ich unter Fedorra 7 in Eclipse, weil es sein muss, naja 😉 Zumindest, kann man das Projekt in zwei Teile Unterteilen, im ersten Teil werden Bilder einer Kamera aufgenommen und einfach gespeichert.

    Das Problem liegt aber im zweiten Teil, der Verarbeitung und ich hoffe wirklich sehr, dass ihr mir helfen könnt, weil ich bin mit meinem Latein wirklich am Ende.

    Da ich davon ausgehe, dass der Fehler schon früher auftritt poste ich mal ich mal den ganzen Code für den zweiten Teil:

    (Variablendeklaration habe ich TEILWEISE weggelassen!)

    int main(void)
    {
    	/* create a new polynom */
    	SENSOR_createpolynom(&stCurrentSensor);
    	getchar();
    	/* import a polynom */
    	SENSOR_importPolynomCSV(&stCurrentSensor, impolynom);
    
    	getchar();
    	/* calculate the failure */
    	for (f=0; f<=slFrameSize*3; f+=3)
    	{
    			tmp = (impolynom[f]*data[g]*data[g]) + (impolynom[f+1]*data[g]) + impolynom[f+2];
    			data[g] = data[g] - tmp;
    			g++;
    	}
    
    	SENSOR_exportPolyCSV(&stCurrentSensor,data,2);
    
    	free(data);
    //	free(impolynom);
    	printf("ENDE!");
    	return EXIT_SUCCESS;
    }
    
    int SENSOR_createpolynom (struct stSensorConfig *stCurrentSensor)
    {
    	int slFrameSize = (stCurrentSensor->usResX-2)*stCurrentSensor->usResY; // Breite x Höhe = Gesamtpixelanzahl
    	int data_pairs = 21; // Anzahl der einzulesenden Datein
    
    	// VARIABLEN POINTER:
    	int slCamCount = 0;
    	char scLogTxt[64];
    	float **createpolynom;
    	float *polynom;
    
    	// IMPORT DATEIEN:
    	double height_fix[22]; // Speichern von fixen Höheninformationen (500 --> 1500)
    	int fiftysteps=500; // benötigt für fixe Höhe (500 --> 1500)
    	int fiftysteps_i; // zählt von 1 --> data_pairs damit die fixen Höhen gespeichert werden
    
    	// KLEINSTE QUADRATE METHODE:
    	int poly_degree = 2; //Grad des Polynoms
    	int poly_degree_plus = poly_degree + 1; // m is degree of approximation + 1 --> m = 3; m1 = 2
    	double height_dyn[22]; // Speichern der jeweiligen Höheninformation
    	double temp_all[300]; // Speichert alle Werte erstmal ab
    	int pixel; // damit jedes Pixel durchlaufen wird, 1 --> slFramesize
    	int height_dyn_i; // i für height_dyn 1 --> data_pairs
    	int save_i = 1;
    	int save_j = 2;
    	int temp_zero = 1;
    	int degree = 1; // bestimmt wie oft die eigentliche Prozedur durchläuft, unteranderen abhängig vom polydegree
    	int stop_degree; // wird entweder 1 oder -1 entscheidet ob degree weiter läuft
    	double summe[10]; // speichert die Summe ab
    	double w_summe; // wenn summe gebildet wird, wird die Wurzel genommen und hier gespeichert
    	double quadrat[10]; // speichert die Quadrate temporär zwischen
    	int i,j,L; // einfache Zählvariablen
    
        // AUSGABE KLEINSTE QUADRATE:
        int ausgabe_i = 1; // POTENZ VON X --> 1 = x0; 2 = x1 ...
        int ausgabe_j = 1;
        int position=0; // zählt von 1 --> slFramesize, damit Polynom wie eine Perlenkette aussieht und in Datei gespeichert werden kann
    
    	/* =====================================================================================================
    	 * Erzeugung der Pointer
    	 */
    
    	// -----------------------------------------------------------------------------
    	// Polynom 21 x 3072 --> für die Rohdaten
    	createpolynom = (float **)malloc((data_pairs) * sizeof(float));
    	if(createpolynom == NULL)
    	{
    		sprintf(scLogTxt, "--> No virtual memory\n");
    		printf(scLogTxt);
    		return FALSE;
    	}
    	for(; slCamCount < slFrameSize; slCamCount++)
    	{
    		createpolynom[slCamCount] = (float *)malloc(slFrameSize * sizeof(float));
    		if(createpolynom[slCamCount] == NULL)
    		{
    			sprintf(scLogTxt, "--> 1 No memory for row  %d\n", slCamCount);
    			printf(scLogTxt);
    			return FALSE;
    		}
    	}
    
    	// -----------------------------------------------------------------------------
    	// Polynom 1 x 9216 --> für EINE Dateien
    	polynom = (float *)malloc((slFrameSize*3) * sizeof(float));
    	if(polynom == NULL)
    	{
    		sprintf(scLogTxt, "--> No virtual memory\n");
    		printf(scLogTxt);
    		return FALSE;
    	}
    
    	/* =====================================================================================================
    	 * Einlesen der verschiedenen Höhendateien
    	 */
    
    	SENSOR_importPolynomCreate(stCurrentSensor,createpolynom); // speichert alle Werte von den Messungen in create polynom
    
    	for (fiftysteps_i=1; fiftysteps_i<=(data_pairs);fiftysteps_i++) // speichern der einzelnen Entfernungswerte in ein neues Array
    	{
    		height_fix[fiftysteps_i] = fiftysteps; // speichern der "Höhe" 500 --> 1500
    		fiftysteps+=50;
    	}
    
    	/* =====================================================================================================
    	 * Berechnung basiert auf der Methode der kleinsten Quadrate
    	 */
    
    	for (pixel=0; pixel<=slFrameSize; pixel+=1)	// Hier die eingelesenen Werte in die richtige Form für Polyfit bringen
    	{
    		for (height_dyn_i=0; height_dyn_i<=(data_pairs);height_dyn_i++) // --> 0 --> 21 (data_pairs)
    		{
    			height_dyn[height_dyn_i+1] = createpolynom[height_dyn_i][pixel]; // speichern der einzelnen Entfernungswerte in ein neues Array
    		}
    
    		        // ------------------- SPEICHERN VON X / Y -----------------------------------
    		        while ( save_i <= data_pairs ) // --> 1 -> 21
    		        {
    		            temp_all[(2*50)+save_i] = height_fix[save_i];
    		            temp_all[(1*50)+save_i] = 1.0;
    		            temp_all[((poly_degree_plus+1)*50)+save_i] = height_dyn[save_i];
    
    		            while ( save_j <= poly_degree ) // --> 2 -> 2
    		            {
    		                temp_all[((save_j+1)*50)+save_i] = temp_all[(save_j*50)+save_i] * temp_all[(2*50)+save_i];
    
    		                save_j++;
    		            }
    		            save_i++;
    		        }
    
    		        // ----------- füllt die Felder nach X/Y mit o bzw. 1 auf ---------------------
    		        i = data_pairs + 1;    // i = 22
    		        while ( i <= (data_pairs + poly_degree_plus) ) // --> 22 -> 24
    		        {
    		            while ( temp_zero <= ( poly_degree_plus + 1)) // --> 1 -> 4
    		            {
    		                temp_all[(temp_zero*50)+i] = 0.0;
    		                temp_zero++;
    		            }
    		            temp_all[((i-data_pairs)*50)+i] = 1.0;
    		            i++;
    		        }
    
    		        // ------------------- Berechnung für die Quotienten --------------------------
    		        while ( degree <= (poly_degree_plus + 1) )    // --> 1 -> 4
    		        {
    		        	// -- Abfrage für später (siehe "Bestimmung des jeweiligen Quotienten") --
    		            if (degree == (poly_degree_plus + 1) )
    		            {
    		                stop_degree = -1;
    		            } else {
    		                stop_degree = 1;
    		            }
    
    		            // -------------------- erzeugt die "Quadrate" ---------------------------
    		            // erzeugt die "Quadrate"
    		            if ( degree != 1 ) // beginnt erst bei degree = 2, weil die fixen Höhen beginnen erst im 100-Bereich
    		            {
    		                L = 1;
    		                while ( L <= (degree - 1) ) // 1 --> 22
    		                {
    		                    quadrat[L] = 0;
    		                    j = 1;
    		                    while ( j <= data_pairs ) // 1 --> 21
    		                    {
    		                        quadrat[L] = quadrat[L] + ( temp_all[(degree*50)+j] * temp_all[(L*50)+j]);
    		                        j++;
    		                    }
    		                    L++;
    		                }
    		            }
    
    		            i = 1;
    		            while ( i <= (data_pairs + poly_degree_plus)) // --> 1 --> 43
    		            {
    		                if ( degree != 1 )
    		                {
    		                    L = 1;
    		                    while ( L <= (degree - 1) )
    		                    {
    		                        temp_all[(degree*50)+i] = temp_all[(degree*50)+i] - ( quadrat[L] * temp_all[(L*50)+i] );
    		                        L++;
    		                    }
    		                } else {
    		                    break;
    		                }
    		                i++;
    		            }
    
    		            // ------------- Bestimmung des jeweiligen Quotienten -------------------------
    		            // wenn k = 4, wird nicht mehr ausgeführt:
    		            if ( stop_degree >= 1 )
    		            {
    		                summe[degree] = 0.;
    		                i = 1;
    		                while ( i <= data_pairs )
    		                {
    		                    summe[degree] = summe[degree] + (temp_all[(degree*50)+i] * temp_all[(degree*50)+i]);
    		                    i++;
    		                }
    		                w_summe = sqrt(summe[degree]);
    		                i = 1;
    		                while ( i <= (data_pairs+poly_degree_plus) )
    		                {
    		                    temp_all[(degree*50)+i] = temp_all[(degree*50)+i] / w_summe;
    		                    i++;
    		                }
    		            }
    		            degree++;
    		        }
    		        //----------------------- AUSGABE ---------------------------------------------
    		        if ( data_pairs != poly_degree_plus ) // normal case
    				{
    				  while ( ausgabe_i <= poly_degree_plus )
    				  {
    					polynom[position] = -temp_all[((poly_degree_plus+1)*50)+(data_pairs+ausgabe_i)];
    					ausgabe_i++;
    					position++;
    				  }
    				} else {                // case when data_pairs = m
    				  while ( ausgabe_j <= poly_degree_plus )
    				  {
    					polynom[ausgabe_j] = -temp_all[((poly_degree_plus+1)*50)+(data_pairs+ausgabe_j)];
    					ausgabe_j++;
    				  }
    				}
    	}
    	/*
    	 * Berechnung basiert auf der Methode der kleinsten Quadrate - ENDE
    	 *
    	 * -----------------------------------------------------------------------------
    	 */
    
    	printf("--> Polynom erfolgreich berechnet");
    //	for(slCamCount=0; slCamCount < data_pairs; slCamCount++)
    //	{
    //		free(createpolynom[slCamCount]);
    //	}
    //	free(createpolynom);
    
    	SENSOR_exportPolyCSV(stCurrentSensor,polynom,1);
    
    	free(polynom);
    	return TRUE;
    }
    
    int SENSOR_importPolynomCSV(struct stSensorConfig *stCurrentSensor, float *pflData)
    {
    	printf("Polynom import beginnt... ");
    	char scaFilename[128];
    	int i;
    
    	int slNumberPixel= (stCurrentSensor->usResX-2) * stCurrentSensor->usResY;
    
        char datei[30] = "polynom.csv";
    
    	FILE *fCSV = fopen(datei, "r");
    	if(fCSV==NULL)
    	{
    		printf("--> SENSOR_importCSV No file found");
    		return FALSE;
    	}
    	fseek(fCSV, 0, SEEK_END); // Position des Zeigers, von 0 --> Ende
    	unsigned long int slFilesize = ftell(fCSV); // aktuele Position des Zeigers --> Ende
    	rewind(fCSV); // Zeiger wieder auf anfang
    
    	//allocate memory for data
    	char *pcaBuffer = (char *)malloc(slNumberPixel); // Speicher reservieren
    	char *pcaElement;
    	char caSeperator[]=";"; //\x0a"; = ";\n"
    
    	int slColCount = 0;
    	int slRowCount = 0;
    
    	while(!feof(fCSV)) // solange nicht Datei am ende...
    	{
    		fgets(pcaBuffer, slFilesize, fCSV);
    		pcaElement = strtok(pcaBuffer, caSeperator);
    		while(pcaElement != NULL)
    		{
    			pflData[slColCount] = (float)atof(pcaElement);
    			slColCount++;
    			pcaElement = strtok(NULL, caSeperator);
    		}
    	}
    
    	fclose(fCSV);
    	free(pcaBuffer);
    
    	printf("... Polynom Import Erfolgreich!\n");
    
    	return TRUE;
    }
    

    Das Problem tritt auf in Zeile 7 der Main, wenn ich sage "importiere". Diese Funktion ging auch mal, nur jetzt nicht mehr 😞 und zwar bekomme ich in der SENSOR_importPolynomCSV in Zeile 42 einen Fehler: No source available for "_int_free()". Das komische ist aber wenn ich das free(pcaBuffer); auskommentiere kommt der gleiche Fehler.

    Ich hoffe ihr könnt mir helfen.

    Vielen Dank.


Log in to reply