# 传统方法





程序
```python
import numpy as np
import cv2
def replaceZeroes(data):
    min_nonzero = min(data[np.nonzero(data)])
    data[data == 0] = min_nonzero
    return data
def SSR(src_img, size):
    L_blur = cv2.GaussianBlur(src_img, (size, size), 0)
    img = replaceZeroes(src_img)
    L_blur = replaceZeroes(L_blur)
    dst_Img = cv2.log(img / 255.0)
    dst_Lblur = cv2.log(L_blur / 255.0)
    dst_IxL = cv2.multiply(dst_Img, dst_Lblur)
    log_R = cv2.subtract(dst_Img, dst_IxL)
    dst_R = cv2.normalize(log_R, None, 0, 255, cv2.NORM_MINMAX)
    log_uint8 = cv2.convertScaleAbs(dst_R)
    return log_uint8
# 使用照片修复的办法来去掉图片中的文字
def remove_text1(path):
    size = 3
    src_img = cv2.imread(path)
    # # 膨胀图片
    # src_img = cv2.dilate(src_img, kernel=np.ones((3, 3), dtype=np.uint8), iterations=2)
    # 腐蚀图片
    # src_img = cv2.erode(src_img, kernel=np.ones((3, 3), dtype=np.uint8), iterations=2)
    b_gray, g_gray, r_gray = cv2.split(src_img)
    b_gray = SSR(b_gray, size)
    g_gray = SSR(g_gray, size)
    r_gray = SSR(r_gray, size)
    ssrimg = cv2.merge([b_gray, g_gray, r_gray])
    canny_img = cv2.Canny(ssrimg, 200, 150)
    k = np.ones((3, 3), np.uint8)
    mask = cv2.morphologyEx(canny_img, cv2.MORPH_CLOSE, k)  # 闭运算
    # 对mask进行膨胀
    # mask = cv2.dilate(mask, kernel=np.ones((3, 3), dtype=np.uint8), iterations=6)
    dst = cv2.inpaint(src_img, mask, 3, cv2.INPAINT_TELEA)
    # dst = cv2.inpaint(dst, mask, 3, cv2.INPAINT_TELEA)
    # 膨胀
    dst = cv2.dilate(dst, kernel=np.ones((3, 3), dtype=np.uint8), iterations=5)
    return dst
# 使用mask直接填充颜色的办法来去掉图片中的文字
def remove_text2(path):
    size = 3
    src_img = cv2.imread(path)
    # 腐蚀图片
    # src_img = cv2.erode(src_img, kernel=np.ones((3, 3), dtype=np.uint8), iterations=2)
    b_gray, g_gray, r_gray = cv2.split(src_img)
    b_gray = SSR(b_gray, size)
    g_gray = SSR(g_gray, size)
    r_gray = SSR(r_gray, size)
    ssrimg = cv2.merge([b_gray, g_gray, r_gray])
    canny_img = cv2.Canny(ssrimg, 200, 150)
    k = np.ones((3, 3), np.uint8)
    mask = cv2.morphologyEx(canny_img, cv2.MORPH_CLOSE, k)  # 闭运算
    # 保存mask为图片
    cv2.imwrite("mask.png", mask)
    # mask等于1的区域，用白色填充
    # dst = cv2.bitwise_and(src_img, src_img, mask=mask)
    src_img[mask == 255] = (255, 255, 255)
    # 膨胀
    src_img = cv2.dilate(src_img, kernel=np.ones((3, 3), dtype=np.uint8), iterations=5)
    return src_img
# 移除背景色，增强文字
def remove_ground(path):
    size = 3
    src_img = cv2.imread(path)
    b_gray, g_gray, r_gray = cv2.split(src_img)
    b_gray = SSR(b_gray, size)
    g_gray = SSR(g_gray, size)
    r_gray = SSR(r_gray, size)
    ssrimg = cv2.merge([b_gray, g_gray, r_gray])
    canny_img = cv2.Canny(ssrimg, 200, 150)
    k = np.ones((3, 3), np.uint8)
    mask = cv2.morphologyEx(canny_img, cv2.MORPH_CLOSE, k)  # 闭运算
    # mask等于1的区域，用白色填充
    dst = cv2.bitwise_and(src_img, src_img, mask=mask)
    dst[mask == 0] = (255, 255, 255)
    return dst
if __name__ == '__main__':
    imgPath = "papertext.jpg"
    dst = remove_text2(imgPath)
    cv2.imwrite("result.jpg", dst)
```

原图：

![在这里插入图片描述](/static/img/images/04728.jpeg)

找到文字部分：

![在这里插入图片描述](/static/img/images/04729.png)

去除文字：

![在这里插入图片描述](/static/img/images/04730.jpeg)

保留清晰文字：

![在这里插入图片描述](/static/img/images/04731.jpeg)

# 深度学习

1、

Self-Supervised Text Erasing with Controllable Image Synthesis 即STE ： 论文[https://arxiv.org/abs/2204.12743](https://arxiv.org/abs/2204.12743)。

2、

EnsNet ： [https://blog.csdn.net/u013554402/article/details/104494261](https://blog.csdn.net/u013554402/article/details/104494261)。

3、

[https://paperswithcode.com/paper/mtrnet-one-stage-mask-based-scene-text-eraser](https://paperswithcode.com/paper/mtrnet-one-stage-mask-based-scene-text-eraser)。

4、

[http://www.cjig.cn/html/jig/2022/4/20220420.htm](http://www.cjig.cn/html/jig/2022/4/20220420.htm)





# 译文回填

SickZil-Machine用于去除文本： [https://github.com/KUR-creative/SickZil-Machine](https://github.com/KUR-creative/SickZil-Machine)

lama-cleaner技术：  [https://github.com/Sanster/lama-cleaner](https://github.com/Sanster/lama-cleaner)

【OpenCV】【深度学习】去除图片文字；只保留图片文字；译文回填

原因是png图片里面的profile ，好像又听说高版本的png在做什么。






解决方式很简单，重写一下这个图。


下面程序会读取 r"/ssd/xd/datasets/multilabelsTask/"下面的所有jpg和png图，多进程方式地重写一下图片，注意，如果opencv打不开这个图，这个图会被删除：
```python
import multiprocessing
import os
import cv2
import numpy as np
def listPathAllfiles(dirname):
    result = []
    for maindir, subdir, file_name_list in os.walk(dirname):
        for filename in file_name_list:
            apath = os.path.join(maindir, filename)
            result.append(apath)
    return result
def overwrite(files1):
    for fname in files1:
        try:
            if fname.endswith(".jpg"):
                img = cv2.imdecode(np.fromfile(fname, dtype=np.uint8), 1)  # img是矩阵
                cv2.imencode('.jpg', img)[1].tofile(fname)
            elif fname.endswith(".png"):
                img = cv2.imdecode(np.fromfile(fname, dtype=np.uint8), 1)  # img是矩阵
                cv2.imencode('.png', img)[1].tofile(fname)
        except:
            os.remove(fname)
            print(fname)
if __name__ == '__main__':
    root = r"/ssd/xd/datasets/multilabelsTask/"
    files = listPathAllfiles(root)
    p = multiprocessing.Pool()  # 创建一个包含2个进程的进程池
    # split files to several parts
    for i in range(0, len(files), 10000):
        p.apply_async(func=overwrite, args=(files[i:i + 1000],))  # 往池子里加一个异步执行的子进城
    p.close()  # 等子进程执行完毕后关闭进程池
    p.join()  # 主进程等待
```

【opencv】【python】libpng warning: iCCP: known incorrect sRGB profile 解决

截图目标，分析目标的颜色直方图：





```python
import cv2
from matplotlib import pyplot as plt
def show_img(path):
    img = cv2.imread(path)
    b, g, r = img[:, :, 0], img[:, :, 1], img[:, :, 2]
    hist_b = cv2.calcHist([b], [0], None, [256], [0, 256])
    hist_g = cv2.calcHist([g], [0], None, [256], [0, 256])
    hist_r = cv2.calcHist([r], [0], None, [256], [0, 256])
    plt.figure(figsize=(10, 5))
    plt.subplot(121)
    plt.plot(hist_r, color='r', label="r")
    plt.plot(hist_g, color='g', label="g")
    plt.plot(hist_b, color='b', label="b")
    plt.legend()
    img2 = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
    h, s, v = img2[:, :, 0], img2[:, :, 1], img2[:, :, 2]
    hist_h = cv2.calcHist([h], [0], None, [256], [0, 256])
    hist_s = cv2.calcHist([s], [0], None, [256], [0, 256])
    hist_v = cv2.calcHist([v], [0], None, [256], [0, 256])
    plt.subplot(122)
    plt.plot(hist_h, color='r', label="h")
    plt.plot(hist_s, color='g', label="s")
    plt.plot(hist_v, color='b', label="v")
    plt.legend()
    plt.show()
    return hist_r, hist_g, hist_b, hist_h, hist_s, hist_v
r, g, b, h, s, v = show_img("lanse.png")
```

![在这里插入图片描述](/static/img/images/00262.png)


```
import cv2
import numpy as np
from matplotlib import pyplot as plt
img = cv2.imread("1111.jpg")
hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
lower_red = np.array([115, 0, 160])
upper_red = np.array([140, 30, 190])
mask = cv2.inRange(hsv, lower_red, upper_red)
res = cv2.bitwise_and(img, img, mask=mask)
# cv2.imshow('img', img)
cv2.imshow('mask', mask)
cv2.imshow('res', res)
cv2.waitKey(0)
cv2.destroyAllWindows()
```

Opencv 颜色过滤 Python mask 选取颜色 颜色直方图

# 边缘检测





![在这里插入图片描述](/static/img/images/00263.jpeg)

拉普拉斯边缘分割：

![在这里插入图片描述](/static/img/images/00264.png)

sobel算子：

![在这里插入图片描述](/static/img/images/00265.png)

canny算子：

![在这里插入图片描述](/static/img/images/00266.png)

加了高斯模糊再用canny算子：

![在这里插入图片描述](/static/img/images/00267.png)






参考：

水文标尺识别opencv：[https://blog.csdn.net/sinat_28371057/article/details/109968240](https://blog.csdn.net/sinat_28371057/article/details/109968240)

边缘 图像分割： [https://www.jianshu.com/p/fb48de8120fd](https://www.jianshu.com/p/fb48de8120fd)

图像分割：[https://zhuanlan.zhihu.com/p/70758906](https://zhuanlan.zhihu.com/p/70758906)

水文标尺识别 深度学习 边缘检测 图像分割

修改video_path = 'test1.mp4' 这一句即可，源码地址：https://github.com/hongcyu/char_painting





```python
import cv2
from PIL import Image, ImageFont, ImageDraw
import os
from cv2 import VideoWriter, VideoWriter_fourcc, imread, resize
# =========================
# coding:UTF-8
# 视频转字符画含音频version-1
# 参考1：https://blog.csdn.net/mp624183768/article/details/81161260
# 参考2：https://blog.csdn.net/qq_42820064/article/details/90958577
# 参考3：https://blog.csdn.net/zj360202/article/details/79026891
# =========================
def get_char(r, g, b, alpha=256):
    ascii_char = list(r"#TONGHUIgogoggoWGPZ*@$C&998798213123123128?3345462I1>;\';][.../]'\]!:-;. ")
    # ascii_char = list("#RMNHQODBWGPZ*@$C&98?32I1>!:-;. ")
    # ascii_char = list("$@B%8&WM#*oahkbdpqwmZO0QLCJUYXzcvunxrjft/\|()1{}[]?-_+~<>i!lI;:oa+>!:+. ")
    if alpha == 0:
        return ''
    length = len(ascii_char)
    gray = int(0.2126 * r + 0.7152 * g + 0.0722 * b)
    unit = (256.0 + 1) / len(ascii_char)
    return ascii_char[int(gray / unit)]
# 将视频转换为图片 并进行计数，返回总共生成了多少张图片！
def video_to_pic(vp):
    # vp = cv2.VideoCapture(video_path)
    number = 0
    if vp.isOpened():
        r, frame = vp.read()
        if not os.path.exists('cache_pic'):
            os.mkdir('cache_pic')
        os.chdir('cache_pic')
    else:
        r = False
    while r:
        number += 1
        cv2.imwrite(str(number) + '.jpg', frame)
        r, frame = vp.read()
    print('\n由视频一共生成了{}张图片！'.format(number))
    os.chdir("..")
    return number
def img_to_char(image_path, raw_width, raw_height, task):
    width = int(raw_width / 6)
    height = int(raw_height / 15)
    im = Image.open(image_path).convert('RGB')  # 必须以RGB模式打开
    im = im.resize((width, height), Image.NEAREST)
    txt = ''
    color = []
    for i in range(height):
        for j in range(width):
            pixel = im.getpixel((j, i))
            color.append((pixel[0], pixel[1], pixel[2]))  # 将颜色加入进行索引
            if len(pixel) == 4:
                txt += get_char(pixel[0], pixel[1], pixel[2], pixel[3])
            else:
                txt += get_char(pixel[0], pixel[1], pixel[2])
        txt += '\n'
        color.append((255, 255, 255))
    im_txt = Image.new("RGB", (raw_width, raw_height), (255, 255, 255))
    dr = ImageDraw.Draw(im_txt)
    # font = ImageFont.truetype('consola.ttf', 10, encoding='unic') #改为这个字体会让图片比例改变
    font = ImageFont.load_default().font
    x, y = 0, 0
    font_w, font_h = font.getsize(txt[1])
    font_h *= 1.37  # 调整字体大小
    for i in range(len(txt)):
        if (txt[i] == '\n'):
            x += font_h
            y = -font_w
        dr.text((y, x), txt[i], fill=color[i])
        y += font_w
    os.chdir('cache_char')
    im_txt.save(str(task) + '.jpg')
    os.chdir("..")
    return 0
def star_to_char(number, save_pic_path):
    if not os.path.exists('cache_char'):
        os.mkdir('cache_char')
    img_path_list = [save_pic_path + r'/{}.jpg'.format(i) for i in range(1, number + 1)]  # 生成目标图片文件的路径列表
    task = 0
    for image_path in img_path_list:
        img_width, img_height = Image.open(image_path).size  # 获取图片的分辨率
        task += 1
        img_to_char(image_path, img_width, img_height, task)
        print('{}/{} is finished.'.format(task, number))
    print('=======================')
    print('All image was finished!')
    print('=======================')
    return 0
def process_bar(percent, start_str='', end_str='', total_length=0):
    # 进度条
    bar = ''.join("■ " * int(percent * total_length)) + ''
    bar = '\r' + start_str + bar.ljust(total_length) + ' {:0>4.1f}%|'.format(percent * 100) + end_str
    print(bar, end='', flush=True)
def jpg_to_video(char_image_path, FPS):
    video_fourcc = VideoWriter_fourcc(*"MP42")  # 设置视频编码器,这里使用使用MP42编码器,可以生成更小的视频文件
    char_img_path_list = [char_image_path + r'/{}.jpg'.format(i) for i in range(1, number + 1)]  # 生成目标字符图片文件的路径列表
    char_img_test = Image.open(char_img_path_list[1]).size  # 获取图片的分辨率
    if not os.path.exists('video'):
        os.mkdir('video')
    video_writter = VideoWriter('video/new_char_video.avi', video_fourcc, FPS, char_img_test)
    sum = len(char_img_path_list)
    count = 0
    for image_path in char_img_path_list:
        img = cv2.imread(image_path)
        video_writter.write(img)
        end_str = '100%'
        count = count + 1
        process_bar(count / sum, start_str='', end_str=end_str, total_length=15)
    video_writter.release()
    print('\n')
    print('=======================')
    print('The video is finished!')
    print('=======================')
if __name__ == '__main__':
    video_path = 'test1.mp4'
    save_pic_path = 'cache_pic'
    save_charpic_path = 'cache_char'
    vp = cv2.VideoCapture(video_path)
    number = video_to_pic(vp)
    FPS = vp.get(cv2.CAP_PROP_FPS)
    star_to_char(number, save_pic_path)
    vp.release()
    jpg_to_video(save_charpic_path, FPS)
```

还是有人不会用，下面具体一点。前提是你会python，你需要有python环境。

安装程序的依赖包：
```
pip install opencv-python pillow
```

把代码弄进去，同级目录下加入一个test1.mp4，然后直接运行代码。

![在这里插入图片描述](/static/img/images/00311.png)

就能得到效果视频了：

![在这里插入图片描述](/static/img/images/00312.gif)

Python 井川里予 当程序员看多了 程序 生成 字符画

OpenCV





```python
img = cv2.imread(os.path.join(filepath, name))
dst = cv2.resize(img, (img.shape[1]//4, img.shape[0]//4))
cv2.imwrite(os.path.join(aimpath, "image" + str(num).zfill(6)) + ".jpg", dst)
```

Python opencv 图像缩放

# 何为bytes？





是Python3的数据类型，详见：[http://c.biancheng.net/view/2175.html](http://c.biancheng.net/view/2175.html)。

# np.frombuffer

返回一维数组：

![在这里插入图片描述](/static/img/images/00321.png)

# cv2.imdecode

cv2.imdecode()函数从指定的内存缓存中读取数据，并把数据转换(解码)成图像格式;主要用于从网络传输数据中恢复出图像。

cv2.imencode()函数是将图片格式转换(编码)成流数据，赋值到内存缓存中;主要用于图像数据格式的压缩，方便网络传输。

# bytes转图片numpy矩阵
```python
img = cv2.imdecode(np.frombuffer(file, dtype=np.uint8), cv2.IMREAD_COLOR)
```

# 逆运算 numpy矩阵转bytes

这里的img_bytes 就是bytes的file
```python
# 对数组的图片格式进行编码
success, encoded_image = cv2.imencode(".jpg", img)
# 将数组转为bytes
img_bytes = encoded_image.tostring()
```

# bytes转图片numpy矩阵


# 完整代码：

```python
# -*- coding:utf-8 -*-
import uvicorn
from fastapi.middleware.cors import CORSMiddleware
from fastapi import FastAPI, File, Form, UploadFile
import cv2
import numpy as np
from io import BytesIO
app = FastAPI(
    title='FastAPI Tutorial',
    description='FastAPI教程',
    version='1.0.0',
    docs_url='/docs',
    redoc_url='/redocs',
)
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)
@app.post("/files/")
async def alg_file(
        file: bytes = File(...),
        token: str = Form(...)
):
    img = cv2.imdecode(np.frombuffer(file, dtype=np.uint8), 1)
    return {
        "token": token,
        "size": img.shape
    }
if __name__ == '__main__':
    uvicorn.run('run1:app', host='0.0.0.0', port=8002, reload=True, debug=True, workers=1)
```

FastAPI bytes转矩阵 bytes转图片 bytes opencv URL传文件 POST FORM Python

Opencv 读取的图片是BGR 矩阵：




```python
import cv2 
import matplotlib.pyplot as plt
img=cv2.imread('./res.jpg')
plt.imshow(img)
plt.show()
```

plt显示方法imshow是默认矩阵是RGB的，

![在这里插入图片描述](/static/img/images/00322.png)

想要正确显示，需要：

```python
imgrgb= cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
plt.imshow(imgrgb)
plt.show()
```

![在这里插入图片描述](/static/img/images/00323.png)

Opencv Python 图片通道 BGR 转 RGB imgrgb= cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

读取




```python
import cv2
import numpy as np 
img = cv2.imdecode(np.fromfile("./人物-1.jpg", dtype=np.uint8), 1) # img是矩阵
```

写入：

```python
import cv2
cv2.imencode('.jpg', img)[1].tofile(os.path.join(self.keyword, self.keyword + str(count) + ".jpg"))
```

Python cv2.imread 无法打开中文路径的图像

![在这里插入图片描述](/static/img/images/00362.png)





1 调程序中的127可以提取多少颜色，有时候有毛边；

2 png是带透明度的图，有颜色的部分设置透明度255就是完全不透明，原来白色的部分设置透明度0就是完全透明；

```python
import cv2
import numpy as np
inputimg = 'minio.png'
thresh=180
img1 = cv2.imread(inputimg, 0)
ret, thresh1 = cv2.threshold(img1, 127, 255, cv2.THRESH_BINARY)
img = cv2.imread(inputimg)
b, g, r = cv2.split(img)
b[thresh1 > thresh] = 0
g[thresh1 > thresh] = 0
r[thresh1 > thresh] = 0
alpha_channel = np.zeros(b.shape, dtype=b.dtype)
alpha_channel[thresh1 < thresh] = 255
img = cv2.merge([b, g, r, alpha_channel])
cv2.imwrite("res.png", img)
```

opencv python jpg 转 png 提取icon 提取jpg中有颜色部分

python安装opencv：





> pip install opencv-python

提取视频帧 视频转图片：
```python
import os
mp4file = 'input.mp4'
savefile = "./output"
if not os.path.exists(savefile):
    os.mkdir(savefile)
import cv2
cap = cv2.VideoCapture(mp4file)
fourcc = cv2.VideoWriter_fourcc(*'XVID')
fps = cap.get(cv2.CAP_PROP_FPS)
size = (int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)), int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)))
print(fps)
print(size)
i = 0
while (cap.isOpened()):
    i = i + 1
    ret, frame = cap.read()
    if ret == True:
        cv2.imwrite(savefile + '/' + str(i) + '.jpg', frame)
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
    else:
        break
print(i)
cap.release()
cv2.destroyAllWindows()
```

图片转视频：

```python
import os
mp4file = 'out.mp4'
savefile = "./output"
if not os.path.exists(savefile):
    os.mkdir(savefile)
import cv2
fourcc = cv2.VideoWriter_fourcc(*'XVID')
fps = 30
size =(720, 1280)
videoWriter = cv2.VideoWriter(mp4file, fourcc, fps, size)  # 最后一个是保存图片的尺寸
for i in range(1, 1402):
    frame = cv2.imread(savefile + '/' + str(i) + '.jpg')
    videoWriter.write(frame)
videoWriter.release()
```


合成，一定得注意尺寸的大小。

```python
# coding=utf-8
import os
import cv2
from PIL import Image
def makevideo(path, fps):
    """ 将图片合成视频. path: 视频路径，fps: 帧率 """
    fourcc = cv2.VideoWriter_fourcc(*"mp4v")
    path1 = r'D:\yifei111\PycharmProjects\python_test\jigan_res4'
    im = Image.open(r'D:\yifei111\PycharmProjects\python_test\jigan1\251.jpg')
    print(im.size)
    vw = cv2.VideoWriter(path, fourcc, fps, im.size)
    for i in os.listdir(path1):
        frame = cv2.imread(path1 + '\\' + i)
        frame = frame[200:649, :]
        frame = cv2.resize(frame, im.size)
        vw.write(frame)
if __name__ == '__main__':
    video_path = r'D:\yifei111\PycharmProjects\python_test\DST_test_new4.mp4'
    makevideo(video_path, 30)  # 图片转视频
```

python opencv 提取视频帧 视频转图片 图片转视频

[https://www.cnblogs.com/skyfsm/p/7411961.html](https://www.cnblogs.com/skyfsm/p/7411961.html)





看到个有意思的，记录一下。

![在这里插入图片描述](/static/img/images/00558.png)

![在这里插入图片描述](/static/img/images/00559.png)

【图像处理】 OpenCV 图像拼接和图像融合技术

导读





1 直方图介绍

2 图像直方图均衡化

3 比较不同图像的直方图的相似度

4 直方图反向投影

 **- [ ] 1、直方图介绍**

> opencv采用hist = cv.calcHist([image], [i], None, [256], [0, 256])计算直方图

> def calcHist(images, channels, mask, histSize, ranges, hist=None, accumulate=None)

灰度直方图是灰度级的函数，描述的是图像中具有该灰度级的像元的个数。


![在这里插入图片描述](/static/img/images/02768.png)
```
import cv2 as cv
import numpy as np
from matplotlib import pyplot as plt
# 将传入图像变成灰度图
# 对于每一级别的灰度，0到255
# 统计图里占有多少像素点
# 比如灰度14占有123个像素点
# 返回np矩阵，表示0到255灰度占有的像素点个数
def custom_hist(image):
    gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
    h, w = gray.shape
    hist = np.zeros([256], dtype=np.int32)
    for row in range(h):
        for col in range(w):
            pv = gray[row, col]
            hist[pv] += 1
    return np.array(hist)
# 将传入图像变成灰度图
# 调用cv.calcHist方法计算，和第一个函数一样的结果
def image_Cvt_and_Gray_hist(image):
    gray_img = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
    hist = cv.calcHist([gray_img], [0], None, [256], [0, 256])
    return np.array(hist)
# 将传入图像的三个通道调用cv.calcHist方法分别计算直方图
# 返回三个通道的直方图信息
def image_hist(image):
    color = ('blue', 'green', 'red')
    all_hist=[]
    for i, color in enumerate(color):
        hist = cv.calcHist([image], [i], None, [256], [0, 256])
        all_hist.append(hist)
    return np.array(all_hist)
# 读取图像
src = cv.imread("D:/vcprojects/images/flower.png")
# 调用三个不一样的函数得到直方图
hist1=custom_hist(src)
hist2=image_Cvt_and_Gray_hist(src)
hist3=image_hist(src)
# 改变shape 使得好画图用
# hist2=hist2.reshape((256,))
hist2=hist2.flatten()
hist3=hist3.reshape((3,256,))
print(hist1.shape)
print(hist2.shape)
print(hist3[0].shape)
# 画图
plt.subplot(231)
plt.bar(range(256),hist1)
plt.title("self gray hist")
plt.subplot(232)
plt.bar(range(256),hist2)
plt.title("opencv gray calc")
plt.subplot(233)
plt.plot(range(256),hist2)
plt.title("opencv gray calc plot")
plt.subplot(234)
plt.plot(range(256),hist3[0],'b')
plt.title("opencv blue ch plot")
plt.subplot(235)
plt.plot(range(256),hist3[1],'g')
plt.title("opencv green ch plot")
plt.subplot(236)
plt.plot(range(256),hist3[2],'r')
plt.title("opencv red ch plot")
plt.show()
```

结果：

![一张彩色图的灰度图的直方图和三个通道的直方图](/static/img/images/02769.png)

 **- [ ] 2、直方图均衡化**

 直方图表达出图像明暗比，直方图均衡化能够调节图像的对比度，让图像视觉效果更好。

 接下来我们需要做出下面这图这效果。

![别人博客的](/static/img/images/02770.png)

首先搞一张低对比度的图：

![在这里插入图片描述](/static/img/images/02771.jpeg)



> opencv使用    equalizeHist_img = cv.equalizeHist(gray_img)  进行图像直方图均衡化

转化后的图形：

![在这里插入图片描述](/static/img/images/02772.jpeg)

两者的直方图对比：

![在这里插入图片描述](/static/img/images/02773.png)

经过图像直方图均衡化后，图像对比度明显增强，直方图的区域也分散开了。

代码

```
import cv2 as cv
import numpy as np
from matplotlib import pyplot as plt
# 调用cv.calcHist方法计算，和第一个函数一样的结果
def Gray_hist(image):
    hist = cv.calcHist([image], [0], None, [256], [0, 256])
    return np.array(hist)
# 读取图像
src = cv.imread("test1.jpg")
gray_img = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
cv.imshow("gray_img",gray_img)
# 画出原图的灰度图的直方图
hist1=Gray_hist(gray_img)
hist1=hist1.flatten()
plt.subplot(211)
plt.bar(range(256),hist1)
plt.title("gray_img hist")
equalizeHist_img = cv.equalizeHist(gray_img)
cv.imshow("equalizeHist_img",equalizeHist_img)
cv.imwrite("test2.jpg",equalizeHist_img)
hist2=Gray_hist(equalizeHist_img)
hist2=hist2.flatten()
plt.subplot(212)
plt.bar(range(256),hist2)
plt.title("equalizeHist_img hist")
duibi1 = cv.compareHist(hist1, hist2, cv.HISTCMP_CORREL)
print("HISTCMP_CORREL",duibi1)
duibi1 = cv.compareHist(hist1, hist2, cv.HISTCMP_CHISQR)
print("HISTCMP_CHISQR",duibi1)
duibi1 = cv.compareHist(hist1, hist2, cv.HISTCMP_INTERSECT)
print("HISTCMP_INTERSECT",duibi1)
duibi1 = cv.compareHist(hist1, hist2, cv.HISTCMP_BHATTACHARYYA)
print("HISTCMP_BHATTACHARYYA",duibi1)
plt.show()
cv.waitKey(0)
cv.destroyAllWindows()
```

 - [ ] 3、比较不同图像的直方图的相似度

官网介绍：https://docs.opencv.org/2.4/modules/imgproc/doc/histograms.html?highlight=cv.comparehist#cv.CompareHist

一共这么几种度量方式：

![在这里插入图片描述](/static/img/images/02774.png)

![在这里插入图片描述](/static/img/images/02775.png)

实验用的图的结果：

    HISTCMP_CORREL -0.003136853862261312

    HISTCMP_CHISQR 49340294.64136557

    HISTCMP_INTERSECT 57006.0

    HISTCMP_BHATTACHARYYA 0.9067574525038417

 - [ ] 4、直方图方向投影

官网解释：https://docs.opencv.org/2.4/doc/tutorials/imgproc/histograms/back_projection/back_projection.html

通俗理解：

我有一个ROI图，这图的HSV中的色调（H），饱和度（S）我比较感兴趣，HSV是针对人的视觉效果来设计的，求出这个ROI的H和S的histogram分布。

我现在有另一张图target，我使用得到的histogram分布去搞这个图，target图里面每个像素点的H和S我都依照得到的histogram分布去改变，改变得最后结果是：有相似H和S的部分会被“显形”（针对人眼视觉），target图中不是一个风格的就不会“显形”。

如果我的target图是这个：

![在这里插入图片描述](/static/img/images/02776.jpeg)

下面我采用不同的ROI去计算反向投影：

![在这里插入图片描述](/static/img/images/02777.png)

![在这里插入图片描述](/static/img/images/02778.png)

画出由H和S的histogram的图。下面这图是ROI卡车那个图和我们target图的。

![在这里插入图片描述](/static/img/images/02779.png)

下图是第一个小狗ROI和target的：

![在这里插入图片描述](/static/img/images/02780.png)

差不多就可以得出结论：

从ROI的H和S，那种色调和饱和度给人的感觉，去找到target的相似的区域显示出来。

这个东西很鸡肋，不能用于识别啥，玩一下就行了。

OpenCV python 图像直方图均衡化 calcBackProject反向投影

### 如何使用MediaCrawler快速下载图片





作为一名图像算法工程师，怎么能没有图片资源呢？今天，我要介绍一个能快速下载图片的方法，仅供学习使用，请勿用于其他用途。

#### 下载项目

首先，从GitHub下载项目：[MediaCrawler](https://github.com/NanmiCoder/MediaCrawler)

![项目页面](/static/img/images/02698.png)

#### 安装依赖

安装所需的Python依赖库：
```bash
pip install -r requirements.txt
```

安装Playwright浏览器驱动：
```bash
playwright install
```

#### 运行爬虫程序

项目默认没有开启评论爬取模式，如果需要爬取评论，请在 `config/base_config.py` 中将 `ENABLE_GET_COMMENTS` 变量设置为 `True`。一些其他支持的功能，也可以在 `config/base_config.py` 查看，文件中有中文注释。

##### 搜索帖子并爬取信息与评论
```bash
python main.py --platform xhs --lt qrcode --type search
```

##### 获取指定帖子的信息与评论
```bash
python main.py --platform xhs --lt qrcode --type detail
```

##### 打开对应APP扫二维码登录
```bash
python main.py --help
```

例如，我想下载某个创作者的全部图片，可以这样设置：

![设置下载参数](/static/img/images/02699.png)

再设置最大下载量：

![设置最大下载量](/static/img/images/02700.png)

在命令行中执行下载：
```bash
python main.py --platform xhs --type creator > output.log 2>&1
```

所有日志会打印到 `output.log` 文件中。

#### 提取图片URL

接下来，我们需要编写一个脚本来从日志中提取图片URL。以下是一个Python脚本示例：

```python
import re
def extract_image_urls(log_file, output_file):
    with open(log_file, 'r', encoding='utf-16LE') as f:
        log_content = f.read()
    # 删除\r\n
    log_content = log_content.replace('\r', '')
    log_content = log_content.replace('\n', '')
    # 使用正则表达式提取'image_list'中的URL
    image_url_pattern = re.compile(r"'image_list':\s*'([^']+)'")
    matches = image_url_pattern.findall(log_content)
    # 分割每个'image_list'字段中的URL，并写入文件
    with open(output_file, 'w', encoding='utf-8') as f:
        for match in matches:
            urls = match.split(',')
            for url in urls:
                f.write(url.strip() + '\n')
# 调用函数，分析日志文件并提取图片URL
extract_image_urls('output.log', 'image.txt')
```

这样，我们就能得到一个包含所有图片URL的 `image.txt` 文件：

![生成的URL文件](/static/img/images/02701.png)

通过这种方法，我们可以快捷地下载所需的图片资源，方便后续的图像处理和算法开发。

如何用程序批量下载小红书的图片？

# Win10系统手动更新和关闭自动更新方法






## Win10系统手动更新

在Win10系统中手动更新可以确保您的设备始终保持最新，以下是具体步骤：

1. 登录桌面云后，左下角点击【开始】，然后选择【设置】。

2. 在Windows设置界面中，点击【更新和安全】。

3. 进入Windows更新界面后，点击【检查更新】按钮。

4. 系统会开始检查是否有可用更新，请耐心等待。

5. 如果有可用更新，系统将自动下载安装，请保持耐心。

6. 更新安装完成后，系统会提示需要重启。您可以选择【立即重新启动】或【计划重新启动】。

7. 建议等待所有更新安装完毕后点击【立即重新启动】。注意：如果有多个更新，建议重启多次。

8. 重启完成后，可以再次点击【检查更新】，以确保已完整安装所有更新。

## Win10系统关闭自动更新

[http://www.yishimei.cn/software/629.html](http://www.yishimei.cn/software/629.html)

Win10系统手动更新和关闭自动更新方法

# docker-compose启动项目流程





要使用 `docker-compose.yaml` 文件启动一个 Python 代码工程，您可以按照以下步骤操作：

### 1. 安装 Docker 和 Docker Compose

如果您的系统上还没有安装 Docker 和 Docker Compose，您需要先安装它们。

- **安装 Docker：**

  对于 Ubuntu：

  ```bash
  sudo apt-get update
  sudo apt-get install docker-ce docker-ce-cli containerd.io
  ```

  对于 Windows 和 macOS，可以从 [Docker 官网](https://www.docker.com/products/docker-desktop) 下载 Docker Desktop 并按照提示进行安装。

- **安装 Docker Compose：**

  对于 Ubuntu：

  ```bash
  sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
  sudo chmod +x /usr/local/bin/docker-compose
  ```

  对于 Windows 和 macOS，Docker Compose 已经包含在 Docker Desktop 中，无需额外安装。

### 2. 准备 Docker Compose 文件

确保 `docker-compose.yaml` 文件在您的项目根目录中。该文件定义了您的服务，包括镜像、容器名称、网络配置、挂载卷等。

### 3. 启动 Docker Compose 服务

打开终端或命令行窗口，导航到包含 `docker-compose.yaml` 文件的项目根目录，然后运行以下命令：

```bash
docker-compose up -d
```

这个命令会在后台启动所有定义在 `docker-compose.yaml` 文件中的服务。如果希望在前台运行并查看日志输出，可以去掉 `-d` 参数：

```bash
docker-compose up
```

### 4. 检查运行状态

您可以使用以下命令检查服务是否正常运行：

```bash
docker-compose ps
```

这个命令会列出所有由 `docker-compose` 启动的容器及其状态。

### 5. 停止服务

如果您需要停止服务，可以在项目根目录中运行以下命令：

```bash
docker-compose down
```

这个命令会停止并删除所有由 `docker-compose` 启动的容器。

### 示例 `docker-compose.yaml` 文件

以下是一个简单的 `docker-compose.yaml` 文件示例：

```yaml
version: '3.8'
services:
  web:
    image: python:3.8
    volumes:
      - .:/code
    working_dir: /code
    command: python app.py
    ports:
      - "5000:5000"
  db:
    image: postgres:13
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
      POSTGRES_DB: mydatabase
    ports:
      - "5432:5432"
```


# 为什么要用docker-compose

`docker-compose` 是为了启动和管理多个容器以便它们能够协同工作。这么做有几个主要原因和好处：

### 1. 微服务架构的实现

现代应用程序往往采用微服务架构，将应用程序拆分为多个独立的服务（如数据库服务、Web服务、缓存服务等）。这些服务各自运行在独立的容器中，可以独立开发、部署和扩展。

### 2. 依赖管理

复杂的应用程序通常依赖于多个组件和服务。例如，一个典型的Web应用程序可能需要一个Web服务器、一个数据库和一个缓存系统。使用 `docker-compose` 可以轻松地定义和管理这些依赖关系，确保所有组件按预期启动和运行。

### 3. 简化开发和测试环境

在开发和测试过程中，需要保证开发环境与生产环境尽可能一致。使用 `docker-compose` 可以定义一致的开发、测试和生产环境，使得在本地运行的环境与部署到服务器上的环境尽量相同，从而减少环境差异带来的问题。

### 4. 方便的服务管理

`docker-compose` 提供了简单的命令来启动、停止和查看所有服务的状态。例如，通过一个 `docker-compose up` 命令，就可以启动所有服务；通过 `docker-compose down` 命令，可以停止并清理所有服务。

### 5. 网络配置

`docker-compose` 自动为所有定义的服务创建一个专用网络，使得这些服务之间能够互相通信，而不需要额外配置复杂的网络设置。每个服务都可以通过服务名直接访问其他服务。

### 示例应用场景

假设我们有一个简单的博客应用程序，它包括以下组件：

- 一个前端Web服务器（例如，使用Nginx）

- 一个后端API服务器（例如，使用Flask或Django）

- 一个数据库服务器（例如，使用PostgreSQL）

在没有 `docker-compose` 的情况下，我们需要分别配置和管理这些服务，这可能会非常复杂且容易出错。而使用 `docker-compose`，我们可以定义一个简单的 `docker-compose.yaml` 文件来描述这些服务及其依赖关系：

```yaml
version: '3.8'
services:
  web:
    image: nginx:latest
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
    depends_on:
      - api
  api:
    image: my-api-server:latest
    build: ./api
    ports:
      - "5000:5000"
    environment:
      - DATABASE_URL=postgres://user:password@db:5432/mydatabase
  db:
    image: postgres:13
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
      POSTGRES_DB: mydatabase
    ports:
      - "5432:5432"
    volumes:
      - postgres-data:/var/lib/postgresql/data
volumes:
  postgres-data:
```

`docker-compose` 为开发人员提供了一种简便的方法来定义、管理和运行多容器Docker应用程序。它在微服务架构、依赖管理、一致的开发和生产环境、服务管理以及网络配置方面提供了显著的优势，使得复杂应用程序的管理和维护变得更加容易和高效。

#  语法

Docker Compose 是一个用于定义和运行多容器 Docker 应用的工具。通过一个 `docker-compose.yml` 文件，你可以配置应用的服务，并使用一个命令启动或关闭它们。以下是 Docker Compose 语法的详细介绍及示例：

### 基本语法结构

`docker-compose.yml` 文件是一个 YAML 文件，通常包含以下几部分：

1. `version`：指定 Docker Compose 文件的版本。

2. `services`：定义应用程序中的服务。

3. `volumes`：定义数据卷。

4. `networks`：定义网络。

### 示例 `docker-compose.yml` 文件

```yaml
version: '3.8'  # Docker Compose 文件版本
services:
  web:
    image: nginx:latest  # 使用的镜像
    ports:
      - "80:80"  # 映射端口
    volumes:
      - ./html:/usr/share/nginx/html  # 挂载主机目录到容器
    networks:
      - webnet  # 使用的网络
  app:
    build:
      context: ./app  # Dockerfile 所在目录
      dockerfile: Dockerfile
    ports:
      - "5000:5000"
    volumes:
      - ./app:/app
    networks:
      - webnet
    depends_on:
      - db  # 指定依赖的服务
  db:
    image: postgres:latest
    environment:
      POSTGRES_DB: mydatabase
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
    volumes:
      - db_data:/var/lib/postgresql/data
    networks:
      - webnet
volumes:
  db_data:  # 定义一个名为 db_data 的卷
networks:
  webnet:  # 定义一个名为 webnet 的网络
```

### 关键字详解

#### `version`

指定 Compose 文件的版本。不同版本支持的语法和功能有所不同。常用的版本包括 `2`、`2.1`、`3`、`3.8` 等。

#### `services`

定义应用中的各个服务。每个服务可以包含以下字段：

- `image`：指定服务使用的 Docker 镜像。

- `build`：构建镜像的配置，通常包含 `context` 和 `dockerfile`。

- `ports`：暴露和映射端口。

- `volumes`：挂载卷。

- `networks`：服务使用的网络。

- `environment`：环境变量配置。

- `depends_on`：指定服务依赖关系。

#### `volumes`

定义数据卷。数据卷用于持久化数据，避免因容器销毁而丢失数据。

#### `networks`

定义网络。网络用于容器之间的通信。Compose 默认提供一个 `bridge` 网络，但可以自定义网络以满足复杂的需求。

### 常用命令

1. 启动服务：

```sh
docker-compose up
```

2. 后台启动服务：

```sh
docker-compose up -d
```

3. 停止服务：

```sh
docker-compose down
```

4. 查看服务日志：

```sh
docker-compose logs
```

5. 重新构建服务：

```sh
docker-compose build
```

6. 列出正在运行的服务：

```sh
docker-compose ps
```

### 进阶用法

#### 使用 `.env` 文件

Docker Compose 支持使用 `.env` 文件来设置环境变量。这些变量可以在 `docker-compose.yml` 文件中使用。

`.env` 文件示例：

```plaintext
POSTGRES_DB=mydatabase
POSTGRES_USER=user
POSTGRES_PASSWORD=password
```

`docker-compose.yml` 文件中使用环境变量：

```yaml
services:
  db:
    image: postgres:latest
    environment:
      POSTGRES_DB: ${POSTGRES_DB}
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
```

#### 多个 Compose 文件

在复杂的应用中，你可能需要使用多个 Compose 文件。例如，一个用于开发环境，一个用于生产环境：

- `docker-compose.yml`：基本配置。

- `docker-compose.override.yml`：覆盖或扩展基本配置。

启动时可以指定多个文件：

```sh
docker-compose -f docker-compose.yml -f docker-compose.override.yml up
```


Docker Compose 是一个强大的工具，可以简化多容器应用的管理。通过定义清晰的 `docker-compose.yml` 文件，可以方便地启动、停止和管理你的应用程序。


# 一个示例工程

[https://github.com/fevolq/Money/blob/main/docker-compose.yaml](https://github.com/fevolq/Money/blob/main/docker-compose.yaml)

```css
version: '3'
services:
  money:
    image: infq/money:latest
    container_name: money
    environment:
      - PORT=8888
      - WorthUseCache=true
    ports:
      - "8888:8888"
    volumes:
      - ./data:/app/money/data
      - ./conf:/app/money/conf
    networks:
      - money
    restart: always
    command: [
      "uvicorn",
      "app:app",
      "--host", "0.0.0.0",
      "--port", "8888"
    ]
  money-frontend:
    image: infq/money-front:latest
    container_name: money-frontend
    ports:
      - "80:80"
    depends_on:
      - money
    networks:
      - money
    environment:
      - SERVER=http://money:8888
      - PORT=80
    restart: always
networks:
  money:
```

【运维】使用 Docker Compose 快速启动项目全流程指南

# 总览





拍摄好看的照片不仅仅依赖于相机的硬件配置，还需要掌握一些基本的摄影技巧和相机设置。以下是一些建议，帮助你利用佳能EOS R62拍出更好看的照片：

### 1. 了解相机设置

- **模式选择**：学习使用不同的拍摄模式（如光圈优先、快门优先、手动模式），这些模式可以让你更好地控制曝光、景深和运动模糊。

- **光圈、快门和ISO**：了解这些参数的作用以及如何相互影响。例如，使用大光圈（小f值）可以获得浅景深，突出主体。

- **白平衡**：根据拍摄环境调整白平衡，确保色彩还原准确。

### 2. 充分利用镜头

- **焦距选择**：22-104mm的镜头涵盖了广角到中长焦，适合多种拍摄场景。广角适合风景和建筑拍摄，而长焦则适合人像和细节捕捉。

- **光圈调节**：在拍摄人像时，使用较大光圈（如f/2.8或f/4）可以获得美丽的背景虚化效果。

### 3. 构图技巧

- **三分法则**：将画面分为九个等分，把主体放在三分线或交叉点上，可以让构图更加平衡和美观。

- **前景和背景**：利用前景和背景增加照片的层次感。例如，可以在前景加入一些植物或建筑，增加画面的深度。

- **引导线**：利用道路、河流等引导线引导观众的视线，增加画面的动感。

### 4. 使用自然光和人工光

- **黄金时段**：在早晨和傍晚拍摄，这时的光线柔和、色彩丰富，非常适合拍摄风景和人像。

- **补光**：在光线不足或逆光拍摄时，可以使用反光板、外置闪光灯等补光设备，改善光线条件。

### 5. 后期处理

- **RAW格式**：尽量使用RAW格式拍摄，这样在后期处理时有更大的调整空间。

- **后期软件**：学习使用后期处理软件如Adobe Lightroom或Photoshop，进行颜色校正、曝光调整和细节增强等操作，提升照片质量。

### 6. 多练习和学习

- **参考优秀作品**：多看一些优秀的摄影作品，分析其构图、用光和色彩搭配，汲取灵感。

- **多拍多练**：摄影技巧需要通过不断的实践来提升，尝试不同的拍摄题材和风格，不断总结和改进。

### 实用示例

#### 风景拍摄

- 使用广角端，光圈缩小到f/8或f/11，确保前景和背景都清晰。

- 选择早晨或傍晚的光线，增加色彩和对比度。

#### 人像拍摄

- 使用长焦端，光圈开大到f/2.8或f/4，突出人物，虚化背景。

- 注意对焦点放在眼睛上，使人物更有神采。


# 什么是光圈优先

光圈优先（Aperture Priority，通常在相机模式拨盘上标记为“A”或“Av”）是一种相机曝光模式。在这种模式下，摄影师可以手动设置光圈值，相机会根据设定的光圈值自动调整快门速度，以确保照片获得正确的曝光。以下是光圈优先模式的详细解释和使用指南：

### 光圈优先模式的特点

1. **光圈控制**：光圈是镜头中的一个可调节的开口，控制进入相机的光线量。光圈值通常以f/值表示，如f/2.8、f/4、f/8等。较小的f/值（如f/2.8）表示较大的光圈开口，较大的f/值（如f/16）表示较小的光圈开口。

2. **景深控制**：光圈值对景深（Depth of Field，DOF）有直接影响。较大的光圈（较小的f/值）会产生较浅的景深，使背景模糊，而前景清晰。这在人像摄影中常用于突出主体。较小的光圈（较大的f/值）会产生较深的景深，使前景和背景都较为清晰，这在风光摄影中较为常见。

3. **自动快门速度**：在光圈优先模式下，相机会根据设定的光圈值和当前的光线条件自动选择适当的快门速度，以保证照片不过曝或欠曝。

### 使用光圈优先模式的场景

1. **人像摄影**：使用大光圈（如f/1.8或f/2.8）可以创建浅景深效果，使背景模糊，从而突出拍摄主体。

2. **风光摄影**：使用小光圈（如f/11或f/16）可以增加景深，使整个画面从前景到背景都清晰。

3. **低光环境**：在光线较暗的环境中，可以选择较大的光圈，以便更多光线进入相机，同时相机会自动调整较慢的快门速度来保持正确曝光。

### 如何使用光圈优先模式

1. **选择光圈优先模式**：在相机模式拨盘上选择“A”或“Av”模式。

2. **设置光圈值**：通过相机的光圈调节拨盘或菜单设置所需的光圈值。

3. **构图和对焦**：构图并对焦拍摄对象，半按快门按钮，相机会自动测光并设置合适的快门速度。

4. **拍摄**：完全按下快门按钮进行拍摄。

### 注意事项

1. **快门速度**：在光线不足的情况下，使用较大光圈时，相机会自动选择较慢的快门速度。这可能导致照片模糊，特别是在手持拍摄时。因此，可以考虑使用三脚架或者增加ISO感光度来获得较快的快门速度。

2. **过曝或欠曝**：如果光线条件非常特殊（如非常明亮或非常暗），相机的自动测光可能会出现过曝或欠曝的情况。这时，可以使用曝光补偿功能（通常标记为“+/-”）进行调整。

光圈优先模式是摄影师常用的拍摄模式之一，尤其适合需要控制景深的场景。在熟练掌握该模式后，可以更灵活地应对各种拍摄环境，拍出满意的照片。

# 什么是快门优先

快门优先（Shutter Priority，通常在相机模式拨盘上标记为“S”或“Tv”）是一种相机曝光模式。在这种模式下，摄影师可以手动设置快门速度，相机会根据设定的快门速度自动调整光圈值，以确保照片获得正确的曝光。以下是快门优先模式的详细解释和使用指南：

### 快门优先模式的特点

1. **快门速度控制**：快门速度是相机的快门打开和关闭的时间，通常以秒或分秒表示，例如1/1000秒、1/250秒、1秒等。较快的快门速度（如1/1000秒）可以冻结快速移动的物体，而较慢的快门速度（如1秒）可以捕捉运动的模糊效果。

2. **运动效果控制**：快门速度对照片中的运动效果有直接影响。较快的快门速度可以拍摄清晰的静止图像，适合拍摄运动中的物体。较慢的快门速度可以产生运动模糊效果，如流水的丝绸效果或夜间车流的光轨。

3. **自动光圈**：在快门优先模式下，相机会根据设定的快门速度和当前的光线条件自动选择适当的光圈值，以保证照片不过曝或欠曝。

### 使用快门优先模式的场景

1. **运动摄影**：使用较快的快门速度（如1/1000秒或更快）可以捕捉快速移动的物体，如体育比赛、野生动物、飞行中的鸟等。

2. **长曝光摄影**：使用较慢的快门速度（如1秒或更慢）可以拍摄夜景、星轨、流水的丝绸效果、光绘等。

3. **低光环境**：在光线不足的环境中，使用较慢的快门速度可以让更多光线进入相机，但需要三脚架以防止相机抖动导致的模糊。

### 如何使用快门优先模式

1. **选择快门优先模式**：在相机模式拨盘上选择“S”或“Tv”模式。

2. **设置快门速度**：通过相机的快门速度调节拨盘或菜单设置所需的快门速度。

3. **构图和对焦**：构图并对焦拍摄对象，半按快门按钮，相机会自动测光并设置合适的光圈值。

4. **拍摄**：完全按下快门按钮进行拍摄。

### 注意事项

1. **光圈限制**：在某些情况下，相机可能无法找到合适的光圈值来匹配设定的快门速度，特别是在光线极端明亮或昏暗的情况下。这时，照片可能会过曝或欠曝。可以考虑调整快门速度或使用ND滤镜（减光镜）来减少进入相机的光线。

2. **相机抖动**：使用较慢的快门速度时，手持拍摄可能会导致照片模糊。因此，建议使用三脚架来稳定相机，或使用防抖功能（如果相机和镜头支持）。

3. **ISO感光度**：在光线不足的情况下，可以增加ISO感光度来提高相机的感光度，从而使用较快的快门速度。但需要注意的是，较高的ISO会增加图像噪点。

快门优先模式对于需要控制运动效果的场景非常有用。熟练掌握该模式后，可以更好地捕捉运动中的精彩瞬间或创造出独特的长曝光效果。

# 佳能R62如何调整白平衡

在佳能EOS R62相机上调整白平衡可以帮助您在不同的光照条件下获得更准确的色彩表现。以下是详细的步骤：

### 通过相机菜单调整白平衡

1. **打开相机**：按下电源按钮开启相机。

2. **进入菜单**：

   - 按下“菜单”按钮进入相机的主菜单。

3. **选择拍摄菜单**：

   - 使用方向按钮或触摸屏导航到“拍摄菜单”选项卡（通常带有相机图标）。

4. **找到白平衡设置**：

   - 在拍摄菜单中找到“白平衡”（White Balance）选项。

5. **选择白平衡模式**：

   - 使用方向按钮或触摸屏选择所需的白平衡模式。常见的白平衡模式包括：

     - **自动白平衡（AWB）**：相机会自动检测光线并调整白平衡。

     - **日光（Daylight）**：适用于晴天的户外光线。

     - **阴影（Shade）**：适用于阴天或阴影下的拍摄。

     - **阴天（Cloudy）**：适用于多云天气。

     - **钨丝灯（Tungsten Light）**：适用于白炽灯光源下的拍摄。

     - **荧光灯（Fluorescent Light）**：适用于荧光灯光源下的拍摄。

     - **闪光灯（Flash）**：适用于使用闪光灯的拍摄。

     - **自定义白平衡（Custom WB）**：允许您手动设置白平衡。

     - **色温（K）**：手动设置具体的色温值（单位为开尔文，K）。

6. **确认选择**：

   - 选择所需的白平衡模式后，按下“设置”按钮或“OK”按钮进行确认。

### 使用自定义白平衡

1. **拍摄白平衡参考图像**：

   - 在需要设置自定义白平衡的光线环境下，用相机拍摄一张白色或中性灰色的参考图像。

2. **进入自定义白平衡菜单**：

   - 在拍摄菜单中选择“自定义白平衡”选项。

3. **选择参考图像**：

   - 相机会提示您选择一张图像作为参考图像。选择刚才拍摄的白色或灰色参考图像。

4. **确认设置**：

   - 确认选择后，相机会将这张参考图像的色彩信息用于设置自定义白平衡。

### 快捷方式调整白平衡

1. **使用快捷按钮**：

   - 按下相机上的“Q”按钮（快速控制按钮）进入快速设置菜单。

2. **选择白平衡选项**：

   - 在快速设置菜单中使用方向按钮或触摸屏选择“白平衡”图标。

3. **调整白平衡模式**：

   - 使用方向按钮或触摸屏选择所需的白平衡模式，并确认设置。

### 注意事项

- **查看效果**：调整白平衡后，可以通过相机的实时取景或拍摄预览查看效果。如果颜色看起来不准确，可以重新选择白平衡模式或调整色温。

- **光线变化**：在光线变化频繁的环境中，可能需要频繁调整白平衡以获得准确的色彩表现。

通过以上步骤，您可以在佳能EOS R62相机上灵活调整白平衡，以适应不同的拍摄环境和光线条件，确保照片的色彩准确和自然。

# 佳能22-104mm镜头的使用指南

### 佳能22-104mm镜头的使用指南

#### 焦距选择

**焦距范围：**

- **22-104mm**镜头涵盖了广角到中长焦的焦距范围，适合多种拍摄场景。

**广角（22mm-35mm左右）：**

- **用途**：广角焦段适合拍摄风景、建筑和大场景。

- **特点**：广角镜头具有较大的视角，可以拍摄更多的场景细节，适合在狭小空间内拍摄，以及表现广阔的风景和宏伟的建筑。

**中焦（35mm-70mm左右）：**

- **用途**：中焦段适合拍摄环境人像、街拍和日常摄影。

- **特点**：中焦镜头具有自然的透视效果，拍摄的人物和景物比例较为真实，适合表现人物和环境的关系。

**长焦（70mm-104mm左右）：**

- **用途**：长焦焦段适合拍摄人像、特写和远处的细节。

- **特点**：长焦镜头可以压缩空间，使前景和背景看起来更接近，同时具有较浅的景深，能更好地突出主体，模糊背景。

#### 光圈调节

**光圈大小：**

- 光圈大小用f/值表示，如f/2.8、f/4、f/5.6等。较小的f/值表示较大的光圈开口。

**人像拍摄（使用较大光圈）：**

- **用途**：在拍摄人像时，使用较大的光圈（如f/2.8或f/4）可以获得美丽的背景虚化效果。

- **效果**：较大的光圈可以使背景变得模糊，从而突出主体。这种效果在摄影中称为“浅景深”。

- **操作**：在相机上选择光圈优先模式（A或Av），然后调整光圈值到所需的大小（如f/2.8或f/4）。相机会自动调整快门速度以确保正确曝光。

#### 使用建议

1. **风景拍摄**：在22-35mm广角范围内，使用较小光圈（如f/8或f/11）来增加景深，使前景和背景都清晰。

2. **人像拍摄**：在70-104mm长焦范围内，使用较大光圈（如f/2.8或f/4）来获得背景虚化效果，使主体更加突出。

3. **建筑拍摄**：在22-35mm广角范围内，注意避免畸变，可以适当调整构图，选择较小光圈（如f/8）以获得清晰的图像。

4. **街拍和日常摄影**：在35-70mm中焦范围内，使用中等光圈（如f/5.6），既能获得足够的景深，又能保持较好的背景虚化效果。

#### 实际操作步骤

1. **选择拍摄模式**：

   - 使用光圈优先模式（A或Av）来手动调整光圈，相机自动调整快门速度。

   - 使用手动模式（M）来完全控制光圈和快门速度。

2. **调整光圈**：

   - 在光圈优先模式下，通过相机的控制拨盘或菜单设置所需的光圈值。

3. **构图和对焦**：

   - 根据拍摄场景选择合适的焦距，构图并对焦拍摄对象。

4. **拍摄**：

   - 检查拍摄效果，适当调整光圈和焦距，确保获得理想的照片。

通过合理选择焦距和光圈，您可以充分利用佳能22-104mm镜头的优势，拍摄出多样化的高质量照片。


佳能22-104mm镜头上的按钮和开关具有特定的功能，帮助您更好地控制拍摄过程。以下是这些按钮和开关的详细解释：

### 常见的镜头按钮和开关

1. **对焦模式开关（AF/MF）**

   - **AF（自动对焦）**：当开关设置为AF时，镜头会自动对焦。这对于大多数拍摄场景都非常方便，尤其是动态场景。

   - **MF（手动对焦）**：当开关设置为MF时，您可以手动调节镜头的对焦环来对焦。这在需要精确对焦或特殊对焦效果时非常有用。

2. **防抖开关（IS，Image Stabilization）**

   - **开（ON）**：开启防抖功能。防抖系统会补偿相机抖动，特别是在低光照条件或使用长焦拍摄时，能有效减少图像模糊。

   - **关（OFF）**：关闭防抖功能。在使用三脚架拍摄时，通常建议关闭防抖功能，以避免防抖系统的干扰。

3. **焦距范围限制开关（Focus Range Limiter）**

   - **全范围（Full）**：镜头可以在整个焦距范围内对焦。

   - **限制范围（例如，0.5m-∞ 或 1.0m-∞）**：镜头只在指定的距离范围内对焦。使用此功能可以加快对焦速度并减少对焦狩猎，适合在特定距离范围内拍摄。

4. **自定义按钮（Custom Button，某些高端镜头可能具备）**

   - **功能设置**：某些镜头具有自定义按钮，可以在相机菜单中设置特定功能，如启动对焦锁定、快速切换对焦模式等。

### 如何使用这些按钮和开关

**对焦模式开关（AF/MF）**

1. **切换到AF模式**：适用于日常拍摄、大部分动态场景。只需将开关拨到“AF”位置。

2. **切换到MF模式**：适用于需要精确对焦的场景，如微距摄影或特殊构图。将开关拨到“MF”位置，然后使用对焦环手动对焦。

**防抖开关（IS）**

1. **开启防抖功能**：适用于手持拍摄，特别是在低光照条件或使用长焦端时。将开关拨到“ON”位置。

2. **关闭防抖功能**：在使用三脚架或需要完全稳定的拍摄环境下，将开关拨到“OFF”位置。

**焦距范围限制开关（Focus Range Limiter）**

1. **全范围对焦**：适用于不确定被摄物体距离或需要全范围对焦的场景。将开关拨到“Full”位置。

2. **限制范围对焦**：适用于特定距离范围的拍摄，如人像摄影或特写。根据需要将开关拨到适当的限制范围位置。

**自定义按钮（Custom Button）**

1. **设置自定义功能**：在相机菜单中找到镜头自定义按钮设置，选择所需的功能并进行设置。使用时，按下自定义按钮即可快速执行设置的功能。

### 实际操作示例

1. **拍摄风景**：

   - 设置对焦模式为AF。

   - 如果手持拍摄，开启防抖功能。

   - 使用全范围对焦模式（Full）。

2. **拍摄人像**：

   - 设置对焦模式为AF或MF（根据需要）。

   - 开启防抖功能以减少手抖影响。

   - 使用限制范围对焦模式，以加快对焦速度（如1.0m-∞）。

3. **拍摄运动物体**：

   - 设置对焦模式为AF。

   - 开启防抖功能。

   - 使用全范围对焦模式（Full）。

通过合理使用镜头上的按钮和开关，您可以更灵活地控制拍摄过程，适应不同的拍摄场景和需求，提升摄影效果。

新手摄影技巧总结

打开TPM2：





[https://support.microsoft.com/zh-cn/windows/%E5%9C%A8%E7%94%B5%E8%84%91%E4%B8%8A%E5%90%AF%E7%94%A8-tpm-2-0-1fd5a332-360d-4f46-a1e7-ae6b0c90645c](https://support.microsoft.com/zh-cn/windows/%E5%9C%A8%E7%94%B5%E8%84%91%E4%B8%8A%E5%90%AF%E7%94%A8-tpm-2-0-1fd5a332-360d-4f46-a1e7-ae6b0c90645c)

下载这个，点击升级即可。

[https://www.microsoft.com/zh-cn/software-download/windows11](https://www.microsoft.com/zh-cn/software-download/windows11)

![在这里插入图片描述](/static/img/images/02941.png)

【电脑】win10如何升级为win11？

## Windows 命令行：开发者必备指令





### 介绍

作为一名熟练使用 Linux 的开发人员，你可能已经习惯了利用命令行来完成各种任务。令人惊讶的是，Windows 也提供了一个强大的命令行界面（CLI），在开发任务中也可以非常高效。在这篇博客中，我们将探索一些 Windows 中最有用的命令，帮助你在 Windows 环境中变得更高效和更舒适。

### Windows 命令行入门

Windows 提供了两个主要的命令行界面：命令提示符（cmd）和 PowerShell。cmd 提供了类似于旧 DOS 命令行的基本功能，而 PowerShell 则是一个更高级的 Shell，包括一个脚本语言，并专为任务自动化和配置管理而设计。我们将重点介绍 cmd，因为它简单且熟悉 Linux 用户，但在 PowerShell 增加显著价值的地方也会提及。

#### 打开命令行

打开命令提示符：

1. 按 `Win + R`，输入 `cmd`，然后按 `Enter`。

打开 PowerShell：

1. 按 `Win + R`，输入 `powershell`，然后按 `Enter`。

### Windows 命令行中的常用命令

#### 文件和目录管理

1. **列出文件和目录**

   ```shell
   dir
   ```

   这个命令相当于 Linux 中的 `ls`，列出当前目录中的文件和目录。

2. **更改目录**

   ```shell
   cd <directory_path>
   ```

   使用此命令更改当前目录，类似于 Linux 中的 `cd` 命令。

3. **创建目录**

   ```shell
   mkdir <directory_name>
   ```

   这个命令创建一个新目录，就像 Linux 中的 `mkdir`。

4. **删除文件和目录**

   ```shell
   del <file_name>
   rmdir <directory_name>
   ```

   `del` 删除文件，`rmdir` 删除目录。要删除目录及其内容，请使用：

   ```shell
   rmdir /s <directory_name>
   ```

#### 文件操作

1. **复制文件**

   ```shell
   copy <source_file> <destination>
   ```

   这类似于 Linux 中的 `cp` 命令。

2. **移动文件**

   ```shell
   move <source_file> <destination>
   ```

   等同于 Linux 中的 `mv` 命令。

3. **重命名文件**

   ```shell
   rename <old_name> <new_name>
   ```

   这个命令像 Linux 中的 `mv` 命令一样用于重命名文件。

#### 系统信息

1. **查看系统信息**

   ```shell
   systeminfo
   ```

   这个命令显示有关系统的详细信息，类似于 Linux 中的 `uname -a`。

2. **检查网络配置**

   ```shell
   ipconfig
   ```

   这个命令显示网络配置，类似于 Linux 中的 `ifconfig`。

#### 任务管理

1. **查看正在运行的进程**

   ```shell
   tasklist
   ```

   这个命令列出所有正在运行的进程，类似于 Linux 中的 `ps`。

2. **终止进程**

   ```shell
   taskkill /PID <process_id>
   ```

   这个命令通过进程 ID 终止进程，类似于 Linux 中的 `kill`。

#### 磁盘操作

1. **检查磁盘使用情况**

   ```shell
   chkdsk
   ```

   这个命令检查磁盘错误并显示磁盘使用情况统计信息，有点类似于 Linux 中的 `df`。

2. **碎片整理磁盘**

   ```shell
   defrag <disk_name>
   ```

   这个命令对指定的磁盘进行碎片整理，有助于提高磁盘性能。

### 高级：使用 PowerShell

PowerShell 提供了更高级的功能和更现代的脚本语言。以下是一些 PowerShell 命令的示例：

1. **详细列出文件**

   ```shell
   Get-ChildItem
   ```

2. **过滤和排序文件**

   ```shell
   Get-ChildItem | Where-Object {$_.Length -gt 1MB} | Sort-Object Length
   ```

3. **下载文件**

   ```shell
   Invoke-WebRequest -Uri <url> -OutFile <file_name>
   ```



虽然 Windows 命令行乍一看可能不太熟悉，但它提供了一套强大的工具，可以显著提高你的生产力。通过掌握这些命令，你可以像在 Linux 中一样高效地导航和管理你的 Windows 环境。祝编码愉快！

【开发】Windows 命令行：开发者必备指令

### 如何查看IP地址、理解子网掩码和默认网关





在网络设置和管理中，了解如何查看IP地址以及理解子网掩码和默认网关是至关重要的。本文将介绍如何在Windows中查看IP地址，并解释子网掩码和默认网关的概念及其作用。

#### 如何在Windows中查看IP地址

查看IP地址是进行网络故障排除和配置的基本步骤。在Windows中，可以通过命令提示符（Command Prompt）使用`ipconfig`命令来查看IP地址。

具体步骤如下：

1. 按下 `Win + R` 键，打开运行窗口。

2. 输入 `cmd` 并按回车，打开命令提示符。

3. 在命令提示符中输入以下命令并按回车：

   ```bash
   ipconfig
   ```

你将看到类似以下输出的信息，其中包括IPv4地址、子网掩码和默认网关：
```
Ethernet adapter Local Area Connection:
   Connection-specific DNS Suffix  . :
   IPv4 Address. . . . . . . . . . . : 192.168.1.10
   Subnet Mask . . . . . . . . . . . : 255.255.255.0
   Default Gateway . . . . . . . . . : 192.168.1.1
```

如果你只想查看特定的信息，比如仅显示IPv4地址，可以结合其他命令使用：
```bash
ipconfig | findstr /i "IPv4"
```

#### 什么是子网掩码

子网掩码（Subnet Mask）是一个用来划分IP地址范围的32位数字。它与IP地址结合使用，帮助网络设备确定哪些地址在同一个子网内，以及哪些地址位于不同的子网。子网掩码的主要作用是将一个大的网络分割成多个较小的子网，从而提高网络的效率和安全性。

子网掩码的工作原理是通过掩码位来区分网络部分和主机部分。在二进制形式下，子网掩码的连续1表示网络部分，连续0表示主机部分。常见的子网掩码形式有以下几种：

- 255.255.255.0（/24）：表示网络前24位是网络部分，后8位是主机部分，通常用于小型局域网。

- 255.255.0.0（/16）：表示网络前16位是网络部分，后16位是主机部分，适用于中型网络。

- 255.0.0.0（/8）：表示网络前8位是网络部分，后24位是主机部分，适用于大型网络。

**例子**：

假设有一个IP地址为192.168.1.10，子网掩码为255.255.255.0：

- IP地址（192.168.1.10）的二进制表示：

  ```
  11000000.10101000.00000001.00001010
  ```

- 子网掩码（255.255.255.0）的二进制表示：

  ```
  11111111.11111111.11111111.00000000
  ```

通过将IP地址与子网掩码进行AND操作，可以确定网络部分和主机部分：

- 网络部分：11000000.10101000.00000001.00000000（192.168.1.0）

- 主机部分：00000000.00000000.00000000.00001010（10）

在这个例子中，192.168.1.0是网络地址，主机地址范围为192.168.1.1到192.168.1.254，广播地址是192.168.1.255。

#### 什么是默认网关

默认网关（Default Gateway）是计算机网络中一台设备（通常是路由器）的IP地址。它作为网络设备（如计算机或服务器）与其他网络设备（尤其是不同子网的设备）进行通信的出口点。当设备需要发送数据到其本地子网之外的设备时，数据会首先发送到默认网关，然后由默认网关将数据转发到目标设备或目标网络。

默认网关的作用类似于一个中继站，帮助本地网络中的设备与外部网络（如互联网）进行通信。如果没有默认网关，网络设备将无法与本地子网之外的设备进行通信。

**例子**：

假设你的本地网络如下配置：

- 计算机A的IP地址：192.168.1.10

- 子网掩码：255.255.255.0

- 默认网关：192.168.1.1

在这个配置中，默认网关的IP地址是192.168.1.1。当计算机A需要与本地子网之外的设备通信（例如，访问互联网上的一个网站），它会将数据包发送到默认网关（192.168.1.1）。默认网关接收到数据包后，会将其转发到外部网络上的目标设备。

### 总结

了解如何查看IP地址、子网掩码和默认网关是进行网络设置和故障排除的重要步骤。通过命令提示符中的`ipconfig`命令，可以轻松查看这些信息，并了解它们在网络通信中的作用和意义。掌握这些基本概念和操作，有助于提高网络管理的效率和安全性。