Блинов Даниил P3208

solution/include/bmp.h

+#include "image.h"
+#include <stdio.h>
+
+#ifndef BMP_H
+#define BMP_H
+
+#define READ_ERROR 1
+#define READ_SUCSESS 0
+#define WRITE_ERROR 1
+#define WRITE_SUCSESS 0
+
+
+int from_bmp(FILE* in, struct image* img);
+int to_bmp(FILE* file, struct image* img);
+
+#endif

solution/include/image.h

+#include <stdint.h>
+#include <stdio.h>
+
+#ifndef IMAGE_H
+#define IMAGE_H
+
+
+struct pixel {
+    uint8_t r;
+    uint8_t g;
+    uint8_t b;
+};
+
+struct image {
+    uint64_t width;
+    uint64_t height;
+    int* pixel;
+    struct pixel* data;
+};
+
+struct image* create_image(uint64_t width, uint64_t height);
+
+#endif

solution/include/rotation.h

+#include "image.h"
+#include <stdint.h>
+
+
+#ifndef ROTATION_H
+#define ROTATION_H
+
+
+struct image rotate_image(struct image* source, int angle);
+void free_image(struct image* img);
+
+#endif

solution/src/bmp.c

+#include "bmp.h"
+#include <stdlib.h>
+
+
+struct bmp_header {
+    uint16_t bfType;
+    uint32_t bfileSize;
+    uint32_t bfReserved;
+    uint32_t bOffBits;
+    uint32_t biSize;
+    uint32_t biWidth;
+    uint32_t biHeight;
+    uint16_t biPlanes;
+    uint16_t biBitCount;
+    uint32_t biCompression;
+    uint32_t biSizeImage;
+    uint32_t biXPelsPerMeter;
+    uint32_t biYPelsPerMeter;
+    uint32_t biClrUsed;
+    uint32_t biClrImportant;
+} __attribute__((packed));
+
+int from_bmp(FILE* in, struct image* img) {
+    struct bmp_header header;
+    int result = (int)fread(&header, sizeof(struct bmp_header), 1, in);
+    if (result!=1) {
+        return READ_ERROR;
+    }
+    img->width = header.biWidth;
+    img->height = header.biHeight;
+    img->data = malloc(img->width * img->height * sizeof(struct pixel));
+
+    if (!img->data) {
+        return READ_ERROR;
+    }
+
+    for (uint32_t row = 0; row < header.biHeight; ++row) {
+        
+        int img_result = (int)fread(img->data + row * img->width, sizeof(struct pixel), header.biWidth, in);
+        if (img_result != img->width) {
+            free(img->data);
+            return READ_ERROR;
+        }
+        
+        if(fseek(in, (int)(4 - (img->width * sizeof(struct pixel)) % 4) % 4, SEEK_CUR)!=0){
+            free(img->data);
+            return READ_ERROR;
+        }
+    }
+    
+    return READ_SUCSESS;
+}
+
+
+
+int to_bmp(FILE* file, struct image* img) {
+    struct bmp_header header;
+    header.bfType = 0x4D42;
+    header.bfileSize = sizeof(struct bmp_header) + img->width * img->height * sizeof(struct pixel);
+    header.bfReserved = 0;
+    header.bOffBits = sizeof(struct bmp_header);
+    header.biSize = 40;
+    header.biWidth = img->width;
+    header.biHeight = img->height;
+    header.biPlanes = 1;
+    header.biBitCount = 24;
+    header.biCompression = 0;
+    uint8_t padding = (4 - (header.biWidth * sizeof(struct pixel)) % 4) % 4;
+    header.biSizeImage = (img->width * sizeof(struct pixel) + padding) * img->height;
+    header.biXPelsPerMeter = 0;
+    header.biYPelsPerMeter = 0;
+    header.biClrUsed = 0;
+
+    header.biClrImportant = 0;
+
+    int header_result = (int)fwrite(&header, sizeof(struct bmp_header), 1, file);
+    
+    if (header_result!= 1) {
+        return WRITE_ERROR;
+    }
+    
+    uint32_t i = 0;
+    while (i < img->height) {
+        int img_result = (int)fwrite(&img->data[i * img->width], sizeof(struct pixel), img->width, file); 
+        if (img_result != img->width) {
+            return WRITE_ERROR;
+        }
+        if (padding > 0) {
+                uint8_t paddingData[3] = {0};
+                int padding_result = (int)fwrite(paddingData, 1, padding, file);
+                
+                if  (padding_result != padding) {
+                return WRITE_ERROR;
+            }
+        }
+        i+=1;
+    }
+    return WRITE_SUCSESS;
+}
+

solution/src/main.c

+#include "bmp.h"
+#include "rotation.h"
+#include <stdint.h>
 #include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
-int main( int argc, char** argv ) {
-    (void) argc; (void) argv; // supress 'unused parameters' warning
 
-    return 0;
+
+int main(int argc, char *argv[]) {
+  if (argc != 4) {
+    printf("Usage: ./image-transformer <source-image> <transformed-image> <angle>\n");
+    return 1;
+  }
+
+  char* source_image_filename = argv[1];
+  char* transformed_image_filename = argv[2];
+  int angle = atoi(argv[3]);
+
+  if (angle % 90 != 0 || angle < -270 || angle > 270) {
+    printf("Invalid angle. Angle must be one of: 0, 90, -90, 180, -180, 270, -270\n");
+    return 1;
+  }
+
+  FILE* source_file = fopen(source_image_filename, "rb");
+  if (!source_file) {
+    printf("Error opening source image file\n");
+    return 1;
+  }
+  
+  struct image original_img;
+  int read_result = from_bmp(source_file, &original_img);
+  if (read_result != READ_SUCSESS) {
+    fclose(source_file);
+    printf("Error reading source image\n");
+    return 1;
+  }
+
+  struct image final_img;
+  final_img = rotate_image(&original_img, angle);
+
+  FILE* transformed_file = fopen(transformed_image_filename, "wb");
+  if (!transformed_file) {
+    printf("Error opening transformed image file\n");
+    return 1;
+  }
+  
+  int write_result = to_bmp(transformed_file, &final_img);
+  if (write_result!=WRITE_SUCSESS){
+    fclose(transformed_file);
+    printf("Error writing rotated image\n");
+    return 1;
+  }
+  
+  return 0;
 }