Kommentare

imageInput.c

@@ -43,11 +43,11 @@ static int readHeader(FILE *file, unsigned int *count, unsigned int *width, unsi
     *width = (unsigned int)temp_height;      // <-- Wegen des Test-Bugs: Gelesene HÖHE als BREITE zuweisen.
     *height = (unsigned int)temp_width;      // <-- Wegen des Test-Bugs: Gelesene BREITE als HÖHE zuweisen.
 
-    return 1;	// Ladevorgang erfolgreich.
+    return 1;	//gibt 1 bei Erfolg zurück
 }
 
 
-// Liest eine Serie von Graustufenbildern aus der angegebenen Datei.
+// Liest eine Serie von Graustufenbildern aus der angegebenen Datei und speichert sie als Series (images[i])
 GrayScaleImageSeries *readImages(const char *path)
 {
     GrayScaleImageSeries *series = NULL;	// Zeiger auf die gesamte Struktur. Standardmäßig NULL.
@@ -63,29 +63,28 @@ GrayScaleImageSeries *readImages(const char *path)
         return NULL; // Fehler beim Öffnen.
     }
 
-    if (!readHeader(file, &count, &width, &height))	// Lade den Header. Wenn fehlerhaft, aufräumen und abbrechen.
+    if (!readHeader(file, &count, &width, &height))	//überprüfung ob header eingelesen werden kann
-    {
+    {												// wenn nicht return NULL
         fclose(file);
         return NULL;
     }
 
-    // --- Dynamische Speicherreservierung (Heap) ---
+    // Dynamic Memory Allocation
-    // 1. Hauptstruktur reservieren
+    series = (GrayScaleImageSeries *)malloc(sizeof(GrayScaleImageSeries));		//reserviert Speicher
-    series = (GrayScaleImageSeries *)malloc(sizeof(GrayScaleImageSeries));
     if (series == NULL)
     {
-        fclose(file);
+        fclose(file);								//wenn kein Speicher -> NULL und Datei schließen
         return NULL;
     }
 
-    series->count = count;	// Anzahl der Bilder setzen.
+    series->count = count;	// Anzahl der Bilder setzen.(kommt von typedef GrayScaleImageSeries)
     series->images = NULL;	// Pointer vorläufig auf NULL setzen (für clearSeries im Fehlerfall).
     series->labels = NULL;
 
-    size_t num_pixels = (size_t)width * height;		// Gesamtanzahl der Pixel pro Bild berechnen.
+    size_t num_pixels = (size_t)width * height;		//berechnet die Anzahl der Pixel pro Bild (size_t weil pixelanzahl groß sein kann)
 
-    // 2. Array für die Bild-Strukturen (GrayScaleImage) reservieren.
+	//GrayScaleImage größe ist als typedef schon definiert.
-    series->images = (GrayScaleImage *)malloc(count * sizeof(GrayScaleImage));
+    series->images = (GrayScaleImage *)malloc(count * sizeof(GrayScaleImage));	//reserviert Speicher
     if (series->images == NULL)
     {
         clearSeries(series); // Im Fehlerfall: bisher reservierten Speicher freigeben.
@@ -97,7 +96,7 @@ GrayScaleImageSeries *readImages(const char *path)
     series->labels = (unsigned char *)malloc(count * sizeof(unsigned char));
     if (series->labels == NULL)
     {
-        clearSeries(series);
+        clearSeries(series);				//bei fehler: alles ferigeben und abbrechen
         fclose(file);
         return NULL;
     }
@@ -112,7 +111,7 @@ GrayScaleImageSeries *readImages(const char *path)
         series->images[i].buffer = (GrayScalePixelType *)malloc(num_pixels * sizeof(GrayScalePixelType));
         if (series->images[i].buffer == NULL)
         {
-            clearSeries(series);
+            clearSeries(series);		//wenn kein speicher: alles freigeben
             fclose(file);
             return NULL;
         }
@@ -120,7 +119,7 @@ GrayScaleImageSeries *readImages(const char *path)
         // Pixeldaten einlesen (num_pixels Elemente, jedes sizeof(GrayScalePixelType) groß).
         if (fread(series->images[i].buffer, sizeof(GrayScalePixelType), num_pixels, file) != num_pixels)
         {
-            clearSeries(series); // Fehler beim Lesen der Pixeldaten.
+            clearSeries(series);		//wenn nicht genau diese anzahl eingelesen werden konnte -> Abbruch
             fclose(file);
             return NULL;
         }
@@ -128,7 +127,7 @@ GrayScaleImageSeries *readImages(const char *path)
         // Label einlesen (ein einzelnes Byte).
         if (fread(&series->labels[i], sizeof(unsigned char), 1, file) != 1)
         {
-            clearSeries(series); // Fehler beim Lesen des Labels.
+            clearSeries(series);		//wenn nicht genau 1 byte eingelesen wurde -> Fehler
             fclose(file);
             return NULL;
         }
@@ -151,21 +150,21 @@ void clearSeries(GrayScaleImageSeries *series)
             {
                 if (series->images[i].buffer != NULL)		// Wenn ein Pixelpuffer reserviert wurde...
                 {
-                    free(series->images[i].buffer);			// ...diesen Pixelpuffer freigeben.
+                    free(series->images[i].buffer);			//gibt den Pixelbuffer des i-ten Bildes frei
-                    series->images[i].buffer = NULL;		// Pointer auf NULL setzen.
+                    series->images[i].buffer = NULL;
-				}
+				}		//setzt pointer auf NULL
-            }
+            }	//bis hier wurden nur pixelbuffer weggeräumt, aber nicht das (array) image selbst
 
-            free(series->images);		// Das Array der GrayScaleImage-Strukturen freigeben.
+            free(series->images);		//gesamte image block wird aus dem heap mit free freigegeben
             series->images = NULL;
         }
 
         if (series->labels != NULL)		// Prüfen, ob das Label-Array existiert.
         {
-            free(series->labels);		// Label-Speicher freigeben.
+            free(series->labels);		//sonst speicher für alle labels freigeben und pointer auf NULL setzen
             series->labels = NULL;
         }
 
-        free(series);		// Die Hauptstruktur GrayScaleImageSeries freigeben.
+        free(series);		//serie wird aus dem speicher freigegeben
     }
 }

matrix.c

@@ -3,7 +3,6 @@
 #include <string.h>
 #include "matrix.h"
 
-// Reserviert dynamischen Speicher für eine Matrix der Größe rows x cols und initialisiert sie mit Nullen.
 Matrix createMatrix(unsigned int rows, unsigned int cols)
 {
     // Struktur für die Rückgabe vorbereiten (wird im Fehlerfall zurückgegeben).
@@ -143,24 +142,23 @@ Matrix multiply(const Matrix matrix1, const Matrix matrix2)
         result.buffer = NULL;
         return result;
     }
-
+    else
-    // Ergebnis-Matrix hat Dimension: (matrix1.rows) x (matrix2.cols)
-    Matrix result = createMatrix(matrix1.rows, matrix2.cols);
-    if (result.buffer == NULL) return result; // Fehler bei Speicherreservierung.
-
-    // i: Reihe (Ergebnis), j: Spalte (Ergebnis), k: Innere Dimension (Summe)
-    for (unsigned int i = 0; i < result.rows; i++)
     {
-        for (unsigned int j = 0; j < result.cols; j++)
+        Matrix result = createMatrix(matrix1.rows, matrix2.cols);    //erzeugt matrix result
+        if (result.buffer == NULL) return result;        //result buffer auf NULL?
+
+        for (unsigned int i = 0; i < result.rows; i++)        //geht über alle zeilen der ergebnismatrix
         {
-            MatrixType summe = 0;
+            for (unsigned int j = 0; j < result.cols; j++)    //geht über alle spalten der ergebnismatrix
-            for (unsigned int k = 0; k < matrix1.cols; k++)
             {
-                // Element (i, j) = Summe von (matrix1[i, k] * matrix2[k, j])
+                MatrixType summe = 0;        //variable wo die matrix summe reingeladen wird
-                summe += getMatrixAt(matrix1, i, k) * getMatrixAt(matrix2, k, j);
+                for (unsigned int k = 0; k < matrix1.cols; k++)
+                {
+                    summe += getMatrixAt(matrix1, i, k) * getMatrixAt(matrix2, k, j);     //get(matrix;row;col) k=col1;row2
+                }
+                setMatrixAt(summe, result, i, j);    //summe wird in matrix result geladen
             }
-            setMatrixAt(summe, result, i, j);
         }
+        return result;
     }
-    return result;
 }

neuralNetwork.c

@@ -128,8 +128,8 @@ NeuralNetwork loadModel(const char *path)
     {
         if(checkFileHeader(file))
         {
-            unsigned int inputDimension = readDimension(file);
+            unsigned int inputDimension = readDimension(file); // übergabe in neuralnetworktests
-            unsigned int outputDimension = readDimension(file);
+            unsigned int outputDimension = readDimension(file); // übergabe in neuralnetworktests
 
             while(inputDimension > 0 && outputDimension > 0)
             {

neuralNetworkTests.c

@@ -19,8 +19,8 @@ static void prepareNeuralNetworkFile(const char *path, const NeuralNetwork nn)
     for (unsigned int i = 0; i < nn.numberOfLayers; ++i)
     {
         const Layer *lay = &nn.layers[i];
-        int inputDim  = (int)lay->weights.cols;
+        int inputDim  = (int)lay->weights.cols; // Die Anzahl der Spalten der Gewichtsmatrix ist immer gleich der Input-Dimension
-        int outputDim = (int)lay->weights.rows;
+        int outputDim = (int)lay->weights.rows; // Anzahl der Reihen der Gewichtsmatrix ist immer gleich der Output-Dimension
 
         // --- Spezifische Dimensions-Schreiblogik (Spiegelung der Leselogik) ---
         if (i == 0) {
@@ -37,9 +37,9 @@ static void prepareNeuralNetworkFile(const char *path, const NeuralNetwork nn)
 
         // --- Matrizen-Daten schreiben ---
         // Schreibe Gewichtsmatrix (Daten):
-        size_t weightCount = (size_t)lay->weights.rows * (size_t)lay->weights.cols;	//size_t unsignierter ganzzahltyp
+        size_t weightCount = (size_t)lay->weights.rows * (size_t)lay->weights.cols;	// Gesamtanzahl der Elemente in der Gewichtsmatrix berechnet (rows x cols) //size_t unsignierter ganzzahltyp
-        if (weightCount > 0 && lay->weights.buffer != NULL) {
+        if (weightCount > 0 && lay->weights.buffer != NULL) { //Prüfung ob dimensionen > 0 & Datenpuffer existiert
-            // Schreibe alle MatrixType-Elemente (z.B. floats) der Gewichte.
+            // Schreibe alle MatrixType-Elemente (z.B. floats) der Gewichte, Anzahl usw.
             fwrite(lay->weights.buffer, sizeof(MatrixType), weightCount, file);
         }