[https://jishuin.proginn.com/p/763bfbd2fb27](https://jishuin.proginn.com/p/763bfbd2fb27)





ClickHouse 是一个用于联机分析（OLAP）的列式数据库管理系统（DBMS）。

最近很火的 ClickHouse 是什么？

# 读取具体哪一帧





这个方法可以获取某一帧：

```python
while True:
    cap.set(cv2.CAP_PROP_POS_FRAMES, current_frame)
    ret, frame = cap.read()
    if not ret:
        break
```

# 等待按钮

这个方法可以显示当前帧，然后等待你的按钮：

```python
        # 显示当前帧
        cv2.imshow('Video Frame', frame)
        # 等待按键输入
        key = cv2.waitKey(0)  # 使用较短的等待时间以确保视频正常播放
        if key == 27:  # ESC
            break
        elif key == ord('q'):  # Q 键（往回跳一帧）
            if current_frame > 0:
                current_frame -= 1
        elif key == ord('w'):  # W 键（往前播放一帧）
            if current_frame < len(json_data) - 1:
                current_frame += 1
```

这个标志打开可以让你存储一个mp4视频：

```
FLAG_SAVE_VIDEOS = False
```

# 写入解码方式与文件格式对应

不同的视频文件格式通常需要使用不同的编解码器，因此你需要根据你要创建的视频文件格式来选择合适的四字符编码标识。以下是一些常见的视频文件格式和相应的四字符编码标识示例：

1. **H.264 编码**（通常用于.mp4文件）：

   ```python
   fourcc = cv2.VideoWriter_fourcc(*'H264')
   ```

2. **XVID 编码**（通常用于.avi文件）：

   ```python
   fourcc = cv2.VideoWriter_fourcc(*'XVID')
   ```

3. **MJPG 编码**（通常用于.avi文件，适用于每帧图像质量高的场景）：

   ```python
   fourcc = cv2.VideoWriter_fourcc(*'MJPG')
   ```

4. **DIVX 编码**（通常用于.avi文件）：

   ```python
   fourcc = cv2.VideoWriter_fourcc(*'DIVX')
   ```

5. **VP8 编码**（通常用于.webm文件）：

   ```python
   fourcc = cv2.VideoWriter_fourcc(*'VP80')
   ```

6. **VP9 编码**（通常用于.webm文件）：

   ```python
   fourcc = cv2.VideoWriter_fourcc(*'VP90')
   ```

这些是一些常见的视频文件格式和相应的四字符编码标识示例。根据你的需求和所使用的视频文件格式，选择适合的编码标识以确保视频文件可以正确编码和解码。不同的视频编辑软件和播放器也支持不同的编解码器，因此你可能需要根据最终使用情况进行调整。

# 全部代码


```python
import logging
import time
import cv2
import json
# 读取JSON文件
with open('../inoutdir/long.json', 'r') as f:
    json_data = json.load(f)
# 打开视频文件
cap = cv2.VideoCapture('../inoutdir/long.mp4')
current_frame = 0
# 配置日志记录
logging.basicConfig(level=logging.INFO, format='%(asctime)s [Frame %(frame)d / %(frame_all)d] %(message)s')
logger = logging.getLogger()
FLAG_SAVE_VIDEOS = False
if FLAG_SAVE_VIDEOS:
    output_file = '../output/long_draw.mp4'
    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
    frame_width = int(cap.get(3))
    frame_height = int(cap.get(4))
    out = cv2.VideoWriter(output_file, fourcc, 30, (frame_width, frame_height))
# 初始化时间统计
start_time = time.time()
total_frames = len(json_data)
while True:
    cap.set(cv2.CAP_PROP_POS_FRAMES, current_frame)
    ret, frame = cap.read()
    if not ret:
        break
    # 记录时间戳
    frame_timestamp = time.time()
    # 从JSON中获取当前帧的检测结果
    if current_frame < len(json_data):
        detections = json_data[current_frame]['dets']
        # 在每个检测上绘制边界框
        for det in detections:
            x1, y1, x2, y2, score, class_id = det
            color = (0, 255, 0)  # 绿色边界框
            label = f'{int(class_id)},{score:.2f}'
            cv2.rectangle(frame, (int(x1), int(y1)), (int(x2), int(y2)), color, 2)
            # 计算文本位置以确保在框内
            text_x = int(x1)
            text_y = int(y1) - 10
            if text_y - 10 < 0:
                text_y = int(y1) + 20  # 如果文本位置超出了帧的上边界，则将其放在边界框的下方
            cv2.putText(frame, label, (text_x, text_y), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
    if FLAG_SAVE_VIDEOS:
        out.write(frame)  # 将当前帧写入输出视频
        current_frame += 1
    else:
        # 显示当前帧
        cv2.imshow('Video Frame', frame)
        # 等待按键输入
        key = cv2.waitKey(0)  # 使用较短的等待时间以确保视频正常播放
        if key == 27:  # ESC
            break
        elif key == ord('q'):  # Q 键（往回跳一帧）
            if current_frame > 0:
                current_frame -= 1
        elif key == ord('w'):  # W 键（往前播放一帧）
            if current_frame < len(json_data) - 1:
                current_frame += 1
    # 计算每一帧消耗的时间并记录到日志中
    frame_processing_time = time.time() - frame_timestamp
    logger.info(f'Frame processed in {frame_processing_time:.4f} seconds',extra={'frame': current_frame, 'frame_all': total_frames})
# 计算总共消耗的时间
total_processing_time = time.time() - start_time
average_frame_time = total_processing_time / total_frames if total_frames > 0 else 0
print(total_processing_time)
print(average_frame_time)
# 释放视频文件、关闭窗口和输出视频文件
cap.release()
if FLAG_SAVE_VIDEOS:
    out.release()
cv2.destroyAllWindows()
```

【Opencv】Pyhton 播放上一帧，下一帧，存video，逐帧分析

# 亮度判断





比如：

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

直方图：

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

代码：

这段代码是一个用于判断图像亮度是否过暗的函数is_dark，并对输入的图像进行可视化直方图展示。

首先，通过import语句导入了cv2和matplotlib.pyplot模块，用于图像处理和可视化。

is_dark函数的作用是判断输入图像的平均亮度是否低于设定的阈值。函数接受两个参数：image_path表示图像文件的路径，threshold表示亮度阈值，默认为100。函数内部的步骤如下：

使用cv2.imread函数读取图像文件，将图像存储在变量img中。

使用cv2.cvtColor函数将图像转换为灰度图像，存储在变量gray中。

使用cv2.mean函数计算灰度图像的平均亮度，存储在变量average_brightness中。

判断average_brightness是否低于设定的阈值threshold，如果是，则返回True表示图像光线过暗；否则返回False表示图像光线正常。

接下来是测试代码部分：

定义了一个图像文件的路径image_path，这里是一个示例路径，请根据实际情况修改。

调用is_dark函数判断图像光线是否过暗，如果返回True，说明图像光线过暗，输出"图片光线过暗"；如果返回False，说明图像光线正常，输出"图片光线正常"。

最后，使用cv2.imread函数再次读取图像文件，将图像存储在变量img中。然后使用plt.hist函数绘制灰度图像的直方图，并通过plt.xlabel和plt.ylabel设置横轴和纵轴的标签。最后使用plt.show显示直方图。这样可以直观地查看图像的亮度分布情况。

```python
import cv2
import matplotlib.pyplot as plt
def is_dark(image_path, threshold=100):
    # 读取图像
    img = cv2.imread(image_path)
    # 转换为灰度图像
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    # 计算灰度图像的平均亮度
    average_brightness = cv2.mean(gray)[0]
    # 判断亮度是否低于阈值
    if average_brightness < threshold:
        return True
    else:
        return False
# 测试代码
image_path = r'E:\facedata\img_data_new\10001normal_face\10001normal_face_0.5893__041430.jpg'
if is_dark(image_path):
    print("图片光线过暗")
else:
    print("图片光线正常")
# 可视化直方图
img = cv2.imread(image_path)
plt.hist(cv2.cvtColor(img, cv2.COLOR_BGR2GRAY).ravel(), bins=256, color='gray')
plt.xlabel('Pixel Value')
plt.ylabel('Frequency')
plt.show()
```


# 模糊判断

```python
import os
import cv2
from tqdm import tqdm
def is_blurry(image_path):
    image = cv2.imread(image_path)
    if image is None:
        raise Exception("无法读取图片")
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    blur_score = cv2.Laplacian(gray, cv2.CV_64F).var()
    return str(round(blur_score * 100)).rjust(10, "0")
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
windowspath = r"E:\facedata\img_data_new"
files = listPathAllfiles(windowspath)
for filename in tqdm(files):
    try:
        num = is_blurry(filename)
    except:
        num = str(round(0 * 100)).rjust(10, "0")
    new_file_name = num + "____" + os.path.basename(filename)
    new_file_name = os.path.join(os.path.dirname(filename), new_file_name)
    os.rename(filename, new_file_name)
```

【图像处理】Python判断一张图像是否亮度过低，图片模糊判定

# 失真






刚性变换： 只有物体的位置(平移变换)和朝向(旋转变换)发生改变，而形状不变，得到的变换称为刚性变换。刚性变换是最一般的变换。

使用透视变换，文字会扭曲失真。刚性变换就不会。

一些介绍： [https://blog.csdn.net/liuweiyuxiang/article/details/86510191](https://blog.csdn.net/liuweiyuxiang/article/details/86510191)

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

# Pillow的实现

创建一张空图写文字：

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

旋转了-30度：

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

将RGBA图像paste到大图中。

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

Python代码：

```python
from PIL import Image, ImageDraw, ImageFont
def draw_text_with_rotation(image, position, text, font_size, color, angle):
    draw = ImageDraw.Draw(image)
    font = ImageFont.truetype("STKAITI.TTF", font_size)
    width, height = draw.textsize(text, font=font)
    rotated_text = Image.new("RGBA", (width, height), (0, 0, 0, 0))
    text_draw = ImageDraw.Draw(rotated_text)
    text_draw.text((0, 0), text, font=font, fill=color)
    rotated_text.save("rotated_text1.png")
    rotated_text = rotated_text.rotate(-angle, resample=Image.BICUBIC, expand=True)
    rotated_text.save("rotated_text2.png")
    image.paste(rotated_text, position, rotated_text)
    rotated_text_width, rotated_text_height = rotated_text.size
    return rotated_text_width, rotated_text_height
# 创建一个空白图像
width, height = 800, 600
background_color = (255, 255, 255)  # 白色
image = Image.new("RGB", (width, height), background_color)
# 在大图中写入文本并旋转
text = "Hello, World!是吗可以的呀"
text_position = (200, 200)
text_font_size = 30
text_color = (0, 0, 0)  # 黑色
rotation_angle = -30
rotated_text_width, rotated_text_height = draw_text_with_rotation(image, text_position, text, text_font_size,
                                                                  text_color, rotation_angle)
# 画一个红色框框选上文字区域
draw = ImageDraw.Draw(image)
draw.rectangle((text_position[0], text_position[1], text_position[0] + rotated_text_width,
                text_position[1] + rotated_text_height), outline=(255, 0, 0))
# 保存图片
image.save("rotated_text3.png")
```

# Opencv的实现

## 不裁剪的旋转图像

参考imutils得到：

```python
import math
import cv2
import numpy as np
def rotate_bound2(image, angle):
    # grab the dimensions of the image and then determine the center
    # 抓取图像的尺寸，然后确定中心
    (h, w) = image.shape[:2]
    (cX, cY) = (w / 2, h / 2)
    # grab the rotation matrix (applying the negative of the angle to rotate clockwise), then grab the sine and cosine (i.e., the rotation components of the matrix)
    # 抓取旋转矩阵（应用角度的负数顺时针旋转），然后抓取正弦和余弦（即矩阵的旋转分量）
    M = cv2.getRotationMatrix2D((cX, cY), -angle, 1.0)
    cos = np.abs(M[0, 0])
    sin = np.abs(M[0, 1])
    # compute the new bounding dimensions of the image
    # 计算图像的新边界尺寸
    nW = int((h * sin) + (w * cos))
    nH = int((h * cos) + (w * sin))
    # adjust the rotation matrix to take into account translation
    # 调整旋转矩阵以考虑平移
    M[0, 2] += (nW / 2) - cX
    M[1, 2] += (nH / 2) - cY
    # perform the actual rotation and return the image
    # 执行实际旋转并返回图像
    return cv2.warpAffine(image, M, (nW, nH), flags=cv2.INTER_CUBIC)
def rotate_image(image, angle):
    angle = angle % 360.0
    if angle == 0:
        return image.copy()
    if angle == 180:
        return cv2.rotate(image, cv2.ROTATE_180)
    if angle == 90:
        return cv2.rotate(image, cv2.ROTATE_90_CLOCKWISE)
    if angle == 270:
        return cv2.rotate(image, cv2.ROTATE_90_COUNTERCLOCKWISE)
    return rotate_bound2(image, angle)
# 读取RGBA
image = cv2.imread('rotated_text1.png', cv2.IMREAD_UNCHANGED)
# 对图像进行旋转并扩展
rotated_image = rotate_image(image, 45)
# SAVE
cv2.imwrite("rotated_text1_rotated.png", rotated_image)
```

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

## 旋转文字并贴图

```python
import math
import cv2
import numpy as np
def rotate_bound2(image, angle):
    # grab the dimensions of the image and then determine the center
    # 抓取图像的尺寸，然后确定中心
    (h, w) = image.shape[:2]
    (cX, cY) = (w / 2, h / 2)
    # grab the rotation matrix (applying the negative of the angle to rotate clockwise), then grab the sine and cosine (i.e., the rotation components of the matrix)
    # 抓取旋转矩阵（应用角度的负数顺时针旋转），然后抓取正弦和余弦（即矩阵的旋转分量）
    M = cv2.getRotationMatrix2D((cX, cY), -angle, 1.0)
    cos = np.abs(M[0, 0])
    sin = np.abs(M[0, 1])
    # compute the new bounding dimensions of the image
    # 计算图像的新边界尺寸
    nW = int((h * sin) + (w * cos))
    nH = int((h * cos) + (w * sin))
    # adjust the rotation matrix to take into account translation
    # 调整旋转矩阵以考虑平移
    M[0, 2] += (nW / 2) - cX
    M[1, 2] += (nH / 2) - cY
    # perform the actual rotation and return the image
    # 执行实际旋转并返回图像
    return cv2.warpAffine(image, M, (nW, nH), flags=cv2.INTER_CUBIC)
def rotate_image(image, angle):
    angle = angle % 360.0
    if angle == 0:
        return image.copy()
    if angle == 180:
        return cv2.rotate(image, cv2.ROTATE_180)
    if angle == 90:
        return cv2.rotate(image, cv2.ROTATE_90_CLOCKWISE)
    if angle == 270:
        return cv2.rotate(image, cv2.ROTATE_90_COUNTERCLOCKWISE)
    return rotate_bound2(image, angle)
def draw_text_with_rotation(image, position, text, font_size, color, angle):
    # 定义字体样式
    font = cv2.FONT_HERSHEY_SIMPLEX
    thickness = 2
    # 获取文字的宽度和高度
    text_size, baseline = cv2.getTextSize(text, font, font_size, thickness)
    print(text_size, baseline)
    text_width, text_height = text_size
    # 灰度图上白纸黑字
    text_image = np.zeros((text_height + baseline, text_width, 1), np.uint8)
    cv2.putText(text_image, text, (0, text_height), font, font_size, (255,), thickness)  # top-left corner.
    # 灰度图给到透明通道上
    text_image2 = np.zeros((text_height + baseline, text_width, 4), np.uint8)
    text_image2[:, :, 3] = text_image[:, :, 0]
    text_image = text_image2
    cv2.imwrite("self1.png", text_image)
    rotated_text = rotate_image(text_image, angle)
    cv2.imwrite("self2.png", rotated_text)
    rotated_text_height, rotated_text_width = rotated_text.shape[:2]
    image[position[0]:position[0] + rotated_text_height, position[1]:position[1] + rotated_text_width] = rotated_text
    return rotated_text_width, rotated_text_height
# 创建一个空白图像
width, height = 800, 600
image = np.zeros((height, width, 4), np.uint8)
# 在大图中写入文本并旋转
text = "Hello, World"
text_position = (200, 200)
text_font_size = 1
text_color = (255, 255, 255)  # 黑色
rotation_angle = -30
rotated_text_width, rotated_text_height = draw_text_with_rotation(image, text_position, text, text_font_size,
                                                                  text_color, rotation_angle)
# 画一个红色框框选上文字区域
cv2.rectangle(image, (text_position[0], text_position[1]),
              (text_position[0] + rotated_text_width, text_position[1] + rotated_text_height), (0, 0, 255, 255), 2)
# 保存图片
cv2.imwrite("self3.png", image)
```

文字图：

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

旋转后：

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

贴图：

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




## C++的图片透视变换

```cpp
        // textImgMask的四个顶点
        std::vector<cv::Point> ptsSrc;
        ptsSrc.emplace_back(0, 0);
        ptsSrc.emplace_back(textImgMask.cols, 0);
        ptsSrc.emplace_back(textImgMask.cols, textImgMask.rows);
        ptsSrc.emplace_back(0, textImgMask.rows);
        // ptsImgText的四个顶点
        std::vector<cv::Point> ptsDst;
        ptsDst.emplace_back(ptsImgText[0]);
        ptsDst.emplace_back(ptsImgText[1]);
        ptsDst.emplace_back(ptsImgText[2]);
        ptsDst.emplace_back(ptsImgText[3]);
        // 计算透视变换矩阵
        cv::Mat homography = cv::findHomography(ptsSrc, ptsDst);
        // 透视变换到imgOutTmp
        cv::Mat imgOutTmp = cv::Mat::zeros(img.size(), CV_8UC3);
        cv::warpPerspective(textImgMask, imgOutTmp, homography, img.size());
        // 转到原图
        cv::Mat gray;
        cv::cvtColor(imgOutTmp, gray, cv::COLOR_BGR2GRAY);
        imgOut.setTo(cv::Scalar(textColors[i][2], textColors[i][1], textColors[i][0]), gray > 125);  // mask部分改色
```

【Opencv】PIL Opencv 向图片写入文字并旋转文字，Opencv图片旋转不截断，Opencv图片旋转不裁剪

版本不一样的时候，返回也不一样。





我使用opencv/4.5.5。

下图是使用minAreaRect判定的角度，可以看到，数值范围是[0,90]，看起来很离谱。

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

画出这张图使用的程序如下：

C++
```cpp
int main() {
    std::string prefix1 =
        "/mnt/c/Users/dong.xie/Desktop/workcode/cpp_project/photo_translate/03implement/photo_translate/"
        "test_photo_translate/";
    // 写一段程序，显示opencv中的角度是怎么计算的
    // 构建一个全白色的4000*4000的图片
    cv::Mat img = cv::Mat::zeros(4000, 4000, CV_8UC3);
    img.setTo(cv::Scalar(114, 114, 114));
    // 遍历0度到360度
    for (int i = 0; i < 360; i = i + 10) {
        //(2000,2000)与(3200,2000)是一条直线，(2000,2000)是原点，不断旋转这条直线，看看旋转后的直线的角度是多少
        int p0x = 2000;
        int p0y = 2000;
        int p1x = 3200;
        int p1y = 2000;
        p1x = 1200 * std::cos(i * 3.1415926 / 180) + p0x;
        p1y = -1200 * std::sin(i * 3.1415926 / 180) + p0y;
        cv::Mat pts = (cv::Mat_<float>(4, 2) << p0x, p0y, p1x, p1y, p0x + 2, p0y + 2, p1x + 2, p1y + 2);
        // 绘制(p0x,p0y)与（p1x，p1y)这条直线
        cv::line(img, cv::Point2f(p0x, p0y), cv::Point2f(p1x, p1y), cv::Scalar(0, 0, 255), 2);
        cv::RotatedRect rect = cv::minAreaRect(pts);
        // 画出旋转后的直线
        cv::Point2f vertices[4];
        rect.points(vertices);
        for (int i = 0; i < 4; i++)
            cv::line(img, vertices[i], vertices[(i + 1) % 4], cv::Scalar(0, 0, 255), 2);
        // 显示旋转后的直线的角度
        cv::putText(img,
                    std::to_string(rect.angle).substr(0, 5),
                    cv::Point(p1x, p1y),
                    cv::FONT_HERSHEY_SIMPLEX,
                    2,
                    cv::Scalar(0, 255, 0),
                    2);
    }
    cv::imwrite(prefix1 + "test.jpg", img);
    return 0;
}
```

那么python中呢，如果版本是一样的，那么结果是一样的，如果版本不同，比如4.4，那么就不会是一样的结果。

```python
import cv2
import numpy as np
print(cv2.__version__)
img = np.zeros((4000, 4000, 3), np.uint8)
img[:] = 114
for i in range(0, 360, 10):
    p0x = 2000
    p0y = 2000
    p1x = 3200
    p1y = 2000
    p1x = 1200 * np.cos(i * np.pi / 180) + p0x
    p1y = -1200 * np.sin(i * np.pi / 180) + p0y
    pts = np.array([[p0x, p0y], [p1x, p1y], [p0x + 2, p0y + 2], [p1x + 2, p1y + 2]], np.float32)
    cv2.line(img, (int(p0x), int(p0y)), (int(p1x), int(p1y)), (0, 0, 255), 2)
    rect = cv2.minAreaRect(pts)
    box = cv2.boxPoints(rect)
    box = np.int0(box)
    cv2.drawContours(img, [box], 0, (0, 0, 255), 2)
    cv2.putText(img, str(rect[2])[0:5], (int(p1x), int(p1y)), cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 255, 0), 2)
cv2.imwrite('test.jpg', img)
```

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

C++的OpenCV中cv::minAreaRect的返回角度的数值范围是多少？

# 传统方法





程序
```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)