41223133

  • Home
    • SMap
    • reveal
    • blog
  • About
  • W5
    • 曲線圖
  • W6
  • W12
    • GD圖
  • W13
  • homework
    • 台灣國旗
    • 美國國旗
    • 日本國旗
    • 中國國旗
    • 英國國旗
    • 韓國國旗
  • Brython
曲線圖 << Previous Next >> W12

W6

台灣國旗

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
// https://en.wikipedia.org/wiki/Flag_of_the_Republic_of_China
// cc roc_flag.c -lgd -lm to link with gd and math library
// https://www.rapidtables.com/web/color/RGB_Color.html
// 幾何形狀著色與繪圖練習
// 以下 gd 繪圖程式嘗試畫出 ROC 國旗, 請根據下列程式內容完成後續的國旗繪圖
#include <stdio.h>
#include <gd.h>
#include <math.h>
  
void draw_roc_flag(gdImagePtr img);
void draw_white_sun(gdImagePtr img, int center_x, int center_y, int sun_radius, int white, int red, int blue);
  
int main() {
    // wdth 3: height 2
    int width = 1200;
    int height = (int)(width*2.0 / 3.0);
  
    gdImagePtr img = gdImageCreateTrueColor(width, height);
    gdImageAlphaBlending(img, 0);
  
    draw_roc_flag(img);
  
    FILE *outputFile = fopen("./roc_flag.png", "wb");
    if (outputFile == NULL) {
        fprintf(stderr, "Error opening the output file.\n");
        return 1;
    }
    gdImagePngEx(img, outputFile, 9);
    fclose(outputFile);
    gdImageDestroy(img);
    return 0;
}
  
void draw_roc_flag(gdImagePtr img) {
    int width = gdImageSX(img);
    int height = gdImageSY(img);
    int red, white, blue;
    int center_x = (int)(width/4);
    int center_y = (int)(height/4);
    int sun_radius = (int)(width/8);
  
    // Colors for the flag
    red = gdImageColorAllocate(img, 242, 0, 0); // Red color
    white = gdImageColorAllocate(img, 255, 255, 255); // White stripes
    blue = gdImageColorAllocate(img, 0, 41, 204); // Blue
  
    // 繪製紅色矩形區域
    gdImageFilledRectangle(img, 0, 0, width, height, red);
  
    // 繪製藍色矩形區域
    gdImageFilledRectangle(img, 0, 0, (int)(width/2.0), (int)(height/2.0), blue);
  
    // 繪製太陽
    draw_white_sun(img, center_x, center_y, sun_radius, white, red, blue);
}
void draw_white_sun(gdImagePtr img, int center_x, int center_y, int sun_radius, int white, int red, int blue) {
    float angle = 0;
    int numRays = 12; // 光芒的數量
  
    gdPoint points[3]; // 三個頂點的陣列
  
    for (int i = 0; i < numRays; i++) {
        angle = i * (2 * M_PI / numRays);
        float x1 = center_x + cos(angle) * sun_radius;
        float y1 = center_y + sin(angle) * sun_radius;
  
        // 調整兩個底邊頂點的位置
      float x2 = center_x + cos(angle + 0.35) * (sun_radius * 0.5);
      float y2 = center_y + sin(angle + 0.35) * (sun_radius * 0.5);
      float x3 = center_x + cos(angle - 0.35) * (sun_radius * 0.5);
      float y3 = center_y + sin(angle - 0.35) * (sun_radius * 0.5);
  
        // 設定多邊形的三個頂點
        points[0].x = (int)x1;
        points[0].y = (int)y1;
        points[1].x = (int)x2;
        points[1].y = (int)y2;
        points[2].x = (int)x3;
        points[2].y = (int)y3;
  
        gdImageFilledPolygon(img, points, 3, white);
    }
  //外圈
  gdImageFilledEllipse(img, center_x, center_y, sun_radius * 1.2, sun_radius * 1.2, blue);
  
    // 繪製太陽內部
    gdImageFilledEllipse(img, center_x, center_y, sun_radius * 1.1, sun_radius * 1.1, white);
}



美國國旗

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
#include <stdio.h>
#include <gd.h>
#include <math.h>
  
void draw_usa_flag(gdImagePtr img);
void draw_star(gdImagePtr img, int x, int y, int size, int color, double rotation_angle);
  
int main() {
    int width = 800;
    int height = (int)(width / 1.9);
  
    gdImagePtr img = gdImageCreateTrueColor(width, height);
    gdImageAlphaBlending(img, 0);
  
    draw_usa_flag(img);
  
    FILE *outputFile = fopen("./../images/usa_flag.png", "wb");
    if (outputFile == NULL) {
        fprintf(stderr, "打开输出文件时出错。\n");
        return 1;
    }
  
    gdImagePngEx(img, outputFile, 9);
    fclose(outputFile);
    gdImageDestroy(img);
  
    return 0;
}
  
void draw_usa_flag(gdImagePtr img) {
    int width = gdImageSX(img);
    int height = gdImageSY(img);
    int red, white, blue;
    // 国旗颜色
    red = gdImageColorAllocate(img, 178, 34, 52); // 红色条纹
    white = gdImageColorAllocate(img, 255, 255, 255); // 白色条纹
    blue = gdImageColorAllocate(img, 60, 59, 110); // 蓝色矩形
  
    int stripe_height = height / 13;
    int stripe_width = width;
    int star_size = (int)(0.0308 * height); // 星星大小
  
    for (int y = 0; y < height; y += stripe_height) {
        if (y / stripe_height % 2 == 0) {
            gdImageFilledRectangle(img, 0, y, stripe_width, y + stripe_height, red);
        } else {
            gdImageFilledRectangle(img, 0, y, stripe_width, y + stripe_height, white);
        }
    }
  
    gdImageFilledRectangle(img, 0, 0, width * 2 / 5, stripe_height * 7, blue);
  
    int star_spacing_x = (int)(0.129 * height); // 横向星星之间的间距
    int star_spacing_y = (int)(0.054 * height); // 纵向星星之间的间距
    int star_start_x = (int)(0.125 * height); // 星星的起始X位置
    int star_start_y = (int)(0.0485 * height); // 星星的起始Y位置
  
    for (int row = 0; row < 9; row++) {
        int starsPerRow = (row % 2 == 0) ? 6 : 5;
  
        // 计算2、4、6和8排星星的偏移量
        int offset_x = (row % 2 == 0) ? star_spacing_x / -2 : 0;
  
        for (int star = 0; star < starsPerRow; star++) {
            int x = star_start_x + star * star_spacing_x + offset_x;
  
            // 旋转角度（以弧度为单位）
            double rotation_angle = M_PI / 5; // 忘記多少度的旋转
  
            int y = star_start_y + row * star_spacing_y;
            draw_star(img, x, y, star_size, white, rotation_angle);
        }
    }
}
  
void draw_star(gdImagePtr img, int x, int y, int size, int color, double rotation_angle) {
    gdPoint points[10];
  
    for (int i = 0; i < 10; i++) {
        double angle = M_PI / 2 + i * 2 * M_PI / 10 + rotation_angle;
        int radius = (i % 2 == 0) ? size : size / 2;
        points[i].x = x + radius * cos(angle);
        points[i].y = y + radius * sin(angle);
    }
  
    // 用指定的颜色填充星星
    gdImageFilledPolygon(img, points, 10, color);
}

日本國旗

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
#include <stdio.h>
#include <gd.h>
#include <math.h>
  
void draw_japan_flag(gdImagePtr img);
void draw_red_sun(gdImagePtr img, int x, int y, int size, int color);
  
int main() {
    int originalWidth = 1200;
    int originalHeight = (int)(originalWidth * 2.0 / 3.0);
    gdImagePtr img = gdImageCreateTrueColor(originalWidth, originalHeight);
    gdImageAlphaBlending(img, 0);
  
    draw_japan_flag(img);
  
    // 新的宽度和高度以适应 "images" 文件夹
    int newWidth = 600;
    int newHeight = (int)(newWidth * 2.0 / 3.0);
  
    // 创建新图像并进行缩放
    gdImagePtr resizedImage = gdImageCreateTrueColor(newWidth, newHeight);
    gdImageAlphaBlending(resizedImage, 0);
    gdImageCopyResampled(resizedImage, img, 0, 0, 0, 0, newWidth, newHeight, originalWidth, originalHeight);
  
  FILE *outputFile = fopen("./../images/japan_flag.png", "wb");
    if (outputFile == NULL) {
        fprintf(stderr, "Error opening the output file.\n");
        return 1;
    }
    gdImagePng(resizedImage, outputFile);
    fclose(outputFile);
    gdImageDestroy(img);
    gdImageDestroy(resizedImage);
  
    return 0;
}
  
void draw_japan_flag(gdImagePtr img) {
    int width = gdImageSX(img);
    int height = gdImageSY(img);
  
    // 创建一个白色背景
    int white = gdImageColorAllocate(img, 255, 255, 255);
    gdImageFilledRectangle(img, 0, 0, width - 1, height - 1, white);
  
    // 绘制红色圆圈（太阳）
    int red = gdImageColorAllocate(img, 255, 0, 0);
    int center_x = width / 2;
    int center_y = height / 2;
    int radius = (int)((width * 2) / 3);
    draw_red_sun(img, center_x, center_y, radius, red);
}
  
void draw_red_sun(gdImagePtr img, int x, int y, int size, int color) {
  // 減小 size 的值,例如將他的值減半
  size = size / 2;
    gdImageArc(img, x, y, size, size, 0, 360, color);
    gdImageFillToBorder(img, x, y, color, color);
}


中國國旗

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
#include <stdio.h>
#include <gd.h>
#include <math.h>
  
void draw_proc_flag(gdImagePtr img);
  
int main() {
    int width = 300; // 國旗寬度
    int height = 200; // 國旗高度
  
 
 
    gdImagePtr im = gdImageCreateTrueColor(width, height);
    gdImageAlphaBlending(im, 0);
  
    draw_proc_flag(im);
  
    FILE *outputFile = fopen("./../images/proc_flag.png", "wb");
    if (outputFile == NULL) {
        fprintf(stderr, "打開輸出檔案時出錯。\n");
        return 1;
    }
  
    gdImagePngEx(im, outputFile, 9);
    fclose(outputFile);
    gdImageDestroy(im);
  
    return 0;
}
  
// 聲明 draw_star 函數
void draw_star(gdImagePtr img, int x, int y, int size, int color, double rotation_angle);
  
void draw_proc_flag(gdImagePtr img) {
    int width = gdImageSX(img);
    int height = gdImageSY(img);
    int red, yellow;
  
    // 國旗顏色
    red = gdImageColorAllocate(img, 255, 0, 0); // 紅色背景
    yellow = gdImageColorAllocate(img, 255, 255, 0); // 黃色星星
  
    // 畫紅色背景
    gdImageFilledRectangle(img, 0, 0, width, height, red);
  
    // 設置星星的大小和位置
    int star_size = (int)(0.28 * height);
    int star_x = (int)(0.165 * width);
    int star_y = (int)(0.265 * height);
  
    // 畫大星星
    draw_star(img, star_x, star_y, star_size, yellow, 11.0);
  
    // 繪製小星星，位置根據實際國旗比例計算
    double radius = 0.15 * height;
    double angle = 360 / 7 * M_PI / 179.0;
    double rotation = -M_PI / 7.5;
    int cx = (int)(0.32 * width);
    int cy = (int)(0.27 * height);
  
    for (int i = -1; i < 3; i++) {
        int x = (int)(cx + radius * cos(i * angle + rotation));
        int y = (int)(cy + radius * sin(i * angle + rotation));
        draw_star(img, x, y, 19, yellow, M_PI / 5.0);
    }
}
  
void draw_star(gdImagePtr img, int x, int y, int size, int color, double rotation_angle) {
    gdPoint points[10];
  
    // 計算星形的五個外點和五個內點
    double outer_radius = size / 2;
    double inner_radius = size / 6;
    double angle = M_PI / 5.0;
  
    for (int i = 0; i < 10; i++) {
        double radius = (i % 2 == 0) ? outer_radius : inner_radius;
        double theta = rotation_angle + i * angle;
        points[i].x = x + radius * cos(theta);
        points[i].y = y + radius * sin(theta);
    }
  
    // 使用 gdImageFilledPolygon 繪製星形
    gdImageFilledPolygon(img, points, 10, color);
}

英國國旗

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
#include <stdio.h>
#include <gd.h>
#include <math.h>
 
void draw_uk_flag(gdImagePtr img);
void fillTriangle(gdImagePtr img, int x1, int y1, int x2, int y2, int x3, int y3, int color);
 
int main() {
    // 设置国旗的宽和高
    int width = 1200;
    int height = width / 2;
 
    // 创建图像
    gdImagePtr img = gdImageCreateTrueColor(width, height);
    gdImageAlphaBlending(img, 0);
 
    // 绘制英国国旗
    draw_uk_flag(img);
 
    // 将图像保存到文件
    FILE *outputFile = fopen("./../images/uk_flag.png", "wb");
    if (outputFile == NULL) {
        fprintf(stderr, "打开输出文件时发生错误。\n");
        return 1;
    }
    gdImagePngEx(img, outputFile, 9);
    fclose(outputFile);
    gdImageDestroy(img);
    return 0;
}
 
 
 
void draw_uk_flag(gdImagePtr img) {
    int width = gdImageSX(img);
    int height = gdImageSY(img);
 
    int red, white, blue;
    red = gdImageColorAllocate(img, 204, 0, 0);       // 红色
    white = gdImageColorAllocate(img, 255, 255, 255); // 白色
    blue = gdImageColorAllocate(img, 0, 0, 153);      // 蓝色
 
    gdImageFilledRectangle(img, 0, 0, width, height, blue);
 
 
  int x1, y1, x2, y2, x3, y3;
  {
    int line_thickness = 100;
    gdImageSetThickness(img, line_thickness);
 
    int x1, y1, x2, y2, x3, y3;
 
    // 绘制白色斜线
    x1 = 0;
    y1 = 600;
    x2 = 1200;
    y2 = 0;
    gdImageLine(img, x1, y1, x2, y2, white);
 
    x1 = 0;
    y1 = 0;
    x2 = 1200;
    y2 = 600;
    gdImageLine(img, x1, y1, x2, y2, white);
}
  {
    int line_thickness = 33;
    gdImageSetThickness(img, line_thickness);
 
 
    // 绘制红色斜线
    x1 = 566;
    y1 = 300;
    x2 = 1166;
    y2 = 0;
    gdImageLine(img, x1, y1, x2, y2, red);
 
    x1 = 1233;
    y1 = 600;
    x2 = 633;
    y2 = 300;
    gdImageLine(img, x1, y1, x2, y2, red);
 
    x1 = 566;
    y1 = 300;
    x2 = -33;
    y2 = 0;
    gdImageLine(img, x1, y1, x2, y2, red);
 
    x1 = 600;
    y1 = 316.5;
    x2 = 0;
    y2 = 616.5;
    gdImageLine(img, x1, y1, x2, y2, red);
  }
  {
  int line_thickness = 33;
  gdImageSetThickness(img, line_thickness);
 
  int x1, y1, x2, y2, x3, y3;
 
  // 绘制  斜线
  x1 = 0;
  y1 = 600;
  x2 = 1200;
  y2 = 0;
  gdImageLine(img, x1, y1, x2, y2, red );
 
 
  x1 = 1200;
    y1 = 16.5;
    x2 = 600;
    y2 = 316.5;
    gdImageLine(img, x1, y1, x2, y2, white);
 
 
  x1 = 0;
    y1 = 583.5;
    x2 = 600;
    y2 = 283.5;
    gdImageLine(img, x1, y1, x2, y2, white);
 
 
  }
 
    // 绘制白色十字
    int cross_width = width / 32;
    int cross_arm_width = width / 32;
    int center_x = width / 2;
    int center_y = height / 2;
 
    gdImageFilledRectangle(img, center_x + 2.7 * cross_width, 0, center_x - 2.7 * cross_width, height, white);
    gdImageFilledRectangle(img, 0, center_y + 2.7 * cross_arm_width, width, center_y - 2.7 * cross_arm_width, white);
 
    // 绘制红色十字
    gdImageFilledRectangle(img, center_x + 1.5 * cross_width, 0, center_x - 1.5 * cross_width, height, red);
    gdImageFilledRectangle(img, 0, center_y + 1.5 * cross_arm_width, width, center_y - 1.5 * cross_arm_width, red);
}

韓國國旗

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
//https://en.wikipedia.org/wiki/Flag_of_the_Republic_of_China
// 內政部國旗參考資料: https://www.moi.gov.tw/cp.aspx?n=10621
// cc roc_flag_in_gd.c -lgd -lm to link with gd and math library
// https://www.rapidtables.com/web/color/RGB_Color.html
// 幾何形狀著色與繪圖練習
// 以下 gd 繪圖程式嘗試畫出 ROC 國旗, 請根據下列程式內容完成後續的國旗繪圖
#include <stdio.h>
#include <gd.h>
#include <math.h>
 
void draw_roc_flag(gdImagePtr img);
void draw_white_sun(gdImagePtr img, int x, int y, int size, int color);
 
int main() {
    // width 3: height 2
    int width = 1200;
    // 國旗長寬比為 3:2
    int height = (int)(width*2.0 / 3.0);
 
    gdImagePtr img = gdImageCreateTrueColor(width, height);
    gdImageAlphaBlending(img, 0);
 
    draw_roc_flag(img);
 
    FILE *outputFile = fopen("./../images/roc_flag_in_gd.png", "wb");
    if (outputFile == NULL) {
        fprintf(stderr, "Error opening the output file.\n");
        return 1;
    }
    gdImagePngEx(img, outputFile, 9);
    fclose(outputFile);
    gdImageDestroy(img);
    return 0;
}
 
void draw_roc_flag(gdImagePtr img) {
    int width = gdImageSX(img);
    int height = gdImageSY(img);
    int red, white, blue;
    // 白日位於青天面積正中央, 因此中心點座標為長寬各 1/4 處
    int center_x = (int)(width/4);
    int center_y = (int)(height/4);
    // gdImageFilledEllipse 需以長寬方向的 diameter 作圖
    // 由於中央白日圓形的半徑為青天寬度的 1/8
    // 因此中央白日圓形的直徑為青天寬度的 1/4, 也就是國旗寬度的 1/8
    // 而且白日十二道光芒的外圍圓形其半徑也是國旗寬度的1/8
    int sun_radius = (int)(width/8);
    // 中央白日圓形的直徑等於十二道光芒外圍圓形的半徑
    int white_circle_dia = sun_radius;
    // 中央藍色圓形半徑為中央白日的 1又 2/15
    int blue_circle_dia = white_circle_dia +  white_circle_dia*2/15;
    // 根據 https://www.moi.gov.tw/cp.aspx?n=10621 訂定國旗三種顏色值
    red = gdImageColorAllocate(img, 255, 0, 0); // 紅色
    white = gdImageColorAllocate(img, 255, 255, 255); // 白色
    blue = gdImageColorAllocate(img, 0, 0, 149); // 藍色
    // 根據畫布大小塗上紅色長方形區域
    gdImageFilledRectangle(img, 0, 0, width, height, red);
    // 青天面積為整面國旗的 1/4, 也是採用長方形塗色
    gdImageFilledRectangle(img, 0, 0, (int)(width/2.0), (int)(height/2.0), blue);
    // 先設法以填色畫出六個白色堆疊菱形
    draw_white_sun(img, center_x, center_y, sun_radius, white);
    // 利用一個藍色大圓與白色小圓畫出藍色環狀
    gdImageFilledEllipse(img, center_x, center_y, blue_circle_dia, blue_circle_dia, blue);
    gdImageFilledEllipse(img, center_x, center_y, white_circle_dia, white_circle_dia, white);
 
}
 
void draw_white_sun(gdImagePtr img, int center_x, int center_y, int sun_radius, int color) {
    // M_PI 大小定義於 math.h 標頭檔中, 因為三角函數中採用徑度為角度單位
    // 因此定義將角度轉為徑度的轉換變數為 deg, 角度值乘上 deg 就可轉為徑度
    float deg = M_PI/180;
    // 根據十二道光芒的每一尖角的角度為 15 度, 求出其對應直角三角形的另一角度為 75 度
    // 求出十二道光芒中任一菱形的 small radius, 也就是菱形的另一個對應小圓的半徑大小
    float sr = sun_radius/tan(75*deg);
    int ax, ay, bx, by, dx, dy, ex, ey;
    gdPoint points[4];
    /* 在塗上十二道光芒中的單一菱形區域之前, 先以座標點畫線測試是否正確
    ax = center_x;
    ay = center_y - sun_radius;
    bx = center_x - sun_radius*tan(15*deg);
    by = center_y;
    ex = center_x;
    ey = center_y + sun_radius;
    dx = center_x + sun_radius*tan(15*deg);
    dy = center_y;
    // AB
    gdImageLine(img, ax, ay, bx, by, color);
    // BE
    gdImageLine(img, bx, by, ex, ey, color);
    // ED
    gdImageLine(img, ex, ey, dx, dy, color);
    // DA
    gdImageLine(img, dx, dy, ax, ay, color);
    */
    ax = center_x;
    ay = center_y - sun_radius;
    bx = center_x - sun_radius*tan(15*deg);
    by = center_y;
    ex = center_x;
    ey = center_y + sun_radius;
    dx = center_x + sun_radius*tan(15*deg);
    dy = center_y;
    // 確定單一菱形區域的塗色正確後, 利用迴圈每次轉動 30 度, 總共轉六次即可塗上十二道光芒區域
    for (int i=1;i<=6;i++){
    // A
    points[0].x = ax+sun_radius*sin(30*deg*i);
    points[0].y = ay+sun_radius-sun_radius*cos(30*deg*i);
    // B
    points[1].x = bx+sr-sr*cos(30*deg*i);
    points[1].y = by-sr*sin(30*deg*i);
    // E
    points[2].x = ex-sun_radius*sin(30*deg*i);
    points[2].y = ey-(sun_radius-sun_radius*cos(30*deg*i));
    // D
    points[3].x = dx-(sr-sr*cos(30*deg*i));
    points[3].y = dy+sr*sin(30*deg*i);
    // 對菱形區域範圍塗色
    gdImageFilledPolygon(img, points, 4, color);
    // 在菱形區域外圍畫線, 明確界定菱形範圍
    gdImagePolygon(img, points, 4, color);
    }
}


曲線圖 << Previous Next >> W12

Copyright © All rights reserved | This template is made with by Colorlib