matrix.h check

matrix.c angefangen
imageInput.c sollte gehen tests gehen nicht bei mi

imageInput.c

@@ -9,14 +9,172 @@
 // TODO Implementieren Sie geeignete Hilfsfunktionen für das Lesen der Bildserie aus einer Datei
 
 // TODO Vervollständigen Sie die Funktion readImages unter Benutzung Ihrer Hilfsfunktionen
+
+
+static int checkFileHeader(FILE *file)
+{
+    char buffer[BUFFER_SIZE];
+    int length = strlen(FILE_HEADER_STRING);
+
+    // Prüfen ob fread erfolgreich war
+    if (fread(buffer, sizeof(char), length, file) != length) {
+        return 0;  // Lesefehler
+    }
+
+    buffer[length] = '\0';
+
+    if (strcmp(buffer, FILE_HEADER_STRING) == 0) {
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+static int readDimensions(FILE *file, unsigned short * count, unsigned short *width, unsigned short *height)
+{
+    // Anzahl lesen
+    if (fread(count, sizeof(unsigned short), 1, file) != 1) {
+    return 0;
+    }
+    // Breite lesen
+    if (fread(width, sizeof(unsigned short), 1, file) != 1) {
+    return 0;
+    }
+    // Höhe lesen
+    if (fread(height, sizeof(unsigned short), 1, file) != 1) {
+    return 0;
+    }
+
+return 1; // Alles ok
+}
+
+static int readSingleImage(FILE *file, GrayScaleImage *image, unsigned char *label, unsigned short width, unsigned short height)
+{
+    // Schritt 1: Gesamtzahl Pixel berechnen
+    int totalPixels = width * height;
+
+    // Schritt 2: Speicher allokieren
+    image->buffer = (unsigned char *)malloc(totalPixels * sizeof(unsigned char));
+    if (image->buffer == NULL) {
+        return 0;  // Fehler: kein Speicher verfügbar
+    }
+
+    // Schritt 3: Breite und Höhe setzen
+    image->width = width;
+    image->height = height;
+
+    // Schritt 4: Pixel lesen
+    if (fread(image->buffer, sizeof(unsigned char), totalPixels, file) != totalPixels) {
+        free(image->buffer);  // Aufräumen!
+        return 0;  // Fehler beim Lesen
+    }
+
+    // Schritt 5: Label lesen
+    if (fread(label, sizeof(unsigned char), 1, file) != 1) {
+        free(image->buffer);  // Aufräumen!
+        return 0;  // Fehler beim Lesen
+    }
+
+    return 1;  // Erfolg!
+}
+
 GrayScaleImageSeries *readImages(const char *path)
 {
-    GrayScaleImageSeries *series = NULL;
+    // Schritt 1: Datei öffnen
-    
+    FILE *file = fopen(path, "rb");
+    if (file == NULL) {
+        return NULL;
+    }
+
+    // Schritt 2: Header prüfen
+    if (!checkFileHeader(file)) {
+        fclose(file);
+        return NULL;
+    }
+
+    // Schritt 3: Dimensionen lesen
+    unsigned short count, width, height;
+    if (!readDimensions(file, &count, &width, &height)) {
+        fclose(file);
+        return NULL;
+    }
+
+    // Schritt 4: Speicher für die Serie allokieren
+    GrayScaleImageSeries *series = (GrayScaleImageSeries *)malloc(sizeof(GrayScaleImageSeries));
+    if (series == NULL) {
+        fclose(file);
+        return NULL;
+    }
+
+    // Schritt 5: Speicher für das images-Array allokieren
+    series->images = (GrayScaleImage *)malloc(count * sizeof(GrayScaleImage));
+    if (series->images == NULL) {
+        free(series);
+        fclose(file);
+        return NULL;
+    }
+
+    // Schritt 6: Speicher für das labels-Array allokieren
+    series->labels = (unsigned char *)malloc(count * sizeof(unsigned char));
+    if (series->labels == NULL) {
+        free(series->images);
+        free(series);
+        fclose(file);
+        return NULL;
+    }
+
+    // Schritt 7: count setzen
+    series->count = count;
+
+    // Schritt 8: Alle Bilder in einer Schleife einlesen
+    for (int i = 0; i < count; i++) {
+        if (!readSingleImage(file, &series->images[i], &series->labels[i], width, height)) {
+            // Bei Fehler: Aufräumen!
+            for (int j = 0; j < i; j++) {
+                free(series->images[j].buffer);
+            }
+            free(series->images);
+            free(series->labels);
+            free(series);
+            fclose(file);
+            return NULL;
+        }
+    }
+
+    // Schritt 9: Datei schließen
+    fclose(file);
+
+    // Schritt 10: Fertige Serie zurückgeben
     return series;
 }
 
 // TODO Vervollständigen Sie die Funktion clearSeries, welche eine Bildserie vollständig aus dem Speicher freigibt
 void clearSeries(GrayScaleImageSeries *series)
 {
-}
+    // Schritt 0: Prüfen ob series überhaupt existiert
+    if (series == NULL) {
+        return;  // Nichts zu tun
+    }
+
+    // Schritt 1: Alle Pixel-Buffer freigeben (für jedes Bild)
+    if (series->images != NULL) {
+        for (int i = 0; i < series->count; i++) {
+            if (series->images[i].buffer != NULL) {
+                free(series->images[i].buffer);  // ← Buffer von Bild i freigeben
+            }
+        }
+    }
+
+    // Schritt 2: Das images-Array freigeben
+    if (series->images != NULL) {
+        free(series->images);
+    }
+
+    // Schritt 3: Das labels-Array freigeben
+    if (series->labels != NULL) {
+        free(series->labels);
+    }
+
+    // Schritt 4: Die Serie-Struktur selbst freigeben
+    free(series);
+}

imageInput.h

@@ -5,17 +5,17 @@ typedef unsigned char GrayScalePixelType;
 
 typedef struct
 {
-    GrayScalePixelType *buffer;
+    GrayScalePixelType *buffer; // Breite in Pixeln
-    unsigned int width;
+    unsigned int width;         // Höhe in Pixeln
-    unsigned int height;
+    unsigned int height;        // Die Pixelwerte (0-255)
-} GrayScaleImage;
+} GrayScaleImage;           // EIN Bild
 
 typedef struct
 {
-    GrayScaleImage *images;
+    GrayScaleImage *images;    // Array von Bildern
-    unsigned char *labels;
+    unsigned char *labels;     // Array von Labels (welche Ziffer?)
-    unsigned int count;
+    unsigned int count;        // Wie viele Bilder ?
-} GrayScaleImageSeries;
+} GrayScaleImageSeries;    // Sammlung der Bilder
 
 GrayScaleImageSeries *readImages(const char *path);
 void clearSeries(GrayScaleImageSeries *series);

matrix.c

@@ -1,17 +1,41 @@
 #include <stdlib.h>
 #include <string.h>
+#include <stdio.h>
 #include "matrix.h"
 
 // TODO Matrix-Funktionen implementieren
 
 Matrix createMatrix(unsigned int rows, unsigned int cols)
 {
-    
+    Matrix m;
+    m.rows = rows;
+    m.cols = cols;
+
+    m.buffer = (MatrixType*)malloc(sizeof(MatrixType) * rows * cols);
+
+    if (m.buffer == NULL){
+    fprintf(stderr, "Error: Memory allocation failed in createMatrix!.\n");
+    m.rows = 0;
+    m.cols = 0;
+    return m;
+    }
+for (unsigned int i = 0; i < rows * cols; i++){
+    m.buffer[i] = 0.0f;
+    }
+return m;
 }
 
+
 void clearMatrix(Matrix *matrix)
 {
-    
+    if (matrix == NULL || matrix->buffer == NULL) {
+        return;
+    }
+
+    // Alle Elemente auf 0 setzen
+    for (unsigned int i = 0; i < matrix->rows * matrix->cols; i++) {
+        matrix->buffer[i] = 0.0f;
+    }
 }
 
 void setMatrixAt(MatrixType value, Matrix matrix, unsigned int rowIdx, unsigned int colIdx)

matrix.h

@@ -6,7 +6,12 @@
 typedef float MatrixType;
 
 // TODO Matrixtyp definieren
+typedef struct{
+	unsigned int rows;
+	unsigned int cols;
+	MatrixType* buffer;
 
+}	Matrix;
 
 Matrix createMatrix(unsigned int rows, unsigned int cols);
 void clearMatrix(Matrix *matrix);