Tag: cs50

Disclaimer: These answers are only for educational purposes only. Please do not use them for cheating. Cheating doesn’t do any good for you!

In this post, I’m giving you my solutions to CS50 Problem Set 4 Filter (less comfortable / more comfortable) Problems and Recover problems. Hope these solutions will help you to better understand the problems and be a guide for your solutions too.

The Solution to CS50 Psets 4 Filter Problem – Less Comfortable (2022)

For this problem, we just have to implement a program that applies filters to BMPs. And a bunch of files were provided for us. We have to implement some functions in helpers.c to apply greyscale, Sepia, reflection, and blur filters to the given images.

The greyscale function turns the input image into a black-and-white version of it

// Convert image to grayscale
void grayscale(int height, int width, RGBTRIPLE image[height][width])
{
    // Iterate through each column of pixel
    for (int i = 0; i < height; i++)
    {
        // Iterate through each raw of pixel in each column
        for (int j = 0; j < width; j++)
        {
            // Get into the 2D array, obtain value of each color
            int red = image[i][j].rgbtRed;
            int blue = image[i][j].rgbtBlue;
            int green = image[i][j].rgbtGreen;

            // Calculate the rounded avarage of each pixel
            int average = round(((float)red + (float)blue + (float)green) / 3);

            // Set the calculated value to be the new value of each pixel
            image[i][j].rgbtRed = image[i][j].rgbtBlue = image[i][j].rgbtGreen = average;
        }
    }
}

The sepia function turns the input image into sepia version of the same image

// Convert image to sepia
void sepia(int height, int width, RGBTRIPLE image[height][width])
{
    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            int red = image[i][j].rgbtRed;
            int blue = image[i][j].rgbtBlue;
            int green = image[i][j].rgbtGreen;

            // New sapia values
            int sepiaRed = round(0.393 * red + 0.769 * green + 0.189 * blue);

            if (sepiaRed > 255)
            {
                image[i][j].rgbtRed = 255;
            }
            else
            {
                image[i][j].rgbtRed = sepiaRed;
            }

            int sepiaBlue = round(0.272 * red + 0.534 * green + 0.131 * blue);

            if (sepiaBlue > 255)
            {
                image[i][j].rgbtBlue = 255;
            }
            else
            {
                image[i][j].rgbtBlue = sepiaBlue;
            }

            int sepiaGreen = round(0.349 * red + 0.686 * green + 0.168 * blue);

            if (sepiaGreen > 255)
            {
                image[i][j].rgbtGreen = 255;
            }
            else
            {
                image[i][j].rgbtGreen = sepiaGreen;
            }
        }
    }
}

The reflect function takes the image and reflects in horizontally

// Reflect image horizontally
void reflect(int height, int width, RGBTRIPLE image[height][width])
{
    for (int i = 0; i < height; i++)
    {
        // Iterate through the array until you get the mid point
        for (int j = 0; j < (width / 2); j++)
        {
            RGBTRIPLE temp = image[i][j];

            image[i][j] = image[i][width - (j + 1)];
            image[i][width - (j + 1)] = temp;
        }
    }
    return;
}

The blur function takes an image and turns it into a box-blurred version of the image

// Blur image
void blur(int height, int width, RGBTRIPLE image[height][width])
{
    //create a temporary image to implement blurred algorithm on it.
    RGBTRIPLE temp[height][width];

    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            int sumRed, sumBlue, sumGreen;
            sumRed = sumBlue = sumGreen = 0;
            float counter = 0.00;

            //Get the neighbouring pexels
            for (int c = -1; c < 2; c++)
            {
                for (int r = -1; r < 2; r++)
                {
                    int currentX = i + c;
                    int currentY = j + r;

                    //check for valid neighbouring pexels
                    if (currentX < 0 || currentX > (height - 1) || currentY < 0 || currentY > (width - 1))
                    {
                        continue;
                    }

                    //Get the image value
                    sumRed += image[currentX][currentY].rgbtRed;
                    sumGreen += image[currentX][currentY].rgbtGreen;
                    sumBlue += image[currentX][currentY].rgbtBlue;

                    counter++;
                }

                //do the average of neigbhouring pexels
                temp[i][j].rgbtRed = round(sumRed / counter);
                temp[i][j].rgbtGreen = round(sumGreen / counter);
                temp[i][j].rgbtBlue = round(sumBlue / counter);
            }
        }

    }

    //copy the blurr image to the original image
    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            image[i][j].rgbtRed = temp[i][j].rgbtRed;
            image[i][j].rgbtGreen = temp[i][j].rgbtGreen;
            image[i][j].rgbtBlue = temp[i][j].rgbtBlue;
        }
    }
    return;
}

Full code of helpers.c file

#include "helpers.h"
#include <math.h>

// Convert image to grayscale
void grayscale(int height, int width, RGBTRIPLE image[height][width])
{
    // Iterate through each column of pixel
    for (int i = 0; i < height; i++)
    {
        // Iterate through each raw of pixel in each column
        for (int j = 0; j < width; j++)
        {
            // Get into the 2D array, obtain value of each color
            int red = image[i][j].rgbtRed;
            int blue = image[i][j].rgbtBlue;
            int green = image[i][j].rgbtGreen;

            // Calculate the rounded avarage of each pixel
            int average = round(((float)red + (float)blue + (float)green) / 3);

            // Set the calculated value to be the new value of each pixel
            image[i][j].rgbtRed = image[i][j].rgbtBlue = image[i][j].rgbtGreen = average;
        }
    }
}

// Convert image to sepia
void sepia(int height, int width, RGBTRIPLE image[height][width])
{
    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            int red = image[i][j].rgbtRed;
            int blue = image[i][j].rgbtBlue;
            int green = image[i][j].rgbtGreen;

            // New sapia values
            int sepiaRed = round(0.393 * red + 0.769 * green + 0.189 * blue);

            if (sepiaRed > 255)
            {
                image[i][j].rgbtRed = 255;
            }
            else
            {
                image[i][j].rgbtRed = sepiaRed;
            }

            int sepiaBlue = round(0.272 * red + 0.534 * green + 0.131 * blue);

            if (sepiaBlue > 255)
            {
                image[i][j].rgbtBlue = 255;
            }
            else
            {
                image[i][j].rgbtBlue = sepiaBlue;
            }

            int sepiaGreen = round(0.349 * red + 0.686 * green + 0.168 * blue);

            if (sepiaGreen > 255)
            {
                image[i][j].rgbtGreen = 255;
            }
            else
            {
                image[i][j].rgbtGreen = sepiaGreen;
            }
        }
    }
}

// Reflect image horizontally
void reflect(int height, int width, RGBTRIPLE image[height][width])
{
    for (int i = 0; i < height; i++)
    {
        // Iterate through the array until you get the mid point
        for (int j = 0; j < (width / 2); j++)
        {
            RGBTRIPLE temp = image[i][j];

            image[i][j] = image[i][width - (j + 1)];
            image[i][width - (j + 1)] = temp;
        }
    }
    return;
}


// Blur image
void blur(int height, int width, RGBTRIPLE image[height][width])
{
    //create a temporary image to implement blurred algorithm on it.
    RGBTRIPLE temp[height][width];

    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            int sumRed, sumBlue, sumGreen;
            sumRed = sumBlue = sumGreen = 0;
            float counter = 0.00;

            //Get the neighbouring pexels
            for (int c = -1; c < 2; c++)
            {
                for (int r = -1; r < 2; r++)
                {
                    int currentX = i + c;
                    int currentY = j + r;

                    //check for valid neighbouring pexels
                    if (currentX < 0 || currentX > (height - 1) || currentY < 0 || currentY > (width - 1))
                    {
                        continue;
                    }

                    //Get the image value
                    sumRed += image[currentX][currentY].rgbtRed;
                    sumGreen += image[currentX][currentY].rgbtGreen;
                    sumBlue += image[currentX][currentY].rgbtBlue;

                    counter++;
                }

                //do the average of neigbhouring pexels
                temp[i][j].rgbtRed = round(sumRed / counter);
                temp[i][j].rgbtGreen = round(sumGreen / counter);
                temp[i][j].rgbtBlue = round(sumBlue / counter);
            }
        }

    }

    //copy the blurr image to the original image
    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            image[i][j].rgbtRed = temp[i][j].rgbtRed;
            image[i][j].rgbtGreen = temp[i][j].rgbtGreen;
            image[i][j].rgbtBlue = temp[i][j].rgbtBlue;
        }
    }
    return;
}

The Solution to CS50 Psets 4 Filter Problem – More Comfortable (2022)

For this problem also, we have to implement a program that applies filters to BMPs. And a bunch of files were provided for us. We have to implement some functions in helpers.c to apply greyscale, reflection, blur, and edge filters to the given images.

The greyscale function should take an image and turn it into a black-and-white version of the same image.

// Convert image to grayscale
void grayscale(int height, int width, RGBTRIPLE image[height][width])
{
    // Iterate though each column
    for (int i = 0; i < height; i++)
    {
        // Iterate through each raw of pixel in each column
        for (int j = 0; j < width; j++)
        {
            // Get into 2D array and obtain value of each color
            int red = image[i][j].rgbtRed;
            int blue = image[i][j].rgbtBlue;
            int green = image[i][j].rgbtGreen;

            // Calculate the rounded avarage of each pixel
            int average = round(((float)red + (float)blue + (float)green) / 3);

            // Set the calculated value to be the new value of each pixel
            image[i][j].rgbtRed = image[i][j].rgbtBlue = image[i][j].rgbtGreen = average;
        }
    }
    return;
}

The reflection function should take an image and reflect it horizontally

// Reflect image horizontally
void reflect(int height, int width, RGBTRIPLE image[height][width])
{
    for (int i = 0; i < height; i++)
    {
        // Iterate through the array until you get the mid point
        for (int j = 0; j < (width / 2); j++)
        {
            RGBTRIPLE temp = image[i][j];

            image[i][j] = image[i][width - (j + 1)];
            image[i][width - (j + 1)] = temp;
        }
    }
    return;
}

The blur function takes and image and turns it into a box-blurred version of the same image.

// Blur image
void blur(int height, int width, RGBTRIPLE image[height][width])
{
    //create a temporary image to implement blurred algorithm on it.
    RGBTRIPLE temp[height][width];

    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            int sumRed, sumBlue, sumGreen;
            sumRed = sumBlue = sumGreen = 0;
            float counter = 0.00;

            //Get the neighbouring pexels
            for (int c = -1; c < 2; c++)
            {
                for (int r = -1; r < 2; r++)
                {
                    int currentX = i + c;
                    int currentY = j + r;

                    //check for valid neighbouring pexels
                    if (currentX < 0 || currentX > (height - 1) || currentY < 0 || currentY > (width - 1))
                    {
                        continue;
                    }

                    //Get the image value
                    sumRed += image[currentX][currentY].rgbtRed;
                    sumGreen += image[currentX][currentY].rgbtGreen;
                    sumBlue += image[currentX][currentY].rgbtBlue;

                    counter++;
                }

                //do the average of neigbhouring pexels
                temp[i][j].rgbtRed = round(sumRed / counter);
                temp[i][j].rgbtGreen = round(sumGreen / counter);
                temp[i][j].rgbtBlue = round(sumBlue / counter);
            }
        }

    }

    //copy the blurr image to the original image
    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            image[i][j].rgbtRed = temp[i][j].rgbtRed;
            image[i][j].rgbtGreen = temp[i][j].rgbtGreen;
            image[i][j].rgbtBlue = temp[i][j].rgbtBlue;
        }
    }
    return;
}

The edges function takes an image and highlight the edges between objects, according to the sobel operator.

// Detect edges
void edges(int height, int width, RGBTRIPLE image[height][width])
{
    RGBTRIPLE temp[height][width];

    int gx[3][3] = {{-1, 0, 1}, {-2, 0, 2}, {-1, 0, 1}};
    int gy[3][3] = {{-1, -2, -1}, {0, 0, 0}, {1, 2, 1}};

    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            float gxRed = 0;
            float gyRed = 0;
            float gxGreen = 0;
            float gyGreen = 0;
            float gxBlue = 0;
            float gyBlue = 0;

            for (int col = -1; col < 2; col++)
            {
                for (int row = -1; row < 2; row++)
                {
                    if (i + col < 0 || i + col > height - 1)
                    {
                        continue;
                    }
                    if (j + row < 0 || j + row > width - 1)
                    {
                        continue;
                    }

                    gxRed += image[i + col][j + row].rgbtRed * gx[col + 1][row + 1];
                    gyRed += image[i + col][j + row].rgbtRed * gy[col + 1][row + 1];
                    gxGreen += image[i + col][j + row].rgbtGreen * gx[col + 1][row + 1];
                    gyGreen += image[i + col][j + row].rgbtGreen * gy[col + 1][row + 1];
                    gxBlue += image[i + col][j + row].rgbtBlue * gx[col + 1][row + 1];
                    gyBlue += image[i + col][j + row].rgbtBlue * gy[col + 1][row + 1];
                }
            }

            int red = round(sqrt(gxRed * gxRed + gyRed * gyRed));
            int green = round(sqrt(gxGreen * gxGreen + gyGreen * gyGreen));
            int blue = round(sqrt(gxBlue * gxBlue + gyBlue * gyBlue));

            // Cap at 255
            if (red > 255)
            {
                red = 255;
            }
            if (green > 255)
            {
                green = 255;
            }
            if (blue > 255)
            {
                blue = 255;
            }

            // Assign new values to pixels
            temp[i][j].rgbtRed = red;
            temp[i][j].rgbtGreen = green;
            temp[i][j].rgbtBlue = blue;
        }
    }

    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            image[i][j] = temp[i][j];
        }
    }

    return;
}

Full solution to cs50 psets 4 filter – more comfortable problem

#include "helpers.h"
#include <math.h>

// Convert image to grayscale
void grayscale(int height, int width, RGBTRIPLE image[height][width])
{
    // Iterate though each column
    for (int i = 0; i < height; i++)
    {
        // Iterate through each raw of pixel in each column
        for (int j = 0; j < width; j++)
        {
            // Get into 2D array and obtain value of each color
            int red = image[i][j].rgbtRed;
            int blue = image[i][j].rgbtBlue;
            int green = image[i][j].rgbtGreen;

            // Calculate the rounded avarage of each pixel
            int average = round(((float)red + (float)blue + (float)green) / 3);

            // Set the calculated value to be the new value of each pixel
            image[i][j].rgbtRed = image[i][j].rgbtBlue = image[i][j].rgbtGreen = average;
        }
    }
    return;
}

// Reflect image horizontally
void reflect(int height, int width, RGBTRIPLE image[height][width])
{
    for (int i = 0; i < height; i++)
    {
        // Iterate through the array until you get the mid point
        for (int j = 0; j < (width / 2); j++)
        {
            RGBTRIPLE temp = image[i][j];

            image[i][j] = image[i][width - (j + 1)];
            image[i][width - (j + 1)] = temp;
        }
    }
    return;
}

// Blur image
void blur(int height, int width, RGBTRIPLE image[height][width])
{
    //create a temporary image to implement blurred algorithm on it.
    RGBTRIPLE temp[height][width];

    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            int sumRed, sumBlue, sumGreen;
            sumRed = sumBlue = sumGreen = 0;
            float counter = 0.00;

            //Get the neighbouring pexels
            for (int c = -1; c < 2; c++)
            {
                for (int r = -1; r < 2; r++)
                {
                    int currentX = i + c;
                    int currentY = j + r;

                    //check for valid neighbouring pexels
                    if (currentX < 0 || currentX > (height - 1) || currentY < 0 || currentY > (width - 1))
                    {
                        continue;
                    }

                    //Get the image value
                    sumRed += image[currentX][currentY].rgbtRed;
                    sumGreen += image[currentX][currentY].rgbtGreen;
                    sumBlue += image[currentX][currentY].rgbtBlue;

                    counter++;
                }

                //do the average of neigbhouring pexels
                temp[i][j].rgbtRed = round(sumRed / counter);
                temp[i][j].rgbtGreen = round(sumGreen / counter);
                temp[i][j].rgbtBlue = round(sumBlue / counter);
            }
        }

    }

    //copy the blurr image to the original image
    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            image[i][j].rgbtRed = temp[i][j].rgbtRed;
            image[i][j].rgbtGreen = temp[i][j].rgbtGreen;
            image[i][j].rgbtBlue = temp[i][j].rgbtBlue;
        }
    }
    return;
}

// Detect edges
void edges(int height, int width, RGBTRIPLE image[height][width])
{
    RGBTRIPLE temp[height][width];

    int gx[3][3] = {{-1, 0, 1}, {-2, 0, 2}, {-1, 0, 1}};
    int gy[3][3] = {{-1, -2, -1}, {0, 0, 0}, {1, 2, 1}};

    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            float gxRed = 0;
            float gyRed = 0;
            float gxGreen = 0;
            float gyGreen = 0;
            float gxBlue = 0;
            float gyBlue = 0;

            for (int col = -1; col < 2; col++)
            {
                for (int row = -1; row < 2; row++)
                {
                    if (i + col < 0 || i + col > height - 1)
                    {
                        continue;
                    }
                    if (j + row < 0 || j + row > width - 1)
                    {
                        continue;
                    }

                    gxRed += image[i + col][j + row].rgbtRed * gx[col + 1][row + 1];
                    gyRed += image[i + col][j + row].rgbtRed * gy[col + 1][row + 1];
                    gxGreen += image[i + col][j + row].rgbtGreen * gx[col + 1][row + 1];
                    gyGreen += image[i + col][j + row].rgbtGreen * gy[col + 1][row + 1];
                    gxBlue += image[i + col][j + row].rgbtBlue * gx[col + 1][row + 1];
                    gyBlue += image[i + col][j + row].rgbtBlue * gy[col + 1][row + 1];
                }
            }

            int red = round(sqrt(gxRed * gxRed + gyRed * gyRed));
            int green = round(sqrt(gxGreen * gxGreen + gyGreen * gyGreen));
            int blue = round(sqrt(gxBlue * gxBlue + gyBlue * gyBlue));

            // Cap at 255
            if (red > 255)
            {
                red = 255;
            }
            if (green > 255)
            {
                green = 255;
            }
            if (blue > 255)
            {
                blue = 255;
            }

            // Assign new values to pixels
            temp[i][j].rgbtRed = red;
            temp[i][j].rgbtGreen = green;
            temp[i][j].rgbtBlue = blue;
        }
    }

    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            image[i][j] = temp[i][j];
        }
    }

    return;
}

The Solution to CS50 Psets 4 Recover Problem (2022)

For this problem, we have to implement a C program that will recover JPEG images from a forensic images. So we have to write our code in recover.c file. So here is my solution to this problem.

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>


int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        printf("Usage: ./recover card.raw\n");
        return 1;
    }
    // Open file for read
    FILE *i = fopen(argv[1], "r");
    //If fail to open input file retun error message "Could not open file"
    if (i == NULL)
    {
        printf("Could not open file");
        return 2;
    }

    //declare a variable to unsigned char to store 512 chunks array
    unsigned char buffer[512];

    //declare a variable to count image later in the loop
    int c = 0;

    //file pointer use to output data gotten from input file
    FILE *o = NULL;

    char *f = malloc(8 * sizeof(char));
    // char file[8];

    //Read 512 bytes from input file and store on the buffer
    while (fread(buffer, sizeof(char), 512, i))
    {
        //check if bytes are from a JPEG
        if (buffer[0] == 0xff && buffer[1] == 0xd8 && buffer[2] == 0xff && (buffer[3] & 0xf0) == 0xe0)
        {
            //write jpeg inot file name in form 001.jpg, 002.jpg and so on
            sprintf(f, "%03i.jpg", c);

            //open output file for writing
            o = fopen(f, "w");

            //count number of images found
            c++;
        }

        //Check if output have been used for valid input
        if (o != NULL)
        {
            fwrite(buffer, sizeof(char), 512, o);
        }
    }

    free(f);
    fclose(o);
    fclose(i);
}

Hope these code solutions help you to solve your problems little bit easier. If it helps consider sharing with your friends that will need these solutions.