Ein- und Auslesen

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • Ein- und Auslesen

    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!)

    Quellcode

    1. int main(void)
    2. {
    3. /* create a new polynom */
    4. SENSOR_createpolynom(&stCurrentSensor);
    5. getchar();
    6. /* import a polynom */
    7. SENSOR_importPolynomCSV(&stCurrentSensor, impolynom);
    9. getchar();
    10. /* calculate the failure */
    11. for (f=0; f<=slFrameSize*3; f+=3)
    12. {
    13. tmp = (impolynom[f]*data[g]*data[g]) + (impolynom[f+1]*data[g]) + impolynom[f+2];
    14. data[g] = data[g] - tmp;
    15. g++;
    16. }
    18. SENSOR_exportPolyCSV(&stCurrentSensor,data,2);
    20. free(data);
    21. // free(impolynom);
    22. printf("ENDE!");
    23. return EXIT_SUCCESS;
    24. }
    26. int SENSOR_createpolynom (struct stSensorConfig *stCurrentSensor)
    27. {
    28. int slFrameSize = (stCurrentSensor->usResX-2)*stCurrentSensor->usResY; // Breite x Höhe = Gesamtpixelanzahl
    29. int data_pairs = 21; // Anzahl der einzulesenden Datein
    31. // VARIABLEN POINTER:
    32. int slCamCount = 0;
    33. char scLogTxt[64];
    34. float **createpolynom;
    35. float *polynom;
    37. // IMPORT DATEIEN:
    38. double height_fix[22]; // Speichern von fixen Höheninformationen (500 --> 1500)
    39. int fiftysteps=500; // benötigt für fixe Höhe (500 --> 1500)
    40. int fiftysteps_i; // zählt von 1 --> data_pairs damit die fixen Höhen gespeichert werden
    42. // KLEINSTE QUADRATE METHODE:
    43. int poly_degree = 2; //Grad des Polynoms
    44. int poly_degree_plus = poly_degree + 1; // m is degree of approximation + 1 --> m = 3; m1 = 2
    45. double height_dyn[22]; // Speichern der jeweiligen Höheninformation
    46. double temp_all[300]; // Speichert alle Werte erstmal ab
    47. int pixel; // damit jedes Pixel durchlaufen wird, 1 --> slFramesize
    48. int height_dyn_i; // i für height_dyn 1 --> data_pairs
    49. int save_i = 1;
    50. int save_j = 2;
    51. int temp_zero = 1;
    52. int degree = 1; // bestimmt wie oft die eigentliche Prozedur durchläuft, unteranderen abhängig vom polydegree
    53. int stop_degree; // wird entweder 1 oder -1 entscheidet ob degree weiter läuft
    54. double summe[10]; // speichert die Summe ab
    55. double w_summe; // wenn summe gebildet wird, wird die Wurzel genommen und hier gespeichert
    56. double quadrat[10]; // speichert die Quadrate temporär zwischen
    57. int i,j,L; // einfache Zählvariablen
    59. // AUSGABE KLEINSTE QUADRATE:
    60. int ausgabe_i = 1; // POTENZ VON X --> 1 = x0; 2 = x1 ...
    61. int ausgabe_j = 1;
    62. int position=0; // zählt von 1 --> slFramesize, damit Polynom wie eine Perlenkette aussieht und in Datei gespeichert werden kann
    64. /* =====================================================================================================
    65. * Erzeugung der Pointer
    66. */
    68. // -----------------------------------------------------------------------------
    69. // Polynom 21 x 3072 --> für die Rohdaten
    70. createpolynom = (float **)malloc((data_pairs) * sizeof(float));
    71. if(createpolynom == NULL)
    72. {
    73. sprintf(scLogTxt, "--> No virtual memory\n");
    74. printf(scLogTxt);
    75. return FALSE;
    76. }
    77. for(; slCamCount < slFrameSize; slCamCount++)
    78. {
    79. createpolynom[slCamCount] = (float *)malloc(slFrameSize * sizeof(float));
    80. if(createpolynom[slCamCount] == NULL)
    81. {
    82. sprintf(scLogTxt, "--> 1 No memory for row %d\n", slCamCount);
    83. printf(scLogTxt);
    84. return FALSE;
    85. }
    86. }
    88. // -----------------------------------------------------------------------------
    89. // Polynom 1 x 9216 --> für EINE Dateien
    90. polynom = (float *)malloc((slFrameSize*3) * sizeof(float));
    91. if(polynom == NULL)
    92. {
    93. sprintf(scLogTxt, "--> No virtual memory\n");
    94. printf(scLogTxt);
    95. return FALSE;
    96. }
    98. /* =====================================================================================================
    99. * Einlesen der verschiedenen Höhendateien
    100. */
    102. SENSOR_importPolynomCreate(stCurrentSensor,createpolynom); // speichert alle Werte von den Messungen in create polynom
    104. for (fiftysteps_i=1; fiftysteps_i<=(data_pairs);fiftysteps_i++) // speichern der einzelnen Entfernungswerte in ein neues Array
    105. {
    106. height_fix[fiftysteps_i] = fiftysteps; // speichern der "Höhe" 500 --> 1500
    107. fiftysteps+=50;
    108. }
    Alles anzeigen

  • Quellcode

    1. /* =====================================================================================================
    2. * Berechnung basiert auf der Methode der kleinsten Quadrate
    3. */
    5. for (pixel=0; pixel<=slFrameSize; pixel+=1) // Hier die eingelesenen Werte in die richtige Form für Polyfit bringen
    6. {
    7. for (height_dyn_i=0; height_dyn_i<=(data_pairs);height_dyn_i++) // --> 0 --> 21 (data_pairs)
    8. {
    9. height_dyn[height_dyn_i+1] = createpolynom[height_dyn_i][pixel]; // speichern der einzelnen Entfernungswerte in ein neues Array
    10. }
    12. // ------------------- SPEICHERN VON X / Y -----------------------------------
    13. while ( save_i <= data_pairs ) // --> 1 -> 21
    14. {
    15. temp_all[(2*50)+save_i] = height_fix[save_i];
    16. temp_all[(1*50)+save_i] = 1.0;
    17. temp_all[((poly_degree_plus+1)*50)+save_i] = height_dyn[save_i];
    19. while ( save_j <= poly_degree ) // --> 2 -> 2
    20. {
    21. temp_all[((save_j+1)*50)+save_i] = temp_all[(save_j*50)+save_i] * temp_all[(2*50)+save_i];
    23. save_j++;
    24. }
    25. save_i++;
    26. }
    28. // ----------- füllt die Felder nach X/Y mit o bzw. 1 auf ---------------------
    29. i = data_pairs + 1; // i = 22
    30. while ( i <= (data_pairs + poly_degree_plus) ) // --> 22 -> 24
    31. {
    32. while ( temp_zero <= ( poly_degree_plus + 1)) // --> 1 -> 4
    33. {
    34. temp_all[(temp_zero*50)+i] = 0.0;
    35. temp_zero++;
    36. }
    37. temp_all[((i-data_pairs)*50)+i] = 1.0;
    38. i++;
    39. }
    41. // ------------------- Berechnung für die Quotienten --------------------------
    42. while ( degree <= (poly_degree_plus + 1) ) // --> 1 -> 4
    43. {
    44. // -- Abfrage für später (siehe "Bestimmung des jeweiligen Quotienten") --
    45. if (degree == (poly_degree_plus + 1) )
    46. {
    47. stop_degree = -1;
    48. } else {
    49. stop_degree = 1;
    50. }
    52. // -------------------- erzeugt die "Quadrate" ---------------------------
    53. // erzeugt die "Quadrate"
    54. if ( degree != 1 ) // beginnt erst bei degree = 2, weil die fixen Höhen beginnen erst im 100-Bereich
    55. {
    56. L = 1;
    57. while ( L <= (degree - 1) ) // 1 --> 22
    58. {
    59. quadrat[L] = 0;
    60. j = 1;
    61. while ( j <= data_pairs ) // 1 --> 21
    62. {
    63. quadrat[L] = quadrat[L] + ( temp_all[(degree*50)+j] * temp_all[(L*50)+j]);
    64. j++;
    65. }
    66. L++;
    67. }
    68. }
    70. i = 1;
    71. while ( i <= (data_pairs + poly_degree_plus)) // --> 1 --> 43
    72. {
    73. if ( degree != 1 )
    74. {
    75. L = 1;
    76. while ( L <= (degree - 1) )
    77. {
    78. temp_all[(degree*50)+i] = temp_all[(degree*50)+i] - ( quadrat[L] * temp_all[(L*50)+i] );
    79. L++;
    80. }
    81. } else {
    82. break;
    83. }
    84. i++;
    85. }
    87. // ------------- Bestimmung des jeweiligen Quotienten -------------------------
    88. // wenn k = 4, wird nicht mehr ausgeführt:
    89. if ( stop_degree >= 1 )
    90. {
    91. summe[degree] = 0.;
    92. i = 1;
    93. while ( i <= data_pairs )
    94. {
    95. summe[degree] = summe[degree] + (temp_all[(degree*50)+i] * temp_all[(degree*50)+i]);
    96. i++;
    97. }
    98. w_summe = sqrt(summe[degree]);
    99. i = 1;
    100. while ( i <= (data_pairs+poly_degree_plus) )
    101. {
    102. temp_all[(degree*50)+i] = temp_all[(degree*50)+i] / w_summe;
    103. i++;
    104. }
    105. }
    106. degree++;
    107. }
    108. //----------------------- AUSGABE ---------------------------------------------
    109. if ( data_pairs != poly_degree_plus ) // normal case
    110. {
    111. while ( ausgabe_i <= poly_degree_plus )
    112. {
    113. polynom[position] = -temp_all[((poly_degree_plus+1)*50)+(data_pairs+ausgabe_i)];
    114. ausgabe_i++;
    115. position++;
    116. }
    117. } else { // case when data_pairs = m
    118. while ( ausgabe_j <= poly_degree_plus )
    119. {
    120. polynom[ausgabe_j] = -temp_all[((poly_degree_plus+1)*50)+(data_pairs+ausgabe_j)];
    121. ausgabe_j++;
    122. }
    123. }
    124. }
    125. /*
    126. * Berechnung basiert auf der Methode der kleinsten Quadrate - ENDE
    127. *
    128. * -----------------------------------------------------------------------------
    129. */
    131. printf("--> Polynom erfolgreich berechnet");
    132. // for(slCamCount=0; slCamCount < data_pairs; slCamCount++)
    133. // {
    134. // free(createpolynom[slCamCount]);
    135. // }
    136. // free(createpolynom);
    138. SENSOR_exportPolyCSV(stCurrentSensor,polynom,1);
    140. free(polynom);
    141. return TRUE;
    142. }
    147. int SENSOR_importPolynomCSV(struct stSensorConfig *stCurrentSensor, float *pflData)
    148. {
    149. printf("Polynom import beginnt... ");
    150. char scaFilename[128];
    151. int i;
    153. int slNumberPixel= (stCurrentSensor->usResX-2) * stCurrentSensor->usResY;
    155. char datei[30] = "polynom.csv";
    157. FILE *fCSV = fopen(datei, "r");
    158. if(fCSV==NULL)
    159. {
    160. printf("--> SENSOR_importCSV No file found");
    161. return FALSE;
    162. }
    163. fseek(fCSV, 0, SEEK_END); // Position des Zeigers, von 0 --> Ende
    164. unsigned long int slFilesize = ftell(fCSV); // aktuele Position des Zeigers --> Ende
    165. rewind(fCSV); // Zeiger wieder auf anfang
    167. //allocate memory for data
    168. char *pcaBuffer = (char *)malloc(slNumberPixel); // Speicher reservieren
    169. char *pcaElement;
    170. char caSeperator[]=";"; //\x0a"; = ";\n"
    172. int slColCount = 0;
    173. int slRowCount = 0;
    175. while(!feof(fCSV)) // solange nicht Datei am ende...
    176. {
    177. fgets(pcaBuffer, slFilesize, fCSV);
    178. pcaElement = strtok(pcaBuffer, caSeperator);
    179. while(pcaElement != NULL)
    180. {
    181. pflData[slColCount] = (float)atof(pcaElement);
    182. slColCount++;
    183. pcaElement = strtok(NULL, caSeperator);
    184. }
    185. }
    187. fclose(fCSV);
    188. free(pcaBuffer);
    190. printf("... Polynom Import Erfolgreich!\n");
    192. return TRUE;
    193. }
    Alles anzeigen

    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.