Upload 27 files

.gitattributes

@@ -33,3 +33,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+src/c_project_files/coep.ppm filter=lfs diff=lfs merge=lfs -text
+src/c_project_files/rcb.ppm filter=lfs diff=lfs merge=lfs -text
+src/c_project_files/sailboat.ppm filter=lfs diff=lfs merge=lfs -text
+src/c_project_files/squares.ppm filter=lfs diff=lfs merge=lfs -text

src/c_project_files/Makefile

@@ -0,0 +1,16 @@
+final: rotate.o suppl.o decompress.o compress.o main.o filters.o union.o
+	cc rotate.o suppl.o decompress.o compress.o main.o filters.o union.o -o final -lm
+rotate.o: rotate.c rotate.h
+	cc -c rotate.c
+suppl.o: suppl.c suppl.h
+	cc -c suppl.c
+decompress.o: decompress.c decompress.h
+	cc -c decompress.c
+compress.o: compress.c compress.h
+	cc -c compress.c
+main.o: main.c filters.h
+	cc -c main.c
+filters.o: filters.c filters.h
+	cc -c filters.c
+union.o: union.c union.h
+	cc -c union.c

src/c_project_files/compress.c

@@ -0,0 +1,49 @@
+#include "compress.h"
+
+//------------------------COMPRESSION FUNCTION-------------------------------//
+void compressImage(pixels **matrix, qtNode **t, int x, int y, int size, int reqFactor)
+{
+    int mean = getMean(matrix, t, x, y, size);
+    int i, j;
+    unsigned long long int blue = 0, green = 0, red = 0;
+
+    (*t) = malloc(sizeof(qtNode));
+    (*t)->area = size * size;
+
+    for (i = y; i < y + size; i++)
+    {
+        for (j = x; j < x + size; j++)
+        {
+            blue = blue + matrix[i][j].blue;
+            green = green + matrix[i][j].green;
+            red = red + matrix[i][j].red;
+        }
+    }
+
+    blue = blue / ((*t)->area);
+    red = red / ((*t)->area);
+    green = green / ((*t)->area);
+
+    (*t)->p.blue = blue;
+    (*t)->p.red = red;
+    (*t)->p.green = green;
+
+    // Traversal condition
+    if (mean > reqFactor)
+    {
+        compressImage(matrix, &(*t)->topLeft, x, y, size / 2, reqFactor);
+        compressImage(matrix, &(*t)->topRight, x + (size / 2), y, size / 2, reqFactor);
+        compressImage(matrix, &(*t)->bottomRight, x + (size / 2), y + (size / 2), size / 2, reqFactor);
+        compressImage(matrix, &(*t)->bottomLeft, x, y + (size / 2), size / 2, reqFactor);
+
+        return;
+    }
+    else
+    {
+        (*t)->topRight = NULL;
+        (*t)->topLeft = NULL;
+        (*t)->bottomLeft = NULL;
+        (*t)->bottomRight = NULL;
+        return;
+    }
+}

src/c_project_files/compress.h

@@ -0,0 +1,3 @@
+#include "suppl.h"
+
+void compressImage(pixels **matrix, qtNode **node, int x, int y, int size, int threshold);

src/c_project_files/decompress.c

@@ -0,0 +1,31 @@
+#include "decompress.h"
+
+//--------------------DECOMPRESSION FUNCTION----------------------------------//
+
+void decompressImage(qtNode *node, pixels ***imageMatrix, int startX, int startY, int blockSize)
+{
+    int i, j;
+
+    // already optimized tree
+    if (node->topLeft == NULL && node->topRight == NULL && node->bottomLeft == NULL && node->bottomRight == NULL)
+    {
+        for (i = startY; i < startY + blockSize; i++)
+        {
+            for (j = startX; j < startX + blockSize; j++)
+            {
+                (*imageMatrix)[i][j].red = node->p.red;
+                (*imageMatrix)[i][j].green = node->p.green;
+                (*imageMatrix)[i][j].blue = node->p.blue;
+            }
+        }
+    }
+    // decompress till tree is optimized
+    else
+    {
+        decompressImage(node->topLeft, imageMatrix, startX, startY, blockSize / 2);
+        decompressImage(node->topRight, imageMatrix, startX + (blockSize / 2), startY, blockSize / 2);
+        decompressImage(node->bottomRight, imageMatrix, startX + (blockSize / 2), startY + (blockSize / 2), blockSize / 2);
+        decompressImage(node->bottomLeft, imageMatrix, startX, startY + (blockSize / 2), blockSize / 2);
+    }
+}
+

src/c_project_files/decompress.h

@@ -0,0 +1,3 @@
+#include "compress.h"
+
+void decompressImage(qtNode *node, pixels ***matrix, int x, int y, int size);

src/c_project_files/filters.c

@@ -0,0 +1,127 @@
+#include "filters.h"
+
+void grayScale(qtNode *t1, qtNode **res)
+{
+    (*res) = malloc(sizeof(qtNode));
+    if (t1->topLeft != NULL)
+    {
+        grayScale(t1->topLeft, &(*res)->topLeft);
+        grayScale(t1->topRight, &(*res)->topRight);
+        grayScale(t1->bottomLeft, &(*res)->bottomLeft);
+        grayScale(t1->bottomRight, &(*res)->bottomRight);
+    }
+
+    else
+    {
+
+        (*res)->topRight = NULL;
+        (*res)->topLeft = NULL;
+        (*res)->bottomLeft = NULL;
+        (*res)->bottomRight = NULL;
+    }
+
+    (*res)->area = t1->area;
+    (*res)->p.red = t1->p.red * 0.3;
+    (*res)->p.blue = t1->p.green * 0.59;
+    (*res)->p.green = t1->p.blue * 0.11;
+    (*res)->area = t1->area;
+
+    return;
+}
+
+void brighten(qtNode *t1, qtNode **res)
+{
+    (*res) = malloc(sizeof(qtNode));
+    if (t1->topLeft != NULL)
+    {
+        brighten(t1->topLeft, &(*res)->topLeft);
+        brighten(t1->topRight, &(*res)->topRight);
+        brighten(t1->bottomLeft, &(*res)->bottomLeft);
+        brighten(t1->bottomRight, &(*res)->bottomRight);
+    }
+    else
+    {
+        (*res)->topRight = NULL;
+        (*res)->topLeft = NULL;
+        (*res)->bottomLeft = NULL;
+        (*res)->bottomRight = NULL;
+    }
+
+    (*res)->area = t1->area;
+    // Brighten the image by increasing the color channels
+    double brightnessFactor = 1.2; // Adjust this factor to control the brightness
+    (*res)->p.red = t1->p.red * brightnessFactor;
+    (*res)->p.green = t1->p.green * brightnessFactor;
+    (*res)->p.blue = t1->p.blue * brightnessFactor;
+
+    return;
+}
+
+
+
+
+void negativeImage(qtNode *t1, qtNode **res)
+{
+    (*res) = malloc(sizeof(qtNode));
+    if (t1->topLeft != NULL)
+    {
+        negativeImage(t1->topLeft, &(*res)->topLeft);
+        negativeImage(t1->topRight, &(*res)->topRight);
+        negativeImage(t1->bottomLeft, &(*res)->bottomLeft);
+        negativeImage(t1->bottomRight, &(*res)->bottomRight);
+    }
+
+    else
+    {
+
+        (*res)->topRight = NULL;
+        (*res)->topLeft = NULL;
+        (*res)->bottomLeft = NULL;
+        (*res)->bottomRight = NULL;
+    }
+
+    (*res)->area = t1->area;
+    (*res)->p.red = (t1->p.red <= 255) ? 255 - t1->p.red : 0;
+    (*res)->p.blue = (t1->p.blue <= 255) ? 255 - t1->p.blue : 0;
+    (*res)->p.green = (t1->p.green <= 255) ? 255 - t1->p.green : 0;
+    (*res)->area = t1->area;
+
+    return;
+}
+
+void sepia(qtNode* t1,qtNode** res)
+{
+    (*res) = malloc(sizeof(qtNode));
+
+    if (t1->topLeft != NULL)
+    {
+        sepia(t1->topLeft, &(*res)->topLeft);
+        sepia(t1->topRight, &(*res)->topRight);
+        sepia(t1->bottomLeft, &(*res)->bottomLeft);
+        sepia(t1->bottomRight, &(*res)->bottomRight);
+    }
+
+    else
+    {
+
+        (*res)->topRight = NULL;
+        (*res)->topLeft = NULL;
+        (*res)->bottomLeft = NULL;
+        (*res)->bottomRight = NULL;
+    }
+
+    (*res)->area = t1->area;
+(*res)->p.red = 0.393 * t1->p.red + 0.769 * t1->p.green + 0.189 * t1->p.blue;
+(*res)->p.blue = 0.349 * t1->p.red + 0.686 * t1->p.green + 0.168 * t1->p.blue;
+(*res)->p.green = 0.272 * t1->p.red + 0.534 * t1->p.green + 0.131 * t1->p.blue;
+
+// Ensure that the color values don't exceed 255
+(*res)->p.red = (*res)->p.red <= 255 ? (*res)->p.red : 255;
+(*res)->p.blue = (*res)->p.blue <= 255 ? (*res)->p.blue : 255;
+(*res)->p.green = (*res)->p.green <= 255 ? (*res)->p.green : 255;
+
+(*res)->area = t1->area;
+
+    return;
+
+}

src/c_project_files/filters.h

@@ -0,0 +1,5 @@
+#include "union.h"
+
+void grayScale(qtNode* t1,qtNode** res);
+void negativeImage(qtNode* t,qtNode** res);
+void sepia(qtNode* t1,qtNode** res);

src/c_project_files/main.c

@@ -0,0 +1,423 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include "filters.h"
+
+int main(int argc, char *argv[])
+{
+    // compression
+    if (strcmp(argv[1], "-c") == 0)
+    {
+        unsigned int index = 0;
+        unsigned int i;
+        int factor, width, height;
+
+        pixels **r;
+        qtNode *node = NULL;
+
+        r = read(&height, &width, argv[3]);
+        compressImage(r, &node, 0, 0, width, atoi(argv[2]));
+
+        // Vector of pointers to the tree nodes
+        qtNode **vector = malloc(sizeof(qtNode *));
+        traversal(node, &vector, &index);
+
+        qtInfo *vec = malloc(sizeof(qtInfo) * index);
+        copyToArr(vector, &vec, index);
+
+        for (i = 0; i < index; i++)
+            free(vector[i]);
+        free(vector);
+
+        // Write vector in a file
+        FILE *f = fopen(argv[4], "wb");
+        // fprintf(f, "P6\n");------------------>segmentation error!
+        // fprintf(f, "%d %d\n", width, width);
+        // fprintf(f, "255\n");
+
+        unsigned int count = 0;
+        for (i = 0; i < index; i++)
+        {
+            if (vec[i].topLeft == -1)
+            {
+                count++;
+            }
+        }
+
+        fwrite(&count, sizeof(int), 1, f);
+        fwrite(&index, sizeof(int), 1, f);
+
+        for (i = 0; i < index; i++)
+        {
+            fwrite(&vec[i], sizeof(qtInfo), 1, f);
+            if (vec[i].topLeft == -1)
+            {
+                count++;
+            }
+        }
+        free(vec);
+        fclose(f);
+    }
+    // decompression
+    else if (strcmp(argv[1], "-d") == 0)
+    {
+
+        unsigned int index, i;
+        unsigned int colors;
+
+        FILE *f = fopen(argv[2], "rb");
+        fread(&colors, sizeof(int), 1, f);
+        // Read number of nodes
+        fread(&index, sizeof(int), 1, f);
+
+        qtInfo *vec = malloc(sizeof(qtInfo) * index);
+
+        // Read node vector
+        fread(vec, sizeof(qtInfo), index, f);
+        fclose(f);
+
+        qtNode *node = NULL;
+        readTree(vec, &node, 0);
+        free(vec);
+
+        int size = sqrt(node->area);
+
+        // Alloc pixels matrix
+        pixels **mat = (pixels **)malloc(sizeof(pixels *) * size);
+        for (i = 0; i < size; i++)
+        {
+            mat[i] = malloc(sizeof(pixels) * size);
+        }
+
+        decompressImage(node, &mat, 0, 0, size);
+        outputFile(mat, argv[3], size);
+    }
+    // mirroring
+    else if (strcmp(argv[1], "-r") == 0)
+    {
+        unsigned int i;
+        int factor, width, height;
+        pixels **r;
+        qtNode *t = NULL;
+
+        factor = atoi(argv[3]);
+        r = read(&height, &width, argv[4]);
+
+        compressImage(r, &t, 0, 0, width, factor);
+
+        if (strcmp(argv[2], "w") == 0)
+        {
+            getWaterImage(&t);
+        }
+        else if (strcmp(argv[2], "m") == 0)
+        {
+            getMirrorImage(&t);
+        }
+        else if (strcmp(argv[2], "l90") == 0)
+        {
+            rotateLeft(&t);
+        }
+        else if (strcmp(argv[2], "r90") == 0)
+        {
+            rotateRight(&t);
+        }
+
+        // Alloc p matrix
+        pixels **mat = (pixels **)malloc(sizeof(pixels *) * width);
+        for (i = 0; i < width; i++)
+        {
+            mat[i] = malloc(sizeof(pixels) * width);
+        }
+
+        decompressImage(t, &mat, 0, 0, width);
+        outputFile(mat, argv[5], width);
+
+        for (i = 0; i < width; i++)
+        {
+            free(mat[i]);
+        }
+        free(mat);
+
+        for (i = 0; i < height; i++)
+        {
+            free(r[i]);
+        }
+        free(r);
+    }
+
+    // else if (strcmp(argv[1], "-f") == 0)
+    // {
+    //     printf("hi");
+    //     unsigned int i;
+    //     int factor, width, height;
+    //     pixels **r;
+    //     qtNode *t = NULL;
+    //     qtNode *res = NULL;
+
+    //     factor = atoi(argv[3]);
+    //     r = read(&height, &width, argv[4]);
+
+    //     compressImage(r, &t, 0, 0, width, factor);
+
+    //     if (strcmp(argv[2], "g") == 0)
+    //     {
+    //         grayScale(t, &res);
+    //     }
+    //     //     else if (strcmp(argv[2], "n") == 0)
+    //     //     {
+    //     //         negativeImage(t,&res);
+    //     //     }
+
+    //     // Alloc p matrix
+    //     pixels **mat = (pixels **)malloc(sizeof(pixels *) * width);
+    //     for (i = 0; i < width; i++)
+    //     {
+    //         mat[i] = malloc(sizeof(pixels) * width);
+    //     }
+
+    //     decompressImage(res, &mat, 0, 0, width);
+    //     // outputFile(mat, argv[5], width);
+    //     // destroyTree(&t);
+
+    //     // for (i = 0; i < width; i++)
+    //     // {
+    //     //     free(mat[i]);
+    //     // }
+    //     // free(mat);
+
+    //     // for (i = 0; i < height; i++)
+    //     // {
+    //     //     free(r[i]);
+    //     // }
+    //     // free(r);
+    // }
+
+    else
+    {
+        if (strcmp(argv[1], "-g") == 0)
+        {
+            unsigned int i;
+            int threshold, width, height;
+
+            pixels **r1;
+            pixels **r2;
+
+            qtNode *t1 = NULL;
+            qtNode *t2 = NULL;
+
+            threshold = atoi(argv[2]);
+
+            r1 = read(&height, &width, argv[3]);
+            r2 = read(&height, &width, argv[4]);
+
+            compressImage(r1, &t1, 0, 0, width, threshold);
+            compressImage(r2, &t2, 0, 0, width, threshold);
+
+            qtNode *node_overlay = NULL;
+            grayScale(t1, &node_overlay);
+
+            // Alloc rgb matrix
+            pixels **mat = (pixels **)malloc(sizeof(pixels *) * width);
+            for (i = 0; i < width; i++)
+            {
+                mat[i] = malloc(sizeof(pixels) * width);
+            }
+
+            decompressImage(node_overlay, &mat, 0, 0, width);
+            outputFile(mat, argv[5], width);
+
+            // Free
+            destroyTree(&t1);
+            destroyTree(&t2);
+
+            for (i = 0; i < width; i++)
+            {
+                free(mat[i]);
+            }
+            free(mat);
+
+            for (i = 0; i < height; i++)
+            {
+                free(r1[i]);
+            }
+            free(r1);
+
+            for (i = 0; i < height; i++)
+            {
+                free(r2[i]);
+            }
+            free(r2);
+        }
+
+        if (strcmp(argv[1], "-n") == 0)
+        {
+            unsigned int i;
+            int threshold, width, height;
+
+            pixels **r1;
+            pixels **r2;
+
+            qtNode *t1 = NULL;
+            qtNode *t2 = NULL;
+
+            threshold = atoi(argv[2]);
+
+            r1 = read(&height, &width, argv[3]);
+            r2 = read(&height, &width, argv[4]);
+
+            compressImage(r1, &t1, 0, 0, width, threshold);
+            compressImage(r2, &t2, 0, 0, width, threshold);
+
+            qtNode *node_overlay = NULL;
+            negativeImage(t1, &node_overlay);
+
+            // Alloc rgb matrix
+            pixels **mat = (pixels **)malloc(sizeof(pixels *) * width);
+            for (i = 0; i < width; i++)
+            {
+                mat[i] = malloc(sizeof(pixels) * width);
+            }
+
+            decompressImage(node_overlay, &mat, 0, 0, width);
+            outputFile(mat, argv[5], width);
+
+            // Free
+            destroyTree(&t1);
+            destroyTree(&t2);
+
+            for (i = 0; i < width; i++)
+            {
+                free(mat[i]);
+            }
+            free(mat);
+
+            for (i = 0; i < height; i++)
+            {
+                free(r1[i]);
+            }
+            free(r1);
+
+            for (i = 0; i < height; i++)
+            {
+                free(r2[i]);
+            }
+            free(r2);
+        }
+
+        if (strcmp(argv[1], "-s") == 0)
+        {
+            unsigned int i;
+            int threshold, width, height;
+
+            pixels **r1;
+            pixels **r2;
+
+            qtNode *t1 = NULL;
+            qtNode *t2 = NULL;
+
+            threshold = atoi(argv[2]);
+
+            r1 = read(&height, &width, argv[3]);
+            r2 = read(&height, &width, argv[4]);
+
+            compressImage(r1, &t1, 0, 0, width, threshold);
+            compressImage(r2, &t2, 0, 0, width, threshold);
+
+            qtNode *node_overlay = NULL;
+            sepia(t1, &node_overlay);
+
+            // Alloc rgb matrix
+            pixels **mat = (pixels **)malloc(sizeof(pixels *) * width);
+            for (i = 0; i < width; i++)
+            {
+                mat[i] = malloc(sizeof(pixels) * width);
+            }
+
+            decompressImage(node_overlay, &mat, 0, 0, width);
+            outputFile(mat, argv[5], width);
+
+            // Free
+            destroyTree(&t1);
+            destroyTree(&t2);
+
+            for (i = 0; i < width; i++)
+            {
+                free(mat[i]);
+            }
+            free(mat);
+
+            for (i = 0; i < height; i++)
+            {
+                free(r1[i]);
+            }
+            free(r1);
+
+            for (i = 0; i < height; i++)
+            {
+                free(r2[i]);
+            }
+            free(r2);
+        }
+
+        // union of two images
+        else
+        {
+            if (strcmp(argv[1], "-u") == 0)
+            {
+                unsigned int i;
+                int threshold, width, height;
+
+                pixels **r1;
+                pixels **r2;
+
+                qtNode *t1 = NULL;
+                qtNode *t2 = NULL;
+
+                threshold = atoi(argv[2]);
+
+                r1 = read(&height, &width, argv[3]);
+                r2 = read(&height, &width, argv[4]);
+
+                compressImage(r1, &t1, 0, 0, width, threshold);
+                compressImage(r2, &t2, 0, 0, width, threshold);
+
+                qtNode *node_overlay = NULL;
+                unionOfImages(t1, t2, &node_overlay);
+
+                // Alloc rgb matrix
+                pixels **mat = (pixels **)malloc(sizeof(pixels *) * width);
+                for (i = 0; i < width; i++)
+                {
+                    mat[i] = malloc(sizeof(pixels) * width);
+                }
+
+                decompressImage(node_overlay, &mat, 0, 0, width);
+                outputFile(mat, argv[5], width);
+
+                // Free
+                destroyTree(&t1);
+                destroyTree(&t2);
+
+                for (i = 0; i < width; i++)
+                {
+                    free(mat[i]);
+                }
+                free(mat);
+
+                for (i = 0; i < height; i++)
+                {
+                    free(r1[i]);
+                }
+                free(r1);
+
+                for (i = 0; i < height; i++)
+                {
+                    free(r2[i]);
+                }
+                free(r2);
+            }
+        }
+    }
+    return 0;
+}

src/c_project_files/rotate.c

@@ -0,0 +1,149 @@
+#include "rotate.h"
+
+// flip the image along the vertical axis
+void getWaterImage(qtNode **t)
+{
+    if ((*t)->topLeft != NULL && (*t)->topLeft != NULL && (*t)->topLeft != NULL && (*t)->topLeft != NULL)
+    {
+        qtNode *temp;
+
+        getWaterImage(&(*t)->topLeft);
+        getWaterImage(&(*t)->topRight);
+        getWaterImage(&(*t)->bottomRight);
+        getWaterImage(&(*t)->bottomLeft);
+
+        temp = (*t)->topLeft;
+        (*t)->topLeft = (*t)->bottomLeft;
+        (*t)->bottomLeft = temp;
+
+        temp = (*t)->topRight;
+        (*t)->topRight = (*t)->bottomRight;
+        (*t)->bottomRight = temp;
+    }
+    // empty tree condition
+    else
+    {
+        return;
+    }
+}
+
+// flip the image along the horizontal axis
+void getMirrorImage(qtNode **node)
+{
+    if ((*node)->topLeft != NULL && (*node)->topLeft != NULL && (*node)->topLeft != NULL && (*node)->topLeft != NULL)
+    {
+        qtNode *temp;
+
+        getMirrorImage(&(*node)->topLeft);
+        getMirrorImage(&(*node)->topRight);
+        getMirrorImage(&(*node)->bottomRight);
+        getMirrorImage(&(*node)->bottomLeft);
+
+        temp = (*node)->topLeft;
+        (*node)->topLeft = (*node)->topRight;
+        (*node)->topRight = temp;
+
+        temp = (*node)->bottomLeft;
+        (*node)->bottomLeft = (*node)->bottomRight;
+        (*node)->bottomRight = temp;
+    }
+    // empty tree condition
+    else
+    {
+        return;
+    }
+}
+
+// rotate the image to the left by 90 degrees
+void rotateLeft(qtNode **t)
+{
+    if ((*t)->topLeft != NULL && (*t)->topLeft != NULL && (*t)->topLeft != NULL && (*t)->topLeft != NULL)
+    {
+        qtNode *temp1;
+        qtNode *temp2;
+        qtNode *temp3;
+        qtNode *temp4;
+
+        rotateLeft(&(*t)->topLeft);
+        rotateLeft(&(*t)->topRight);
+        rotateLeft(&(*t)->bottomLeft);
+        rotateLeft(&(*t)->bottomRight);
+
+        temp1 = (*t)->topLeft;
+        temp2 = (*t)->topRight;
+        temp3 = (*t)->bottomLeft;
+        temp4 = (*t)->bottomRight;
+
+        (*t)->topLeft = temp2;
+        (*t)->topRight = temp4;
+        (*t)->bottomLeft = temp1;
+        (*t)->bottomRight = temp3;
+    }
+    else
+    {
+        return;
+    }
+}
+
+// rotate the image to the right by 90 degrees
+void rotateRight(qtNode **t)
+{
+    if ((*t)->topLeft != NULL && (*t)->topLeft != NULL && (*t)->topLeft != NULL && (*t)->topLeft != NULL)
+    {
+        qtNode *temp1;
+        qtNode *temp2;
+        qtNode *temp3;
+        qtNode *temp4;
+
+        rotateRight(&(*t)->topLeft);
+        rotateRight(&(*t)->topRight);
+        rotateRight(&(*t)->bottomLeft);
+        rotateRight(&(*t)->bottomRight);
+
+        temp1 = (*t)->topLeft;
+        temp2 = (*t)->topRight;
+        temp3 = (*t)->bottomLeft;
+        temp4 = (*t)->bottomRight;
+
+        (*t)->topLeft = temp3;
+        (*t)->topRight = temp1;
+        (*t)->bottomLeft = temp4;
+        (*t)->bottomRight = temp2;
+    }
+    else
+    {
+        return;
+    }
+}
+
+// rotate the image 180 degrees
+void rotate180(qtNode **t)
+{
+    if ((*t)->topLeft != NULL && (*t)->topLeft != NULL && (*t)->topLeft != NULL && (*t)->topLeft != NULL)
+    {
+        qtNode *temp1;
+        qtNode *temp2;
+        qtNode *temp3;
+        qtNode *temp4;
+
+        rotate180(&(*t)->topLeft);
+        rotate180(&(*t)->topRight);
+        rotate180(&(*t)->bottomLeft);
+        rotate180(&(*t)->bottomRight);
+
+        temp1 = (*t)->topLeft;
+        temp2 = (*t)->topRight;
+        temp3 = (*t)->bottomLeft;
+        temp4 = (*t)->bottomRight;
+
+        (*t)->topLeft = temp4;
+        (*t)->topRight = temp3;
+        (*t)->bottomLeft = temp2;
+        (*t)->bottomRight = temp1;
+    }
+    else
+    {
+        return;
+    }
+}
+

src/c_project_files/rotate.h

@@ -0,0 +1,6 @@
+#include "decompress.h"
+
+void getWaterImage(qtNode ** node);
+void getMirrorImage(qtNode ** node);
+void rotateLeft(qtNode** t);
+void rotateRight(qtNode** t);

src/c_project_files/suppl.c

@@ -0,0 +1,206 @@
+#include "suppl.h"
+
+//-----------------------IMG MANIPULATION FUNC-----------------------------//
+
+// reads the .ppm file and stores the data in 2D matrix form
+pixels **read(int *height, int *width, char *file)
+{
+    FILE *f;
+    char magic_num[3];
+    int color;
+    int i;
+
+    f = fopen(file, "rb");
+
+    fscanf(f, "%s", magic_num);
+    if (magic_num[0] != 'P' || magic_num[1] != '6')
+    {
+        printf("Invalid Image Format!\n");
+        exit;
+    }
+    fscanf(f, "%d ", width);
+    fscanf(f, "%d\n", height);
+    fscanf(f, "%d", &color);
+
+    char garbage;
+    fread(&garbage, sizeof(char), 1, f);
+
+    pixels **r = (pixels **)malloc(sizeof(pixels *) * (*height));
+
+    for (i = 0; i < (*height); i++)
+    {
+        r[i] = malloc(sizeof(pixels) * (*width));
+        fread(r[i], sizeof(pixels), (*width), f);
+    }
+
+    fclose(f);
+    return r;
+}
+
+// gives the output file in .ppm format
+void outputFile(pixels **mat, char *file, int size)
+{
+
+    FILE *f = fopen(file, "w");
+
+    fprintf(f, "P6\n");
+    fprintf(f, "%d %d\n", size, size);
+    fprintf(f, "255\n");
+
+    int i;
+    for (i = 0; i < size; i++)
+    {
+        fwrite(mat[i], sizeof(pixels), size, f);
+    }
+    fclose(f);
+}
+
+int getMean(pixels **matrix, qtNode **t, int x, int y, int size)
+{
+    int i, j;
+    unsigned long long int blue = 0, green = 0, red = 0, mean = 0;
+
+    (*t) = malloc(sizeof(qtNode));
+    (*t)->area = size * size;
+
+    for (i = y; i < y + size; i++)
+        for (j = x; j < x + size; j++)
+        {
+            blue = blue + matrix[i][j].blue;
+            green = green + matrix[i][j].green;
+            red = red + matrix[i][j].red;
+        }
+
+    blue = blue / ((*t)->area);
+    red = red / ((*t)->area);
+    green = green / ((*t)->area);
+
+    (*t)->p.blue = blue;
+    (*t)->p.red = red;
+    (*t)->p.green = green;
+
+    // Compute score
+
+    for (i = y; i < y + size; i++)
+    {
+        for (j = x; j < x + size; j++)
+        {
+            mean = mean + ((red - matrix[i][j].red) * (red - matrix[i][j].red)) + ((green - matrix[i][j].green) * (green - matrix[i][j].green)) + ((blue - matrix[i][j].blue) * (blue - matrix[i][j].blue));
+        }
+    }
+
+    mean = mean / (3 * (*t)->area);
+
+    return mean;
+}
+
+//--------------------------QUAD TREE FUNCTIONS------------------------------//
+
+// stores the quad tree info in array
+
+void traversal(qtNode *node, qtNode **vector[], unsigned int *index)
+{
+    if (node != NULL)
+    {
+        if ((*index) > 0)
+            (*vector) = realloc((*vector), sizeof(qtNode *) * ((*index) + 1));
+
+        (*vector)[(*index)] = node;
+        node->index = (*index);
+        (*index)++;
+
+        traversal(node->topLeft, vector, index);
+        traversal(node->topRight, vector, index);
+        traversal(node->bottomRight, vector, index);
+        traversal(node->bottomLeft, vector, index);
+    }
+    else
+        return;
+}
+
+// transfers the contents to qtInfo
+void copyToArr(qtNode **vp, qtInfo **v, int index)
+{
+
+    unsigned int i;
+
+    for (i = 0; i < index; i++)
+    {
+        (*v)[i].red = vp[i]->p.red;
+        (*v)[i].blue = vp[i]->p.blue;
+        (*v)[i].green = vp[i]->p.green;
+        (*v)[i].area = vp[i]->area;
+
+        if (vp[i]->topLeft != NULL)
+            (*v)[i].topLeft = vp[i]->topLeft->index;
+        else
+            (*v)[i].topLeft = -1;
+
+        if (vp[i]->topRight != NULL)
+            (*v)[i].topRight = vp[i]->topRight->index;
+        else
+            (*v)[i].topRight = -1;
+
+        if (vp[i]->bottomRight != NULL)
+            (*v)[i].bottomRight = vp[i]->bottomRight->index;
+        else
+            (*v)[i].bottomRight = -1;
+
+        if (vp[i]->bottomLeft != NULL)
+            (*v)[i].bottomLeft = vp[i]->bottomLeft->index;
+        else
+            (*v)[i].bottomLeft = -1;
+    }
+}
+
+// reads the data from matrix
+void readTree(qtInfo *vec, qtNode **node, int i)
+{
+    (*node) = malloc(sizeof(qtNode));
+
+    (*node)->p.red = vec[i].red;
+    (*node)->p.blue = vec[i].blue;
+    (*node)->p.green = vec[i].green;
+    (*node)->area = vec[i].area;
+    (*node)->index = i;
+
+    if (vec[i].topLeft != -1 && vec[i].topRight != -1 && vec[i].bottomLeft != -1 && vec[i].bottomRight != -1)
+    {
+        readTree(vec, &(*node)->topLeft, vec[i].topLeft);
+        readTree(vec, &(*node)->topRight, vec[i].topRight);
+        readTree(vec, &(*node)->bottomLeft, vec[i].bottomLeft);
+        readTree(vec, &(*node)->bottomRight, vec[i].bottomRight);
+    }
+    else
+    {
+        (*node)->topLeft = NULL;
+        (*node)->topRight = NULL;
+        (*node)->bottomLeft = NULL;
+        (*node)->bottomRight = NULL;
+    }
+}
+
+void destroyTree(qtNode** t)
+{
+    if(!t)
+    {
+        destroyTree(&(*t)->topLeft);
+        destroyTree(&(*t)->topRight);
+        destroyTree(&(*t)->bottomLeft);
+        destroyTree(&(*t)->bottomRight);
+    }
+    free(*t);
+}
+
+//-----------------------------OTHER FUNCS---------------------------------//
+int min(int a,int b)
+{
+    if(a>b)
+    {
+        return a;
+    }
+    else
+    {
+        return b;
+    }
+}

src/c_project_files/suppl.h

@@ -0,0 +1,59 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+// rgb structure
+typedef struct pixels
+{
+
+    unsigned char red;
+    unsigned char green;
+    unsigned char blue;
+
+} pixels;
+
+// quad tree structure
+typedef struct qtNode
+{
+
+    pixels p;
+    long long index;
+    int area;
+
+    struct qtNode *topLeft;
+    struct qtNode *topRight;
+    struct qtNode *bottomLeft;
+    struct qtNode *bottomRight;
+
+} qtNode;
+
+//structure for storing the information about quad tree array
+typedef struct qtInfo
+{
+
+    unsigned char blue, green, red;
+    int area;
+    int topLeft;
+    int topRight;
+    int bottomLeft;
+    int bottomRight;
+
+} qtInfo;
+
+
+//-----------------------IMG MANIPULATION FUNCTIONS-----------------------------//
+
+pixels **read(int *height, int *width, char *file);
+void outputFile(pixels **mat, char *file, int size);
+int getMean(pixels **matrix, qtNode **node, int x, int y, int size);
+
+
+//--------------------------QUAD TREE FUNCTIONS------------------------------//
+void traversal(qtNode * node, qtNode ** vector[], unsigned int * index);
+void copyToArr(qtNode ** vp, qtInfo ** v, int index);
+void readTree(qtInfo * vec, qtNode ** node, int i);
+void destroyTree(qtNode** t);
+
+//------------------------OTHER FUNCS--------------------------------------//
+int min(int a,int b);

src/c_project_files/union.c

@@ -0,0 +1,47 @@
+#include "union.h"
+
+void unionOfImages(qtNode *t1, qtNode *t2, qtNode **res)
+{
+    (*res) = malloc(sizeof(qtNode));
+    if (t1->topLeft != NULL && t2->topLeft != NULL)
+    {
+        unionOfImages(t1->topLeft, t2->topLeft, &(*res)->topLeft);
+        unionOfImages(t1->topRight, t2->topRight, &(*res)->topRight);
+        unionOfImages(t1->bottomLeft, t2->bottomLeft, &(*res)->bottomLeft);
+        unionOfImages(t1->bottomRight, t2->bottomRight, &(*res)->bottomRight);
+    }
+    else
+    {
+        if (t1->topLeft == NULL && t2->topLeft != NULL)
+        {
+            unionOfImages(t1, t2->topLeft, (&(*res)->topLeft));
+            unionOfImages(t1, t2->topRight, &(*res)->topRight);
+            unionOfImages(t1, t2->bottomLeft, &(*res)->bottomLeft);
+            unionOfImages(t1, t2->bottomRight, &(*res)->bottomRight);
+        }
+        else
+        {
+            if (t1->topLeft != NULL && t2->topLeft == NULL)
+            {
+                unionOfImages(t1->topLeft, t2, &(*res)->topLeft);
+                unionOfImages(t1->topRight, t2, &(*res)->topRight);
+                unionOfImages(t1->bottomLeft, t2, &(*res)->bottomLeft);
+                unionOfImages(t1->bottomRight, t2, &(*res)->bottomRight);
+            }
+            else
+            {
+
+                (*res)->topRight = NULL;
+                (*res)->topLeft = NULL;
+                (*res)->bottomLeft = NULL;
+                (*res)->bottomRight = NULL;
+            }
+        }
+    }
+    (*res)->area = min(t1->area, t2->area);
+    (*res)->p.blue = (t1->p.blue + t2->p.blue) / 2;
+    (*res)->p.red = (t1->p.red + t2->p.red) / 2;
+    (*res)->p.green = (t1->p.green + t2->p.green) / 2;
+
+    return;
+}

src/c_project_files/union.h

@@ -0,0 +1,4 @@
+#include "rotate.h"
+
+void unionOfImages(qtNode *t1, qtNode *t2, qtNode **res);
+