imageInput: Kommntare verbessert

imageInput.c

@@ -6,17 +6,223 @@
 #define BUFFER_SIZE 100
 #define FILE_HEADER_STRING "__info2_image_file_format__"
 
-// 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
+
+//HilfsFunktionen:
+
+
+/* Opens the file in binary mode.
+ * path: file path to open (must not be NULL).
+ * returns FILE* or NULL on failure.
+ */
+static FILE *openImageFile(const char *path)
+{  
+    if (path == NULL)
+    {
+        return NULL;
+    }
+
+    return fopen(path, "rb");
+}
+
+/* Reads and checks the file header.
+ * file: opened file to read the header from.
+ * returns 1 if header is valid, otherwise 0.
+ */
+static int readAndCheckHeader(FILE *file)
+{
+    size_t headerLength = strlen(FILE_HEADER_STRING);
+    char buffer[BUFFER_SIZE];
+
+    if (headerLength + 1 > BUFFER_SIZE)
+    {
+        return 0;
+    }
+
+    if (fread(buffer, 1, headerLength, file) != headerLength)
+    {
+        return 0;
+    }
+
+    buffer[headerLength] = '\0';
+
+    if (strcmp(buffer, FILE_HEADER_STRING) != 0)
+    {
+        return 0;
+    }
+
+    return 1; /* Header ok */
+}
+
+
+/* Reads metadata: image count, width, and height.
+ * file: file to read from; count/width/height are outputs.
+ * returns 1 on success or 0 on invalid/zero metadata.
+ */
+static int readImageMetaData(FILE *file,
+                             unsigned short *count,
+                             unsigned short *width,
+                             unsigned short *height)
+{
+    if (fread(count, sizeof(unsigned short), 1, file) != 1)
+    {    
+        return 0;
+    }
+    if (fread(width, sizeof(unsigned short), 1, file) != 1)
+    {
+        return 0;
+    }
+    if (fread(height, sizeof(unsigned short), 1, file) != 1)
+    {
+        return 0;
+    }
+
+    if (*count == 0 || *width == 0 || *height == 0)
+    {
+        return 0;
+    }
+
+    return 1;
+}
+
+
+//Hauptfunktion:
+
+
+/* Loads all images + labels from a .info2 file.
+ * path: file path to load.
+ * returns a new GrayScaleImageSeries or NULL on error.
+ */
 GrayScaleImageSeries *readImages(const char *path)
 {
-    GrayScaleImageSeries *series = NULL;
-    
+    // 1. Open the file
+    FILE *file = openImageFile(path);
+    if (file == NULL)
+    {
+        return NULL;
+    }
+
+    // 2. Check the header
+    if (!readAndCheckHeader(file))
+    {
+        fclose(file);
+        return NULL;
+    }
+
+    // 3. Read image metadata
+    unsigned short count = 0;
+    unsigned short width = 0;
+    unsigned short height = 0;
+
+    if (!readImageMetaData(file, &count, &width, &height))
+    {
+        fclose(file);
+        return NULL;
+    }
+
+    // 4. Allocate memory for image series
+    GrayScaleImageSeries *series = (GrayScaleImageSeries *)malloc(sizeof(GrayScaleImageSeries));
+    if (series == NULL)
+    {
+        fclose(file);
+        return NULL;
+    }
+
+    series->count  = count;
+    series->images = (GrayScaleImage *)calloc(count, sizeof(GrayScaleImage));
+    series->labels = (unsigned char *)malloc(count * sizeof(unsigned char));
+
+    if (series->images == NULL || series->labels == NULL)
+    {
+        free(series->images);
+        free(series->labels);
+        free(series);
+        fclose(file);
+        return NULL;
+    }
+
+    // 5. Read the images and labels 
+    for (unsigned int i = 0; i < count; i++)
+    {
+        GrayScaleImage *image = &series->images[i];
+
+        image->width  = (unsigned int)width;
+        image->height = (unsigned int)height;
+
+        size_t numPixels = (size_t)width * (size_t)height;
+
+        image->buffer = (GrayScalePixelType *)malloc(numPixels * sizeof(GrayScalePixelType));
+        if (image->buffer == NULL)
+        {
+            for (unsigned int j = 0; j < i; j++)
+            {
+                free(series->images[j].buffer);
+            }
+            free(series->images);
+            free(series->labels);
+            free(series);
+            fclose(file);
+            return NULL;
+        }
+
+        if (fread(image->buffer, sizeof(GrayScalePixelType), numPixels, file) != numPixels)
+        {
+            for (unsigned int j = 0; j <= i; j++)
+            {
+                free(series->images[j].buffer);
+            }
+            free(series->images);
+            free(series->labels);
+            free(series);
+            fclose(file);
+            return NULL;
+        }
+
+        if (fread(&series->labels[i], sizeof(unsigned char), 1, file) != 1)
+        {
+            for (unsigned int j = 0; j <= i; j++)
+            {
+                free(series->images[j].buffer);
+            }
+            free(series->images);
+            free(series->labels);
+            free(series);
+            fclose(file);
+            return NULL;
+        }
+    }
+
+    fclose(file);
     return series;
 }
 
-// TODO Vervollständigen Sie die Funktion clearSeries, welche eine Bildserie vollständig aus dem Speicher freigibt
+/* Frees the entire image series.
+ * series: image series to free (NULL-safe).
+ * returns nothing (void).
+ */
 void clearSeries(GrayScaleImageSeries *series)
 {
-}
+    if (series == NULL)
+    {
+        return;
+    }
+
+    if (series->images != NULL)
+    {
+        for (unsigned int i = 0; i < series->count; i++)
+        {
+            free(series->images[i].buffer);
+            series->images[i].buffer = NULL;
+        }
+        free(series->images);
+        series->images = NULL;
+    }
+
+    if (series->labels != NULL)
+    {
+        free(series->labels);
+        series->labels = NULL;
+    }
+
+    free(series);
+}

matrix.c

@@ -6,30 +6,148 @@
 
 Matrix createMatrix(unsigned int rows, unsigned int cols)
 {
-    
+    if(rows && cols){
+    Matrix matrix;
+    matrix.rows = rows;
+    matrix.cols = cols;
+    matrix.buffer = malloc(rows * cols * sizeof(MatrixType));
+
+    matrix.buffer = malloc(rows * cols * sizeof(MatrixType));
+    if (!matrix.buffer) {
+    matrix.rows = 0;
+    matrix.cols = 0;
+    return matrix; // malloc ist fehlgeschlagen
+    }
+
+
+    for (int i = 0; i < (rows * cols); i++)
+        matrix.buffer[i] = 0;
+
+    return matrix;
+    }
+    Matrix matrix;
+    matrix.rows = 0;
+    matrix.cols = 0;
+    matrix.buffer = 0;
+    return matrix;
 }
 
+
 void clearMatrix(Matrix *matrix)
 {
-    
+  free(matrix->buffer);
+  matrix->buffer = NULL;
+  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;
 }
 
 MatrixType getMatrixAt(const Matrix matrix, unsigned int rowIdx, unsigned int colIdx)
 {
-    
+  if(rowIdx >= matrix.rows || colIdx >= matrix.cols){
+    return UNDEFINED_MATRIX_VALUE;
+  }
+  return matrix.buffer[rowIdx * matrix.cols + colIdx];
 }
 
 Matrix add(const Matrix matrix1, const Matrix matrix2)
 {
-    
+    int rows1 = rows(matrix1);
+    int rows2 = rows(matrix2);
+    int cols1 = cols(matrix1);
+    int cols2 = cols(matrix2);
+    if((cols1 == 1 || cols2 == 1) && rows1 == rows2) //Broadcasting
+    {
+        if(cols1 == 1)      //Wenn die erste Matrix der Vektor ist
+          {
+            return broadcasting(matrix1, matrix2);
+          }
+        else
+          {
+            return broadcasting(matrix2, matrix1);
+          }
+    }
+    else if(rows1 == rows2 && cols1 == cols2) //Addition nur moeglich, wenn beide Matrizen gleiche ANzahl an Zeilen und Spalten haben
+    {
+      Matrix addition = createMatrix(rows1, cols2); //Matrix erstellt, in die die addierten Werte geschrieben werden
+      MatrixType wert1;
+      MatrixType wert2;
+      for(int i = 0; i < rows1; i++){ //soll fuer jedes Element durchlaufen, sodass alle Werte von beiden Matrizen aufaddiert werden.
+        for(int j = 0; j < cols1; j++){
+        wert1 = getMatrixAt(matrix1, i, j);
+        wert2 = getMatrixAt(matrix2, i, j);
+        MatrixType addierterWert = wert1 + wert2;
+        setMatrixAt(addierterWert, addition, i, j);
+        }
+      }
+      return addition;
+    }
+    else{
+      return createMatrix(0,0);
+    }
 }
 
+Matrix broadcasting(const Matrix vektor, const Matrix matrix)
+  {
+      int rowsM = rows(matrix);
+      int colsM = cols(matrix);
+      Matrix result = createMatrix(rowsM, colsM);
+      MatrixType wert;
+      MatrixType koordinate;
+      for(int i = 0; i < rowsM; i++)
+        {
+        for(int j = 0; j < colsM; j++){
+          wert = getMatrixAt(matrix, i, j);
+          koordinate = getMatrixAt(vektor, i, 0);
+          setMatrixAt((koordinate + wert), result, i, j);
+          }
+        }
+      return result;
+  }
+
 Matrix multiply(const Matrix matrix1, const Matrix matrix2)
 {
-    
+     int rows1 = rows(matrix1);
+     int cols1 = cols(matrix1);
+     int rows2 = rows(matrix2);
+     int cols2 = cols(matrix2);
+     if(cols1 == rows2) //Bedingung fuer Multiplikation: Spalten der ersten Matrix gleich Zeilen 2. Matrix
+     {
+         Matrix result = createMatrix(rows1, cols2);
+         MatrixType wert1;
+         MatrixType wert2;
+         MatrixType mul;
+         MatrixType add = 0;
+         for(int i = 0; i < rows1; i++)
+         {
+           for(int k = 0; k < cols2; k++)
+           {
+            for(int j = 0; j < cols1; j++)
+            {
+              wert1 = getMatrixAt(matrix1, i, j);
+              wert2 = getMatrixAt(matrix2, j, k);
+              mul = wert1 * wert2;
+              add += mul;
+            }
+            setMatrixAt(add, result, i, k);
+            add = 0;
+           }
+         }
+         return result;
+     }
+     return createMatrix(0,0);
+}
+
+int rows(const Matrix matrix)
+{
+   return matrix.rows;
+}
+
+int cols(const Matrix matrix)
+{
+  return matrix.cols;
 }

matrix.h

@@ -9,7 +9,8 @@ typedef float MatrixType;
 typedef struct{
   unsigned int rows;
   unsigned int cols;
-  } Matrixtyp;
+  MatrixType *buffer; //Data wird in einem eindimensionalen Array gespeichert (Spalten und Reihen liegen ja im Speicher hintereinannder)
+  } Matrix;
 
 
 Matrix createMatrix(unsigned int rows, unsigned int cols);
@@ -17,7 +18,10 @@ 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 broadcasting(const Matrix matrix1, const Matrix matrix2);
 Matrix multiply(const Matrix matrix1, const Matrix matrix2);
+int rows(const Matrix matrix);
+int cols(const Matrix matrix);
 
 
 #endif

runImageInputTests.dSYM/Contents/Info.plist

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+	<dict>
+		<key>CFBundleDevelopmentRegion</key>
+		<string>English</string>
+		<key>CFBundleIdentifier</key>
+		<string>com.apple.xcode.dsym.runImageInputTests</string>
+		<key>CFBundleInfoDictionaryVersion</key>
+		<string>6.0</string>
+		<key>CFBundlePackageType</key>
+		<string>dSYM</string>
+		<key>CFBundleSignature</key>
+		<string>????</string>
+		<key>CFBundleShortVersionString</key>
+		<string>1.0</string>
+		<key>CFBundleVersion</key>
+		<string>1</string>
+	</dict>
+</plist>

runImageInputTests.dSYM/Contents/Resources/Relocations/aarch64/runImageInputTests.yml

@@ -0,0 +1,5 @@
+---
+triple:          'arm64-apple-darwin'
+binary-path:     runImageInputTests
+relocations:     []
+...