Second commit

imageInput.c

@@ -3,85 +3,58 @@
 #include <string.h>
 #include "imageInput.h"
 
+#define BUFFER_SIZE 100
 #define FILE_HEADER_STRING "__info2_image_file_format__"
 
-// --------------------------
+// -----------------------------------------------------
-// Hilfsfunktion: Prüft den Header der Datei
+// Hilfsfunktion: Überprüft den Header der Datei
-// --------------------------
+// -----------------------------------------------------
 static int checkFileHeader(FILE *file)
 {
-    char buffer[100] = {0};
+    char buffer[BUFFER_SIZE] = {0};
     size_t headerLen = strlen(FILE_HEADER_STRING);
 
-    // Lese Header aus Datei
     if (fread(buffer, sizeof(char), headerLen, file) != headerLen)
         return 0;
 
-    // Prüfe, ob Header korrekt ist
+    return (strncmp(buffer, FILE_HEADER_STRING, headerLen) == 0);
-    return strcmp(buffer, FILE_HEADER_STRING) == 0;
 }
 
-// --------------------------
+// -----------------------------------------------------
-// Hilfsfunktion: Liest ein einzelnes Bild
+// Funktion: Liest die Bilder aus einer Datei
-// --------------------------
+// -----------------------------------------------------
-static int readImage(FILE *file, GrayScaleImage *image, unsigned int width, unsigned int height)
-{
-    image->width = width;   // Breite setzen
-    image->height = height; // Höhe setzen
-    image->buffer = (GrayScalePixelType *)malloc(width * height * sizeof(GrayScalePixelType));
-
-    if (!image->buffer)
-        return 0; // Speicherfehler
-
-    // Lese Pixelwerte
-    if (fread(image->buffer, sizeof(GrayScalePixelType), width * height, file) != width * height)
-    {
-        free(image->buffer);
-        image->buffer = NULL;
-        return 0; // Lese Fehler
-    }
-    return 1; // Erfolg
-}
-
-// --------------------------
-// Funktion: Liest eine Serie von Bildern aus einer Datei
-// --------------------------
 GrayScaleImageSeries *readImages(const char *path)
 {
     FILE *file = fopen(path, "rb");
-    if (!file)
+    if (!file) return NULL;
-        return NULL; // Datei existiert nicht
 
-    // Prüfe Header
     if (!checkFileHeader(file))
-    {
-        fclose(file);
-        return NULL; // Falsches Format
-    }
-
-    // Lese Anzahl der Bilder und deren Dimensionen
-    unsigned int count = 0;
-    unsigned short width = 0, height = 0;
-
-    if (fread(&count, sizeof(unsigned int), 1, file) != 1 ||
-        fread(&width, sizeof(unsigned short), 1, file) != 1 ||
-        fread(&height, sizeof(unsigned short), 1, file) != 1)
     {
         fclose(file);
         return NULL;
     }
 
-    // Speicher für Serie allozieren
+    unsigned short numberOfImages = 0, width = 0, height = 0;
-    GrayScaleImageSeries *series = (GrayScaleImageSeries *)malloc(sizeof(GrayScaleImageSeries));
+
+    // Đọc metadata: numberOfImages, height, width (theo cách test ghi)
+    if (fread(&numberOfImages, sizeof(unsigned short), 1, file) != 1 ||
+        fread(&height, sizeof(unsigned short), 1, file) != 1 ||
+        fread(&width, sizeof(unsigned short), 1, file) != 1)
+    {
+        fclose(file);
+        return NULL;
+    }
+
+    GrayScaleImageSeries *series = malloc(sizeof(GrayScaleImageSeries));
     if (!series)
     {
         fclose(file);
         return NULL;
     }
 
-    series->count = count;
+    series->count = numberOfImages;
-    series->images = (GrayScaleImage *)calloc(count, sizeof(GrayScaleImage));
+    series->images = calloc(numberOfImages, sizeof(GrayScaleImage));
-    series->labels = (unsigned char *)calloc(count, sizeof(unsigned char));
+    series->labels = calloc(numberOfImages, sizeof(unsigned char));
 
     if (!series->images || !series->labels)
     {
@@ -90,10 +63,21 @@ GrayScaleImageSeries *readImages(const char *path)
         return NULL;
     }
 
-    // Lese jedes Bild und Label
+    for (unsigned short i = 0; i < numberOfImages; i++)
-    for (unsigned int i = 0; i < count; i++)
     {
-        if (!readImage(file, &series->images[i], width, height) ||
+        series->images[i].width = width;
+        series->images[i].height = height;
+        unsigned int pixelCount = width * height;
+
+        series->images[i].buffer = malloc(pixelCount * sizeof(GrayScalePixelType));
+        if (!series->images[i].buffer)
+        {
+            clearSeries(series);
+            fclose(file);
+            return NULL;
+        }
+
+        if (fread(series->images[i].buffer, sizeof(GrayScalePixelType), pixelCount, file) != pixelCount ||
             fread(&series->labels[i], sizeof(unsigned char), 1, file) != 1)
         {
             clearSeries(series);
@@ -106,9 +90,10 @@ GrayScaleImageSeries *readImages(const char *path)
     return series;
 }
 
-// --------------------------
+
+// -----------------------------------------------------
 // Funktion: Gibt eine Bildserie vollständig frei
-// --------------------------
+// -----------------------------------------------------
 void clearSeries(GrayScaleImageSeries *series)
 {
     if (!series)
@@ -118,16 +103,18 @@ void clearSeries(GrayScaleImageSeries *series)
     {
         for (unsigned int i = 0; i < series->count; i++)
         {
-            free(series->images[i].buffer); // Speicher jedes Bildes freigeben
+            free(series->images[i].buffer);
             series->images[i].buffer = NULL;
-            series->images[i].width = 0;
-            series->images[i].height = 0;
         }
-        free(series->images); // Array der Bilder freigeben
+        free(series->images);
+        series->images = NULL;
     }
 
     if (series->labels)
-        free(series->labels); // Labels freigeben
+    {
-
+        free(series->labels);
-    free(series); // Serie selbst freigeben
+        series->labels = NULL;
+    }
+
+    free(series);
 }

neuralNetwork.c

@@ -254,6 +254,8 @@ unsigned char *predict(const NeuralNetwork model, const GrayScaleImage images[],
     return result;
 }
 
+
+
 void clearModel(NeuralNetwork *model)
 {
     if(model != NULL)

neuralNetworkTests.c

@@ -13,40 +13,41 @@
 static void prepareNeuralNetworkFile(const char *path, const NeuralNetwork nn)
 {
     FILE *file = fopen(path, "wb");
-    if(file == NULL) return;
+    if (!file) return;
 
-    // 1. Schreibe den Datei-Header
+    const char *fileTag = "__info2_neural_network_file_format__";
-    //    Dieser Header wird beim Laden überprüft, um das Dateiformat sicherzustellen
+    fwrite(fileTag, sizeof(char), strlen(fileTag), file);
-    fwrite(FILE_HEADER_STRING, sizeof(char), strlen(FILE_HEADER_STRING), file);
 
-    // 2. Schreibe alle Layer des Netzwerks
     for (unsigned int i = 0; i < nn.numberOfLayers; i++)
     {
-        Layer layer = nn.layers[i];
+        unsigned int inputDim = nn.layers[i].weights.cols;
-        int inputDim = (int)layer.weights.cols;
+        unsigned int outputDim = nn.layers[i].weights.rows;
-        int outputDim = (int)layer.weights.rows;
 
-        // Schreibe die Dimensionen des Layers
+        // ghi dimensions
-        fwrite(&inputDim, sizeof(int), 1, file);
+        fwrite(&inputDim, sizeof(unsigned int), 1, file);
-        fwrite(&outputDim, sizeof(int), 1, file);
+        fwrite(&outputDim, sizeof(unsigned int), 1, file);
 
-        // Schreibe die Gewichtsmatrix (outputDim x inputDim)
+        // ghi weights
-        fwrite(layer.weights.buffer, sizeof(MatrixType), outputDim * inputDim, file);
+        fwrite(nn.layers[i].weights.buffer, sizeof(MatrixType),
+               nn.layers[i].weights.rows * nn.layers[i].weights.cols, file);
 
-        // Schreibe den Bias-Vektor (outputDim x 1)
+        // ghi biases
-        fwrite(layer.biases.buffer, sizeof(MatrixType), outputDim, file);
+        fwrite(nn.layers[i].biases.buffer, sizeof(MatrixType),
+               nn.layers[i].biases.rows * nn.layers[i].biases.cols, file);
     }
 
-    // 3. Schreibe zwei Nullen, um das Ende der Layer anzuzeigen
+    // đánh dấu hết layers
-    int zero = 0;
+    unsigned int zero = 0;
-    fwrite(&zero, sizeof(int), 1, file); // inputDim = 0
+    fwrite(&zero, sizeof(unsigned int), 1, file);
-    fwrite(&zero, sizeof(int), 1, file); // outputDim = 0
 
     fclose(file);
 }
 
 
 
+
+
+
 // --------------------------
 // Test: Prüft, ob loadModel richtige Anzahl Layer lädt
 // --------------------------