# dddddd 

**Repository Path**: zhao-yingchi916/dddddd

## Basic Information

- **Project Name**: dddddd 
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-10-12
- **Last Updated**: 2025-10-12

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# 数字图像处理实验一：图像基础操作

## 环境要求
- Python 3.8+（推荐 3.9/3.10）
- 必需库：
  - numpy
  - matplotlib
  - scikit-image
  - Pillow
- 推荐在虚拟环境中安装依赖，并在 Jupyter Notebook 中运行实验代码。

建议的 `requirements.txt`
```
numpy>=1.20
matplotlib>=3.0
scikit-image>=0.16
Pillow>=8.0
```

## 文件说明
- `Untitled.ipynb` / `.ipynb_checkpoints/Untitled-checkpoint.ipynb`
  - 内容概览：多个练习单元，演示像素访问、局部/整体通道操作、通道分离、条纹效果等。
  - 对应代码（读取并显示图像）：
```python
from skimage import io
import matplotlib.pyplot as plt

img = io.imread('x.jpg')
print('shape, dtype:', img.shape, img.dtype)
plt.imshow(img)
plt.axis('off')
plt.show()
```

  - 原始代码（来自 `Untitled-checkpoint.ipynb`，读取并显示图像的单元）：
```python
from skimage import io  # 从名为'skimage'的库中导入'io'模块，这个模块通常用于读取图像
import matplotlib.pyplot as plt  # 从'matplotlib'库中导入'pyplot'模块，并给它起了个简称'plt'，用于绘图

img = io.imread('x.jpg')  # 使用导入的'io'模块中的'imread'函数读取名为'x.jpg'的图像，并将其存储在变量'img'中

# 接下来这部分是对图像像素值的操作
rgb = img[0,0]  # 获取图像左上角（第 0 行第 0 列）像素的颜色值，并将其存储在'rgb'变量中
print(rgb)  # 打印出这个像素的原始颜色值

rgb[0]=255  # 将这个像素的第一个颜色通道的值修改为 255（可能是红色通道）
print(rgb)  # 再次打印这个像素的颜色值，此时第一个通道的值已被修改

# 使用'matplotlib.pyplot'模块来显示图像
plt.imshow(img)  # 使用'imshow'函数显示图像
plt.show()  # 显示绘制的图像
```

- `x.jpg`
  - 用途：像素级示例（左上角像素演示、小区域标注、区域颜色替换）。
  - 对应代码（读取左上像素并修改 — 稳健写法示例）：
```python
import numpy as np
from skimage import io
img = io.imread('x.jpg').astype(np.uint8)
pix = img[0,0].copy()
pix[0] = 255
img[0,0] = pix
```

  - 原始代码（来自 `Untitled-checkpoint.ipynb`，直接访问左上像素的原始单元）：
```python
from skimage import io  # 从名为'skimage'的库中导入'io'模块，这个模块通常用于读取图像
import matplotlib.pyplot as plt  # 从'matplotlib'库中导入'pyplot'模块，并给它起了个简称'plt'，用于绘图

img = io.imread('x.jpg')  # 使用导入的'io'模块中的'imread'函数读取名为'x.jpg'的图像，并将其存储在变量'img'中

# 接下来这部分是对图像像素值的操作
rgb = img[0,0]  # 获取图像左上角（第 0 行第 0 列）像素的颜色值，并将其存储在'rgb'变量中
print(rgb)  # 打印出这个像素的原始颜色值

rgb[0]=255  # 将这个像素的第一个颜色通道的值修改为 255（可能是红色通道）
print(rgb)  # 再次打印这个像素的颜色值，此时第一个通道的值已被修改

# 使用'matplotlib.pyplot'模块来显示图像
plt.imshow(img)  # 使用'imshow'函数显示图像
plt.show()  # 显示绘制的图像
```

- `earth.jpg`
  - 用途：条纹/通道示例（按列交替改变 R/G/B）。
  - 推荐向量化（性能更好）示例：
```python
import numpy as np
from skimage import io
img = io.imread('earth.jpg')
if img.ndim == 2:
    img = np.stack([img]*3, axis=-1)
img[:, 0::3, 0] = 255
img[:, 1::3, 1] = 255
img[:, 2::3, 2] = 255
```

  - 原始代码（来自 `Untitled-checkpoint.ipynb`，逐像素循环实现）：
```python
from skimage import io  
import matplotlib.pyplot as plt  # 从'matplotlib'库中导入用于绘图的'pyplot'模块，并简称为'plt'

img = io.imread('earth.jpg')  # 使用'io'模块中的'imread'函数读取图像'x.jpg'，并将其存储在'img'变量中

h, w, c = img.shape  # 将图像的高度、宽度和通道数分别存储在变量'h'、'w'和'c'中

# 下面使用一个循环遍历图像的每一列
for i in range(w):  
    for j in range(h):  
        if i%3==0:
            img[j, i][0] = 255

        elif i%3==1:
            img[j, i][1] = 255
        else:
            img[j, i][2] = 255
            
plt.figure(figsize=(15,15))
plt.imshow(img)  
plt.show()  
```

- `galaxy-full.jpg`
  - 用途：通道分离示例（仅显示 R / G / B 通道）。
  - Pillow 示例（只保留 R）：
```python
from PIL import Image
import matplotlib.pyplot as plt

image = Image.open('galaxy-full.jpg')
r, g, b = image.split()
r_only = Image.merge("RGB", (r, Image.new("L", r.size, 0), Image.new("L", r.size, 0)))
plt.imshow(r_only)
plt.axis('off')
plt.show()
```

  - 原始代码（来自 `Untitled-checkpoint.ipynb`，分离并合并 R 通道的单元）：
```python
from PIL import Image
import matplotlib.pyplot as plt

# 打开原始图片
image = Image.open('galaxy-full.jpg')

# 分离图像的 RGB 通道
r, g, b = image.split()

# 创建新的图像，仅使用红色通道，将绿色和蓝色通道设为 0
# 这里通过将绿色和蓝色通道置为全黑，只保留红色通道的信息来模拟右边图片的效果
reg_image = Image.merge("RGB", (r, Image.new("L", r.size, 0), Image.new("L", r.size, 0)))

# 显示最终效果
plt.imshow(reg_image)
plt.show()
```

## 代码示例说明（按图片要点 1–9，包含原始代码片段）

1. 图像上半部分处理  
   - 意图：把上半区 R 通道设为 255。  
   - 推荐（向量化）：
```python
img = io.imread('x.jpg')
img[:img.shape[0]//2, :, 0] = 255
```
   - 原始代码（来自 `Untitled-checkpoint.ipynb`）：
```python
from skimage import io  # 从'skimage'库中导入用于读取图像的'io'模块
import matplotlib.pyplot as plt  # 从'matplotlib'库中导入用于绘图的'pyplot'模块，并简称为'plt'

img = io.imread('x.jpg')  # 使用'io'模块中的'imread'函数读取图像'x.jpg'，并将其存储在'img'变量中

print(img.shape)  # 打印'img'图像的形状，形状通常表示为（高度，宽度，通道数）

h, w, c = img.shape  # 将图像的高度、宽度和通道数分别存储在变量'h'、'w'和'c'中

# 计算高度的一半（只处理上半部分）
half_h = h // 2

# 下面使用循环遍历图像的每一列和上半部分的每一行
for i in range(w):  # 'i'从 0 到图像的宽度 - 1
    # 只遍历高度的一半（0到half_h-1的行）
    for j in range(half_h):  # 'j'从 0 到图像高度的一半 - 1
        img[j, i][0] = 255  # 将上半部分的红色通道值设置为 255

plt.imshow(img)  # 使用'matplotlib.pyplot'的'imshow'函数来显示处理后的图像'img'
plt.show()  # 展示绘制出来的图像
```

2. 图像左半部分处理  
   - 推荐（向量化）：
```python
img[:, :img.shape[1]//2, 0] = 255
```
   - 原始代码（来自 `Untitled-checkpoint.ipynb`）：
```python
from skimage import io  # 从'skimage'库中导入用于读取图像的'io'模块
import matplotlib.pyplot as plt  # 从'matplotlib'库中导入用于绘图的'pyplot'模块，并简称为'plt'

img = io.imread('x.jpg')  # 使用'io'模块中的'imread'函数读取图像'x.jpg'，并将其存储在'img'变量中

print(img.shape)  # 打印'img'图像的形状，形状通常表示为（高度，宽度，通道数）

h, w, c = img.shape  # 将图像的高度、宽度和通道数分别存储在变量'h'、'w'和'c'中

# 计算宽度的一半（只处理左半部分）
half_w = w // 2

# 先遍历高度（所有行），再遍历宽度的一半（左半部分列）
for j in range(h):  # 'j'从 0 到图像的高度 - 1（先遍历高）
    # 只遍历宽度的一半（0到half_w-1的列）
    for i in range(half_w):  # 'i'从 0 到图像宽度的一半 - 1（再遍历宽的一半）
        img[j, i][0] = 255  # 将左半部分的红色通道值设置为 255

plt.imshow(img)  # 使用'matplotlib.pyplot'的'imshow'函数来显示处理后的图像'img'
plt.show()  # 展示绘制出来的图像
```

3. 图像左上四分之一处理  
   - 推荐：
```python
img[:half_h, :half_w, 0] = 255
```
   - 原始代码（来自 `Untitled-checkpoint.ipynb`）：
```python
from skimage import io  # 从'skimage'库中导入用于读取图像的'io'模块
import matplotlib.pyplot as plt  # 从'matplotlib'库中导入用于绘图的'pyplot'模块，并简称为'plt'

img = io.imread('x.jpg')  # 使用'io'模块中的'imread'函数读取图像'x.jpg'，并将其存储在'img'变量中

print(img.shape)  # 打印'img'图像的形状，形状通常表示为（高度，宽度，通道数）

h, w, c = img.shape  # 将图像的高度、宽度和通道数分别存储在变量'h'、'w'和'c'中

# 计算高度和宽度的一半
half_h = h // 2  # 高度的一半
half_w = w // 2  # 宽度的一半

# 先遍历高度的一半，再遍历宽度的一半（只处理左上四分之一区域）
for j in range(half_h):  # 'j'从 0 到高度一半 - 1（只遍历一半高度）
    for i in range(half_w):  # 'i'从 0 到宽度一半 - 1（只遍历一半宽度）
        img[j, i][0] = 255  # 将左上四分之一区域的红色通道值设置为 255

plt.imshow(img)  # 使用'matplotlib.pyplot'的'imshow'函数来显示处理后的图像'img'
plt.show()  # 展示绘制出来的图像
```

4. 小区域像素处理（若干小块变色）  
   - 推荐（按比例）：
```python
h, w = img.shape[:2]
region = (slice(int(0.1*h), int(0.15*h)), slice(int(0.2*w), int(0.25*w)))
img[region] = [255, 0, 0]
```
   - 原始代码（来自 `Untitled-checkpoint.ipynb`）：
```python
from skimage import io
import matplotlib.pyplot as plt
import numpy as np

# 读取左侧图像
img = io.imread('x.jpg')
h, w, c = img.shape

# 定义红色区域的行、列范围（根据实际图像中红色区域的位置调整）
red_regions = [
    (slice(3, 4), slice(4, 5)),
    (slice(3, 4), slice(5, 6)),
    (slice(6, 7), slice(4, 5)),
    (slice(6, 7), slice(5, 6)),
    (slice(4, 6), slice(3, 4)),
    (slice(4, 6), slice(6, 7))
]

# 变成红色
for row, col in red_regions:
    img[row, col] = [255, 0, 0]

# 显示转换后的图像
plt.imshow(img)
plt.show()
```

5. 指定区域颜色处理（白色转黄 + 边框）  
   - 推荐（布尔掩码）：
```python
import numpy as np
img = io.imread('x.jpg').astype(np.uint8)
mask = (img[:,:,0] > 240) & (img[:,:,1] > 240) & (img[:,:,2] > 240)
img[mask] = [255,255,0]
img[0,:,:] = 0
img[-1,:,:] = 0
img[:,0,:] = 0
img[:,-1,:] = 0
```
   - 原始代码（来自 `Untitled-checkpoint.ipynb`，包含原始的白色检测、覆盖绿色通道并画边框的实现）：
```python
from skimage import io
import matplotlib.pyplot as plt

# 读取原始图像
img = io.imread('x.jpg')
print(img.shape)
h, w, c = img.shape

# 第一部分：找到白色方块并转为黄色（RGB: 255,255,0）
# 遍历所有像素，检测白色区域（RGB接近255,255,255）
for i in range(w):
    for j in range(h):
        # 检测白色区域（允许一定误差范围）
        if (img[j, i][0] > 240 and img[j, i][1] > 240 and img[j, i][2] > 240):
            img[j, i] = [255, 255, 0]  # 转为黄色

# 第二部分：遍历并修改绿色通道（将所有像素的绿色通道设为255）
for i in range(w):
    for j in range(h):
        img[j, i][1] = 255  # 修改绿色通道（索引1）

# 第三部分：绘制四条边，RGB 都设为 255（白色边）
# 上边（第 0 行）
for i in range(w):
    img[0, i] = [0, 0, 0]

# 下边（最后一行）
for i in range(w):
    img[h - 1, i] = [0, 0, 0]

# 左边（第 0 列）
for j in range(h):
    img[j, 0] = [0, 0, 0]

# 右边（最后一列）
for j in range(h):
    img[j, w - 1] = [0, 0, 0]
# 显示最终效果
plt.imshow(img)
plt.show()
```

6–8. 星系图像颜色通道处理（R / G / B 分离）  
   - 推荐（Pillow 示例见上文）。  
   - 原始代码（来自 `Untitled-checkpoint.ipynb`）——红色通道单元：
```python
from PIL import Image
import matplotlib.pyplot as plt

# 打开原始图片
image = Image.open('galaxy-full.jpg')

# 分离图像的 RGB 通道
r, g, b = image.split()

# 创建新的图像，仅使用红色通道，将绿色和蓝色通道设为 0
# 这里通过将绿色和蓝色通道置为全黑，只保留红色通道的信息来模拟右边图片的效果
reg_image = Image.merge("RGB", (r, Image.new("L", r.size, 0), Image.new("L", r.size, 0)))

# 显示最终效果
plt.imshow(reg_image)
plt.show()
```
   - 原始绿色通道单元：
```python
from PIL import Image
import matplotlib.pyplot as plt

# 打开原始图片
image = Image.open('galaxy-full.jpg')

# 分离图像的 RGB 通道
r, g, b = image.split()

# 创建新的图像，仅使用绿色通道，将红色和蓝色通道设为 0
green_image = Image.merge("RGB", (Image.new("L", g.size, 0), g, Image.new("L", g.size, 0)))

# 显示最终效果
plt.imshow(green_image)
plt.show()
```
   - 原始蓝色通道单元：
```python
from PIL import Image
import matplotlib.pyplot as plt

# 打开原始图片
image = Image.open('galaxy-full.jpg')

# 分离图像的 RGB 通道
r, g, b = image.split()

# 创建新的图像，仅使用蓝色通道，将红色和绿色通道设为 0
blue_image = Image.merge("RGB", (Image.new("L", b.size, 0), Image.new("L", b.size, 0), b))

# 显示最终效果
plt.imshow(blue_image)
plt.show()
```

9. 条纹效果处理（按列 i%3 设 R/G/B）  
   - 推荐向量化见上文。  
   - 原始代码（来自 `Untitled-checkpoint.ipynb`，最后一个条纹单元）：
```python
from skimage import io  
import matplotlib.pyplot as plt  # 从'matplotlib'库中导入用于绘图的'pyplot'模块，并简称为'plt'

img = io.imread('earth.jpg')  # 使用'io'模块中的'imread'函数读取图像'x.jpg'，并将其存储在'img'变量中

h, w, c = img.shape  # 将图像的高度、宽度和通道数分别存储在变量'h'、'w'和'c'中

# 下面使用一个循环遍历图像的每一列
for i in range(w):  
    for j in range(h):  
        if i%3==0:
            img[j, i][0] = 255

        elif i%3==1:
            img[j, i][1] = 255
        else:
            img[j, i][2] = 255
            
plt.figure(figsize=(15,15))
plt.imshow(img)  
plt.show()  
```

## 使用方法（Windows PowerShell）
1. 在仓库根创建并激活虚拟环境：
```powershell
python -m venv .venv
.\.venv\Scripts\Activate.ps1
```
2. 安装依赖（先保存 `requirements.txt`）：
```powershell
pip install -r requirements.txt
```
3. 启动 Jupyter 并打开 `Untitled.ipynb`：
```powershell
jupyter notebook
# 或
jupyter lab
```
4. 运行前检查：
```python
from skimage import io
img = io.imread('x.jpg')
print(img.shape, img.dtype)
```

## 学习要点
- 图像数组结构：(height, width, channels) 与 dtype（uint8/float）；赋值前请确认。
- 优先使用 NumPy 向量化操作替代嵌套循环以提高性能。
- 原位修改会改变原图：如需保存原始，请使用 `img.copy()`。
- Pillow 与 NumPy 在通道操作上互补，选择合适工具完成任务。
- 避免硬编码坐标，使用参数化/按比例选择区域以增强通用性。

##个人信息
姓名：赵盈池
班级：智能科学与技术1班
学号：202452320121