Harvard CS50 学习笔记（四）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

// Modifies the volume of an audio file

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

// Number of bytes in .wav header
const int HEADER_SIZE = 44;

int main(int argc, char *argv[])
{
    // Check command-line arguments
    if (argc != 4)
    {
        printf("Usage: ./volume input.wav output.wav factor\n");
        return 1;
    }

    // Open files and determine scaling factor
    FILE *input = fopen(argv[1], "r");
    if (input == NULL)
    {
        printf("Could not open file.\n");
        return 1;
    }

    FILE *output = fopen(argv[2], "w");
    if (output == NULL)
    {
        printf("Could not open file.\n");
        return 1;
    }

    float factor = atof(argv[3]);

    // TODO: Copy header from input file to output file
    uint8_t header[HEADER_SIZE];
    int length1 = sizeof(header)/sizeof(uint8_t);

    fread(header, length1, 1, input);
    fwrite(header, length1, 1, output);

    // TODO: Read samples from input file and write updated data to output file

      // 注释掉的方法，确实可以完成需求，但是不能通过检测
    // int16_t buffer[4096];
    // int length2 = sizeof(buffer)/sizeof(int16_t);
    // while (!feof(input)) {
    //     fread(buffer, length2, 1, input);

    //     for (int i = 0; i< length2; i++) {

    //         buffer[i] *= factor;
    //     }
    //     fwrite(buffer, length2, 1, output);
    // }

    int16_t buffer;
    while(fread(&buffer, sizeof(int16_t), 1, input)) {
        buffer *= factor;
        fwrite(&buffer, sizeof(int16_t), 1, output);
    }


    // Close files
    fclose(input);
    fclose(output);
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

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


// Convert image to grayscale
void grayscale(int height, int width, RGBTRIPLE image[height][width])
{
    for (int i = 0; i < height; i++) {
        for (int j = 0; j < width; j++) {
          	// 求平均即可
            BYTE average = round((image[i][j].rgbtBlue + image[i][j].rgbtGreen + image[i][j].rgbtRed) / 3.0);
            image[i][j].rgbtBlue = average;
            image[i][j].rgbtGreen = average;
            image[i][j].rgbtRed = average;
        }
    }
    return;
}

// Reflect image horizontally
void reflect(int height, int width, RGBTRIPLE image[height][width])
{

    for (int i = 0; i < height; i++) {
        for (int j = 0; j < (width / 2); j++) {
          	// 调换顺序即可
            RGBTRIPLE temp;
            temp = image[i][j];
            image[i][j] = image[i][width - 1 - j];
            image[i][width - j - 1] = temp;
        }
    }

    return;
}

// Blur image
void blur(int height, int width, RGBTRIPLE image[height][width])
{
  	// 用一个新图片储存改变后的数据，修改原图片会导致计算异常
    RGBTRIPLE temp[height][width];
    for (int i = 0; i < height; i++) {
        for (int j = 0; j < width; j++) {
          	// 数组记录每个像素的相对坐标
            int arr[] = {-1, 0, 1};
            int red = 0;
            int blue = 0;
            int green = 0;
          	// 记录参与计算的像素数
            int count = 0;
            for (int k = 0; k < sizeof(arr)/sizeof(int); k++) {
                for (int l = 0; l < sizeof(arr)/sizeof(int); l++) {
                    int x = j + arr[l];
                    int y = i + arr[k];
                  	// 越界情况排除
                    if (x < 0 || x >= width || y < 0 || y >= height) {
                        continue;
                    } else {
                        red += image[y][x].rgbtRed;
                        blue += image[y][x].rgbtBlue;
                        green += image[y][x].rgbtGreen;
                        count++;
                    }
                }
            }
        // 计算
        temp[i][j].rgbtRed = round(red * 1.0 / count);
        temp[i][j].rgbtBlue = round(blue * 1.0 / count);
        temp[i][j].rgbtGreen = round(green * 1.0 / count);
        }
    }
  	// 新图片替代旧图片
    for (int i = 0; i < height; i++) {
        for (int j = 0; j < width; j++) {
            image[i][j] = temp[i][j];
        }
    }
    return;
}

// Detect edges
void edges(int height, int width, RGBTRIPLE image[height][width])
{
  	// 用一个新图片储存改变后的数据，修改原图片会导致计算异常
    RGBTRIPLE temp[height][width];
    for (int i = 0; i < height; i++) {
        for (int j = 0; j < width; j++) {
          	// 数组记录每个像素的相对坐标
            int arr[] = {-1, 0, 1};
            int redX = 0;
            int blueX = 0;
            int greenX = 0;
            int redY = 0;
            int blueY = 0;
            int greenY = 0;
          	// 记录计算次数（总共2次）
            int count = 0;
            while (count < 2) {
              	// X 方向计算
                for (int k = 0; k < sizeof(arr)/sizeof(int); k++) {
                    for (int l = 0; l < sizeof(arr)/sizeof(int); l++) {
                        int x = j + arr[l];
                        int y = i + arr[k];
                        if (count == 0) {
                            if (y != i) {
                                if (x < 0 || x >= width || y < 0 || y >= height) {
                                    continue;
                                }
                                redX += image[y][x].rgbtRed * arr[l];
                                blueX += image[y][x].rgbtBlue * arr[l];
                                greenX += image[y][x].rgbtGreen * arr[l];
                            } else {
                                if (x < 0 || x >= width || y < 0 || y >= height) {
                                    continue;
                                }
                                redX += image[y][x].rgbtRed * arr[l] * 2;
                                blueX += image[y][x].rgbtBlue * arr[l] * 2;
                                greenX += image[y][x].rgbtGreen * arr[l] * 2;
                            }

                        }
                      	// Y 方向计算
                        if (count == 1) {
                            if (x != j) {
                                if (x < 0 || x >= width || y < 0 || y >= height) {
                                    continue;
                                }
                                redY += image[y][x].rgbtRed * arr[k];
                                blueY += image[y][x].rgbtBlue * arr[k];
                                greenY += image[y][x].rgbtGreen * arr[k];
                            } else {
                                if (x < 0 || x >= width || y < 0 || y >= height) {
                                    continue;
                                }
                                redY += image[y][x].rgbtRed * arr[k] * 2;
                                blueY += image[y][x].rgbtBlue * arr[k] * 2;
                                greenY += image[y][x].rgbtGreen * arr[k] * 2;
                            }

                        }
                    }
                }
                count++;
            }
          	// 计算
            temp[i][j].rgbtRed = ((round(fabs(sqrt(redX * redX + redY * redY)))) > 255) ? 255 : round(fabs(sqrt(redX * redX + redY * redY)));
            temp[i][j].rgbtBlue = ((round(fabs(sqrt(blueX * blueX + blueY * blueY)))) > 255) ? 255 : round(fabs(sqrt(blueX * blueX + blueY * blueY)));
            temp[i][j].rgbtGreen = ((round(fabs(sqrt(greenX * greenX + greenY * greenY)))) > 255) ? 255 : round(fabs(sqrt(greenX * greenX + greenY * greenY)));
        }
    }
  	// 新图片替代旧图片
    for (int i = 0; i < height; i++) {
        for (int j = 0; j < width; j++) {
            image[i][j] = temp[i][j];
        }
    }
    return;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

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

int main(int argc, char *argv[])
{
    if (argc != 2) {
        printf("Usage: ./recover image\n");
        return 1;
    }

    FILE *file = fopen(argv[1], "r");
    if (file == NULL)
    {
        printf("Could not open file.\n");
        return 1;
    }

  	// jpg 的头
    char first = 0xff;
    char second = 0xd8;
    char third = 0xff;
    int fourth = 0xe0;

  	// 文件名
    int name = -1;

    FILE *img = NULL;
    bool flag = false;
    char buffer[512];

  	// 循环读
    while(fread(buffer, sizeof(char), 512, file)) {

        if (buffer[0] == first && buffer[1] == second && buffer[2] == third && (buffer[3] & 0xf0) == fourth) {

            flag = true;

          	// 第一次不关闭，之后先关闭旧文件，再打开新文件
            if (name != -1) {
                fclose(img);
            }

            name++;
            char fileName[8];
            sprintf(fileName, "%03i.jpg", name);
            img = fopen(fileName, "a");

        }

        if (flag) {
            fwrite(buffer, sizeof(char), 512, img);
        }

    }

    fclose(file);
    return 0;
}