matrix.c unitTest PASS

imageInput.c

@@ -1,22 +1,96 @@
-#include <stdio.h>
+#include <stdio.h>
-#include <stdlib.h>
+#include <stdlib.h>
-#include <string.h>
+#include <string.h>
-#include "imageInput.h"
+#include "imageInput.h"
-
+
-#define BUFFER_SIZE 100
+#define BUFFER_SIZE 100
-#define FILE_HEADER_STRING "__info2_image_file_format__"
+#define FILE_HEADER_STRING "__info2_image_file_format__"
-
+
-// TODO Implementieren Sie geeignete Hilfsfunktionen für das Lesen der Bildserie aus einer Datei
+// 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
+// TODO Vervollständigen Sie die Funktion readImages unter Benutzung Ihrer Hilfsfunktionen
-GrayScaleImageSeries *readImages(const char *path)
+GrayScaleImageSeries *readImages(const char *path)
-{
+{
-    GrayScaleImageSeries *series = NULL;
+    // GrayScaleImageSeries *series = NULL;
-    
+    
-    return series;
+    // return series;
-}
+
-
+    FILE *file = fopen(path, "rb");
-// TODO Vervollständigen Sie die Funktion clearSeries, welche eine Bildserie vollständig aus dem Speicher freigibt
+    if (file == NULL) {
-void clearSeries(GrayScaleImageSeries *series)
+        return NULL;  // Datei existiert nicht oder konnte nicht geöffnet werden
-{
+    }
+
+    // Überprüfe den Dateitag
+    char fileTag[25];
+    fread(fileTag, sizeof(fileTag[0]), 24, file);
+    fileTag[24] = '\0';  // Null-Terminierung des Strings
+
+    if (strcmp(fileTag, "__info2_image_file_format__") != 0) {
+        fclose(file);
+        return NULL;  // Ungültiges Dateiformat
+    }
+
+    // Lese die Metadaten: Anzahl der Bilder, Breite und Höhe
+    unsigned short numberOfImages, width, height;
+    fread(&numberOfImages, sizeof(numberOfImages), 1, file);
+    fread(&width, sizeof(width), 1, file);
+    fread(&height, sizeof(height), 1, file);
+
+    // Speicher für die Bildserie und die Bilddaten allozieren
+    GrayScaleImageSeries *series = (GrayScaleImageSeries *)malloc(sizeof(GrayScaleImageSeries));
+    if (series == NULL) {
+        fclose(file);
+        return NULL;  // Speicher konnte nicht allokiert werden
+    }
+
+    series->count = numberOfImages;
+    series->images = (GrayScaleImage *)malloc(numberOfImages * sizeof(GrayScaleImage));
+    series->labels = (unsigned char *)malloc(numberOfImages * sizeof(unsigned char));
+
+    if (series->images == NULL || series->labels == NULL) {
+        free(series);
+        fclose(file);
+        return NULL;  // Speicher konnte nicht allokiert werden
+    }
+
+    // Lese die Bilddaten und die Labels
+    for (int i = 0; i < numberOfImages; i++) {
+        series->images[i].width = width;
+        series->images[i].height = height;
+        series->images[i].buffer = (GrayScalePixelType *)malloc(width * height * sizeof(GrayScalePixelType));
+
+        if (series->images[i].buffer == NULL) {
+            // Fehlerbehandlung: Speicher freigeben, wenn Allocation fehlschlägt
+            for (int j = 0; j < i; j++) 
+            {
+                free(series->images[j].buffer);
+            }
+            free(series->images);
+            free(series->labels);
+            free(series);
+            fclose(file);
+            return NULL;
+        }
+
+        // Lese die Pixel-Daten und das Label
+        fread(series->images[i].buffer, sizeof(GrayScalePixelType), width * height, file);
+        fread(&series->labels[i], sizeof(unsigned char), 1, file);
+    }
+
+    fclose(file);
+    return series;
+}
+
+// TODO Vervollständigen Sie die Funktion clearSeries, welche eine Bildserie vollständig aus dem Speicher freigibt
+void clearSeries(GrayScaleImageSeries *series)
+{
+    if (series == NULL) return;
+
+    for (int i = 0; i < series->count; i++) {
+        free(series->images[i].buffer);  // Speicher für das Bild freigeben
+    }
+
+    free(series->images);   // Speicher für die Bild-Array freigeben
+    free(series->labels);   // Speicher für die Labels freigeben
+    free(series); 
 }

matrix.c

@@ -1,35 +1,166 @@
-#include <stdlib.h>
+#include <stdlib.h>
-#include <string.h>
+#include <string.h>
-#include "matrix.h"
+#include "matrix.h"
-
+
-// TODO Matrix-Funktionen implementieren
+// TODO Matrix-Funktionen implementieren
-
+
-Matrix createMatrix(unsigned int rows, unsigned int cols)
+Matrix createMatrix(unsigned int rows, unsigned int cols)
-{
+{
-    
+    Matrix m = {0, 0, NULL};
-}
+
-
+    if (rows > 0 && cols > 0)
-void clearMatrix(Matrix *matrix)
+    {
-{
+        m.rows = rows;
-    
+        m.cols = cols;
-}
+        m.buffer = malloc(rows * cols * sizeof(int));
-
+    }
-void setMatrixAt(MatrixType value, Matrix matrix, unsigned int rowIdx, unsigned int colIdx)
+
-{
+    return m;
-    
+}
-}
+
-
+void clearMatrix(Matrix *matrix)
-MatrixType getMatrixAt(const Matrix matrix, unsigned int rowIdx, unsigned int colIdx)
+{
-{
+
-    
+    if (matrix == NULL)
-}
+    {
-
+        return;
-Matrix add(const Matrix matrix1, const Matrix matrix2)
+    }
-{
+
-    
+    // Speicher freigeben, falls vorhanden
-}
+    free(matrix->buffer);
-
+    matrix->buffer = NULL;
-Matrix multiply(const Matrix matrix1, const Matrix matrix2)
+
-{
+    // Metadaten zurücksetzen
-    
+    matrix->rows = 0;
+    matrix->cols = 0;
+}
+
+void setMatrixAt(MatrixType value, Matrix matrix, unsigned int rowIdx, unsigned int colIdx)
+{
+    matrix.buffer[rowIdx * matrix.cols + colIdx] = value; // setzte Matrix auf den Wert value am Punkt (row col)
+}
+
+MatrixType getMatrixAt(const Matrix matrix, unsigned int rowIdx, unsigned int colIdx)
+{
+    MatrixType value = 0;
+
+    if (rowIdx < matrix.rows && colIdx < matrix.cols)
+    {
+        value = matrix.buffer[rowIdx * matrix.cols + colIdx]; // hole Wert value am Punkt (row col)
+    }
+
+    return value;
+}
+
+Matrix add(const Matrix matrix1, const Matrix matrix2)
+{
+    Matrix result = {0};
+
+    int broadcast_case =
+    (matrix1.cols == 1 && matrix1.rows == matrix2.rows) ||
+    (matrix2.cols == 1 && matrix1.rows == matrix2.rows);
+
+    if (!broadcast_case && (matrix1.rows != matrix2.rows || matrix1.cols != matrix2.cols))
+    {
+        return result;
+    }
+
+    result.rows = matrix1.rows;
+    result.cols = matrix1.cols;
+    result.buffer = malloc(result.rows * result.cols * sizeof(MatrixType));
+
+    // wenn buffer nicht allokiert werden kann dann zurücksetzen und abbrechen
+    if (result.buffer == NULL)
+    {
+        result.rows = result.cols = 0;
+
+        return result;
+    }
+
+    if (matrix1.cols == 1 && matrix1.rows == matrix2.rows) // Broadcasting
+    {
+        result.rows = matrix2.rows;
+        result.cols = matrix2.cols;
+        
+        for (unsigned int i = 0; i < matrix1.rows; i++)
+        {
+            for (unsigned int j = 0; j < result.cols; j++)
+            {
+                result.buffer[i * result.cols + j] = matrix1.buffer[i] + matrix2.buffer[i * matrix2.cols + j];
+            }
+        }
+        
+
+    }
+
+    else if (matrix2.cols == 1 && matrix1.rows == matrix2.rows) 
+    {
+        result.rows = matrix1.rows;
+        result.cols = matrix1.cols;
+
+        for (unsigned int i = 0; i < matrix2.rows; i++)
+        {
+            for (unsigned int j = 0; j < result.cols; j++)
+            {
+                result.buffer[i * result.cols + j] = matrix1.buffer[i * matrix1.cols + j] + matrix2.buffer[i];
+            }
+        }
+    }
+
+    else
+    {
+        // Elementweise Addition
+        for (unsigned int i = 0; i < result.rows; i++)
+        {
+            for (unsigned int j = 0; j < result.cols; j++)
+            {
+                result.buffer[i * result.cols + j] = matrix1.buffer[i * matrix1.cols + j] + matrix2.buffer[i * matrix2.cols + j];
+            }
+        }
+    }
+
+    
+    return result;
+}
+
+Matrix multiply(const Matrix matrix1, const Matrix matrix2)
+{
+    Matrix result = {0};
+
+    if (matrix1.cols != matrix2.rows)
+    {
+        return result;
+    }
+
+    result.rows = matrix1.rows;
+    result.cols = matrix2.cols;
+    result.buffer = malloc(result.rows * result.cols * sizeof(MatrixType));
+
+    // wenn buffer nicht allokiert werden kann dann zurücksetzen und abbrechen
+    if (result.buffer == NULL)
+    {
+        result.rows = result.cols = 0;
+
+        return result;
+    }
+
+    // Matritzenmultiplikation
+
+    for (int r = 0; r < result.rows; r++) // Zeile in Ergebnis
+    {
+        for (int m = 0; m < result.cols; m++) // Spalte in Ergebnis
+        {
+            MatrixType sum = 0;
+
+            for (int n = 0; n < matrix1.cols; n++)
+            {
+                sum += matrix1.buffer[r * matrix1.cols + n] *
+                       matrix2.buffer[n * matrix2.cols + m];
+            }
+
+            result.buffer[r * result.cols + m] = sum;
+        }
+    }
+
+    return result;
 }

matrix.h

@@ -1,19 +1,26 @@
-#ifndef MATRIX_H
+#ifndef MATRIX_H
-#define MATRIX_H
+#define MATRIX_H
-
+
-#define UNDEFINED_MATRIX_VALUE 0
+#define UNDEFINED_MATRIX_VALUE 0
-
+
-typedef float MatrixType;
+typedef float MatrixType;
-
+
-// TODO Matrixtyp definieren
+// TODO Matrixtyp definieren
-
+
-
+typedef struct 
-Matrix createMatrix(unsigned int rows, unsigned int cols);
+{
-void clearMatrix(Matrix *matrix);
+    unsigned int rows;   // Anzahl der Zeilen
-void setMatrixAt(MatrixType value, Matrix matrix, unsigned int rowIdx, unsigned int colIdx);
+    unsigned int cols;   // Anzahl der Spalten
-MatrixType getMatrixAt(const Matrix matrix, unsigned int rowIdx, unsigned int colIdx);
+    MatrixType *buffer;    // Zeiger auf die Matrixdaten 
-Matrix add(const Matrix matrix1, const Matrix matrix2);
+} Matrix;
-Matrix multiply(const Matrix matrix1, const Matrix matrix2);
+
-
+
-
+Matrix createMatrix(unsigned int rows, unsigned int cols);
-#endif
+void clearMatrix(Matrix *matrix);
+void setMatrixAt(MatrixType value, Matrix matrix, unsigned int rowIdx, unsigned int colIdx);
+MatrixType getMatrixAt(const Matrix matrix, unsigned int rowIdx, unsigned int colIdx);
+Matrix add(const Matrix matrix1, const Matrix matrix2);
+Matrix multiply(const Matrix matrix1, const Matrix matrix2);
+
+
+#endif