字符批量分割脚本调试，效果一般，需要调整参数

文字使用umi-ocr识别，批量重命名后可以看出识别效果并不好

@赤霄 #196935

这个有人己直接做出软件了，我也是苦于字体，平时都是用到一些不常见的字，目前正自学软件，自己刻复《鉅宋廣韻》。以下是切片软件网址：https://vistudium.top/gouken/

@赤霄 #196961

如果有软件批量处理肯定是好事，理论上说自动识别文字，自动切割图片，自动载入软件，自动居中布局，短时间内就能实现数万字的字库，将来肯定会实现，但现在这种工具罕见不好用。

样本材料，基本上决定字库的生命。用广韵、集韵这些材料好处是：重复性极低、易检索文字、字量足够多。问题是：刻工都不怎么样、风格不统一后续补字主要靠拼接。

我猜测是因为韵书类，正文大字都是孤零零的刻出来的，刻工很不适应这种状态，如果是成行成列的，他有参考，整体的风貌会协调一点。

前期调研，或者说少量试验（比如1000字）还是要做。以我的认知，宋刻字体在南宋中后期，尤其是绍熙嘉定左右达到巅峰，这时期安徽一带的颜体，极佳。如果要说欧体，就是浙江刻本最好，尤其是杭州刻本天下第一，但是这些好的样本，现在都没有很好的图源。世彩堂的算是浙刻欧体，图源也清晰，但有人做了，黄善夫的算颜体极佳，有人做，但主要是图片普清，不好做。有些时候，我觉得倒不如用日本宫内厅的崇宁大藏做，时间在北宋晚期到绍兴时代，字多、图源清晰、风格统一，问题就是检索烦一点，这种大藏的刻工水平也还没到最善

批量识别正文分割参数调整面板

测试效果图

批量分割Python代码

import cv2
import numpy as np
import os
import glob

class AncientTextSegmentor:
def __init__(self, min_char_width=20, max_char_width=100, min_char_height=30, max_char_height=100,
width_expansion=0.2, height_expansion=0.3, min_aspect_ratio=0.5, max_aspect_ratio=2.0):
"""
初始化古籍文字分割器

参数:
min_char_width: 最小字符宽度
max_char_width: 最大字符宽度
min_char_height: 最小字符高度
max_char_height: 最大字符高度
width_expansion: 宽度扩展比例 (0 = 扩展0%)
height_expansion: 高度扩展比例 (0 = 扩展0%)
min_aspect_ratio: 最小宽高比
max_aspect_ratio: 最大宽高比
"""
self.min_char_width = min_char_width
self.max_char_width = max_char_width
self.min_char_height = min_char_height
self.max_char_height = max_char_height
self.width_expansion = width_expansion
self.height_expansion = height_expansion
self.min_aspect_ratio = min_aspect_ratio
self.max_aspect_ratio = max_aspect_ratio

def preprocess_image(self, image_path):
"""图像预处理"""
print(f"尝试读取图像: {image_path}")

if not os.path.exists(image_path):
raise ValueError(f"文件不存在: {image_path}")

# 读取图像
img = cv2.imread(image_path)
if img is None:
try:
with open(image_path, 'rb') as f:
img_data = np.frombuffer(f.read(), np.uint8)
img = cv2.imdecode(img_data, cv2.IMREAD_COLOR)
except Exception as e:
raise ValueError(f"无法读取图像文件: {e}")

if img is None:
raise ValueError("无法读取图像文件")

print(f"图像读取成功，尺寸: {img.shape}")

# 转换为灰度图
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# 使用自适应阈值进行二值化
binary = cv2.adaptiveThreshold(
gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
cv2.THRESH_BINARY_INV, 11, 2
)

return img, binary

def detect_text_regions(self, binary_img):
"""检测文本区域 - 改进的选区检测"""
# 使用不同的形态学操作组合
kernel_small = cv2.getStructuringElement(cv2.MORPH_RECT, (2, 2))
kernel_medium = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))

# 先进行开操作去除噪声
opened = cv2.morphologyEx(binary_img, cv2.MORPH_OPEN, kernel_small)

# 然后进行闭操作连接文字部件
closed = cv2.morphologyEx(opened, cv2.MORPH_CLOSE, kernel_medium)

# 查找轮廓
contours, _ = cv2.findContours(
closed, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
)

# 筛选可能的文字区域
char_regions = []
for contour in contours:
x, y, w, h = cv2.boundingRect(contour)

aspect_ratio = w / h if h > 0 else 0
area = w * h

# 改进的筛选条件
if (h >= self.min_char_height and
w >= self.min_char_width and
w <= self.max_char_width and
h <= self.max_char_height and
self.min_aspect_ratio <= aspect_ratio <= self.max_aspect_ratio and
area > 150 and area < 50000): # 增加最大面积限制
char_regions.append((x, y, w, h))

print(f"初步检测到 {len(char_regions)} 个候选区域")
return char_regions

def adjust_region_size(self, region, img_width, img_height):
"""调整选区大小"""
x, y, w, h = region

# 计算扩展量
width_padding = int(w * self.width_expansion)
height_padding = int(h * self.height_expansion)

# 应用扩展
new_x = max(0, x - width_padding)
new_y = max(0, y - height_padding)
new_w = min(img_width - new_x, w + 2 * width_padding)
new_h = min(img_height - new_y, h + 2 * height_padding)

return (new_x, new_y, new_w, new_h)

def merge_overlapping_regions(self, regions, overlap_threshold=0.3):
"""合并重叠的区域"""
if not regions:
return []

# 按面积排序，先处理大的区域
regions.sort(key=lambda r: r[2] * r[3], reverse=True)

merged_regions = []
used = [False] * len(regions)

for i, (x1, y1, w1, h1) in enumerate(regions):
if used[i]:
continue

current_region = (x1, y1, w1, h1)

# 查找重叠的区域
for j, (x2, y2, w2, h2) in enumerate(regions[i+1:], i+1):
if used[j]:
continue

# 计算重叠面积
overlap_x = max(x1, x2)
overlap_y = max(y1, y2)
overlap_w = min(x1 + w1, x2 + w2) - overlap_x
overlap_h = min(y1 + h1, y2 + h2) - overlap_y

if overlap_w > 0 and overlap_h > 0:
overlap_area = overlap_w * overlap_h
area1 = w1 * h1
area2 = w2 * h2

# 如果重叠面积超过阈值，合并区域
if overlap_area / min(area1, area2) > overlap_threshold:
# 合并两个区域
new_x = min(x1, x2)
new_y = min(y1, y2)
new_w = max(x1 + w1, x2 + w2) - new_x
new_h = max(y1 + h1, y2 + h2) - new_y
current_region = (new_x, new_y, new_w, new_h)
used[j] = True

merged_regions.append(current_region)
used[i] = True

print(f"区域合并: {len(regions)} -> {len(merged_regions)}")
return merged_regions

def filter_main_text(self, regions, img_height):
"""过滤出大字正文"""
if not regions:
return []

# 按y坐标分组，识别文本行
regions.sort(key=lambda r: r[1])

# 计算平均字符高度
heights = [h for _, _, _, h in regions]
avg_height = np.mean(heights) if heights else self.min_char_height

# 按行分组
lines = []
current_line = []
line_y = -1

for region in regions:
x, y, w, h = region

if line_y == -1:
line_y = y
current_line.append(region)
elif abs(y - line_y) <= avg_height * 0.6: # 增加行内容差
current_line.append(region)
else:
if current_line:
# 按x坐标排序
current_line.sort(key=lambda r: r[0])
lines.append(current_line)
current_line = [region]
line_y = y

if current_line:
current_line.sort(key=lambda r: r[0])
lines.append(current_line)

# 识别大字行
main_text_regions = []
for i, line in enumerate(lines):
if len(line) >= 1: # 即使只有一个字符也可能是正文
line_heights = [h for _, _, _, h in line]
avg_line_height = np.mean(line_heights)

# 大字行的特征
if (avg_line_height >= self.min_char_height and
len(line) >= 1): # 放宽条件

# 计算行内字符间距
if len(line) > 1:
spacings = []
for j in range(1, len(line)):
prev_right = line[j-1][0] + line[j-1][2]
curr_left = line[j][0]
spacings.append(curr_left - prev_right)
avg_spacing = np.mean(spacings) if spacings else 0

# 如果字符间距合理，认为是正文行
if avg_spacing <= avg_line_height * 2:
main_text_regions.extend(line)
else:
# 单字符行也可能是正文
main_text_regions.extend(line)

print(f"识别出 {len(main_text_regions)} 个正文区域")
return main_text_regions

def segment_characters(self, image_path, output_dir="./output_chars", show_windows=False):
"""主函数：分割字符并保存

参数:
image_path: 输入图像路径
output_dir: 输出目录
show_windows: 是否显示可视化窗口（批量处理时建议设为False）
"""
os.makedirs(output_dir, exist_ok=True)

print("正在处理图像...")
try:
original_img, binary_img = self.preprocess_image(image_path)
except Exception as e:
print(f"图像处理错误: {e}")
return []

img_height, img_width = original_img.shape[:2]

print("检测文字区域...")
regions = self.detect_text_regions(binary_img)

# 合并重叠区域
merged_regions = self.merge_overlapping_regions(regions)

# 过滤出大字正文
main_text_regions = self.filter_main_text(merged_regions, img_height)

if not main_text_regions:
print("未检测到大字正文区域，使用所有检测区域")
main_text_regions = merged_regions

# 调整选区大小
adjusted_regions = []
for region in main_text_regions:
adjusted_region = self.adjust_region_size(region, img_width, img_height)
adjusted_regions.append(adjusted_region)

print(f"最终得到 {len(adjusted_regions)} 个调整后的大字区域")

# 按从右到左的顺序排序
adjusted_regions.sort(key=lambda r: r[0], reverse=True)

# 保存单个字符图片
char_images = []
for i, (x, y, w, h) in enumerate(adjusted_regions):
# 确保在图像范围内
x_start = max(0, x)
y_start = max(0, y)
x_end = min(img_width, x + w)
y_end = min(img_height, y + h)

char_img = original_img[y_start:y_end, x_start:x_end]

# 检查图像是否有效
if char_img.size == 0:
print(f"跳过空图像区域: {i}")
continue

output_path = os.path.join(output_dir, f"char_{i:03d}.png")
cv2.imwrite(output_path, char_img)
char_images.append(output_path)

print(f"保存字符 {i:03d}: 位置({x}, {y}), 尺寸({w}x{h})")

# 创建可视化结果
self.create_visualization(original_img, regions, adjusted_regions, output_dir, show_windows)

print(f"处理完成！共分割出 {len(char_images)} 个字符")
return char_images

def create_visualization(self, original_img, all_regions, main_regions, output_dir, show_windows=False):
"""创建可视化结果

参数:
show_windows: 是否显示可视化窗口
"""
result_img = original_img.copy()

# 绘制所有检测到的区域（半透明红色）
for x, y, w, h in all_regions:
overlay = result_img.copy()
cv2.rectangle(overlay, (x, y), (x + w, y + h), (0, 0, 255), -1)
cv2.addWeighted(overlay, 0.3, result_img, 0.7, 0, result_img)
cv2.rectangle(result_img, (x, y), (x + w, y + h), (0, 0, 255), 1)

# 绘制大字正文区域（绿色边框）
for x, y, w, h in main_regions:
cv2.rectangle(result_img, (x, y), (x + w, y + h), (0, 255, 0), 2)

vis_path = os.path.join(output_dir, "segmentation_result.jpg")
cv2.imwrite(vis_path, result_img)
print(f"可视化结果已保存: {vis_path}")

# 只有在需要显示窗口时才显示
if show_windows:
# 调整显示窗口大小
height, width = result_img.shape[:2]
if width > 1200:
scale = 1200 / width
display_img = cv2.resize(result_img, (int(width * scale), int(height * scale)))
else:
display_img = result_img

cv2.imshow('Segmentation Result - Red: All, Green: Main Text', display_img)
print("按任意键关闭窗口...")
cv2.waitKey(0)
cv2.destroyAllWindows()

def interactive_adjustment():
"""交互式参数调整"""
print("=== 古籍文字分割参数调整 ===")

# 基本参数
min_char_width = int(input("最小字符宽度 (默认50): ") or 50)
max_char_width = int(input("最大字符宽度 (默认150): ") or 150)
min_char_height = int(input("最小字符高度 (默认50): ") or 50)
max_char_height = int(input("最大字符高度 (默认150): ") or 150)

# 扩展参数
width_expansion = float(input("宽度扩展比例 (默认0): ") or 0)
height_expansion = float(input("高度扩展比例 (默认0): ") or 0)

# 宽高比参数
min_aspect_ratio = float(input("最小宽高比 (默认0.5): ") or 0.5)
max_aspect_ratio = float(input("最大宽高比 (默认2.0): ") or 2.0)

return AncientTextSegmentor(
min_char_width=min_char_width,
max_char_width=max_char_width,
min_char_height=min_char_height,
max_char_height=max_char_height,
width_expansion=width_expansion,
height_expansion=height_expansion,
min_aspect_ratio=min_aspect_ratio,
max_aspect_ratio=max_aspect_ratio
)

def batch_process_images():
"""批量处理文件夹中的所有图像"""
print("=== 批量处理模式 ===")

# 输入文件夹路径
input_folder = input("请输入包含古籍图像的文件夹路径: ").strip().strip('"')

if not input_folder or not os.path.exists(input_folder):
print("文件夹不存在")
return

# 支持的图像格式
image_extensions = ['*.jpg', '*.jpeg', '*.png', '*.bmp', '*.tiff', '*.tif']
image_files = []

for extension in image_extensions:
image_files.extend(glob.glob(os.path.join(input_folder, extension)))
image_files.extend(glob.glob(os.path.join(input_folder, extension.upper())))

if not image_files:
print("在指定文件夹中未找到图像文件")
return

print(f"找到 {len(image_files)} 个图像文件")

# 选择模式
print("\n选择参数模式:")
print("1. 自动模式 (使用默认参数)")
print("2. 手动调整参数")
mode = input("请选择 (1/2): ").strip()

if mode == "2":
segmentor = interactive_adjustment()
else:
# 使用优化的默认参数
segmentor = AncientTextSegmentor(
min_char_width=50,
max_char_width=150,
min_char_height=50,
max_char_height=150,
width_expansion=0, # 宽度扩展15%
height_expansion=0, # 高度扩展25%
min_aspect_ratio=0.7, # 最小宽高比
max_aspect_ratio=1.5 # 最大宽高比
)

# 询问是否显示窗口
show_windows = input("处理时是否显示可视化窗口？(y/N): ").strip().lower() == 'y'

# 创建主输出目录
main_output_dir = os.path.join(input_folder, "batch_output")
os.makedirs(main_output_dir, exist_ok=True)

# 处理统计
total_images = len(image_files)
processed_count = 0
success_count = 0

print(f"\n开始批量处理 {total_images} 个图像...")
print("批量处理模式下，可视化结果将自动保存为图片，不会弹出窗口阻碍处理流程")

for i, image_path in enumerate(image_files):
print(f"\n{'='*50}")
print(f"处理图像 {i+1}/{total_images}: {os.path.basename(image_path)}")
print(f"{'='*50}")

try:
# 为每个图像创建单独的输出文件夹
image_name = os.path.splitext(os.path.basename(image_path))[0]
output_dir = os.path.join(main_output_dir, image_name)

# 执行分割，批量处理时不显示窗口
char_images = segmentor.segment_characters(image_path, output_dir, show_windows=show_windows)

if char_images:
success_count += 1
print(f"✅ 成功处理: {os.path.basename(image_path)} - 分割出 {len(char_images)} 个字符")
else:
print(f"⚠️ 警告: {os.path.basename(image_path)} - 未分割出字符")

except Exception as e:
print(f"❌ 处理失败: {os.path.basename(image_path)} - 错误: {e}")

processed_count += 1

# 输出处理总结
print(f"\n{'='*60}")
print("批量处理完成！")
print(f"{'='*60}")
print(f"总图像数: {total_images}")
print(f"成功处理: {success_count}")
print(f"失败数量: {processed_count - success_count}")
print(f"输出目录: {main_output_dir}")
print(f"{'='*60}")

def single_image_process():
"""单张图像处理模式"""
print("=== 单张图像处理模式 ===")

# 设置输入图像路径
input_image = input("请输入古籍图像路径: ").strip().strip('"')

if not input_image or not os.path.exists(input_image):
print("文件不存在")
return

# 选择模式
print("\n选择模式:")
print("1. 自动模式 (使用默认参数)")
print("2. 手动调整参数")
mode = input("请选择 (1/2): ").strip()

if mode == "2":
segmentor = interactive_adjustment()
else:
# 使用优化的默认参数
segmentor = AncientTextSegmentor(
min_char_width=50,
max_char_width=150,
min_char_height=50,
max_char_height=150,
width_expansion=0, # 宽度扩展15%
height_expansion=0, # 高度扩展25%
min_aspect_ratio=0.7, # 最小宽高比
max_aspect_ratio=1.5 # 最大宽高比
)

print(f"处理图像: {input_image}")

# 执行分割，单张图像处理时显示窗口
output_dir = "./output_chars"
char_images = segmentor.segment_characters(input_image, output_dir, show_windows=True)

if char_images:
print(f"\n✅ 处理完成！字符图片保存在: {output_dir}")
print(f"共生成 {len(char_images)} 个字符图片")
else:
print("\n❌ 处理失败")

def main():
"""主函数"""
print("=== 古籍文字分割工具 (批量处理版) ===")

while True:
print("\n选择处理模式:")
print("1. 单张图像处理")
print("2. 批量处理文件夹")
print("3. 退出")

choice = input("请选择 (1/2/3): ").strip()

if choice == "1":
single_image_process()
elif choice == "2":
batch_process_images()
elif choice == "3":
print("再见！")
break
else:
print("无效选择，请重新输入")

if __name__ == "__main__":
main()

像素图转svg矢量图运行情况

测试效果图

代码

# convert_with_tif_support.py
import os
import subprocess
import tempfile
from PIL import Image
import glob
import sys

def check_tif_support():
"""检查 TIF 支持"""
try:
# 测试是否能打开 TIF 文件
test_img = Image.new('L', (10, 10), 255)
with tempfile.NamedTemporaryFile(suffix='.tif', delete=False) as f:
test_img.save(f.name, format='TIFF')
with Image.open(f.name) as img:
print(f"✅ TIF 格式支持: {img.format}")
os.unlink(f.name)
return True
except Exception as e:
print(f"❌ TIF 格式不支持: {e}")
return False

def convert_image_to_svg(input_file, output_file):
"""使用 potrace 将图像转换为真正的矢量 SVG"""
try:
print(f"转换: {os.path.basename(input_file)}")

# 1. 打开并预处理图像
with Image.open(input_file) as img:
print(f" 原始: {img.size}, {img.mode}, 格式: {img.format}")

# 处理不同格式的特殊情况
if img.format == 'TIFF':
print(" 🖼️ 处理 TIF 文件")
# TIF 文件可能有特殊模式，确保转换为灰度
if img.mode in ['I;16', 'I;16B', 'I;16L', 'I;16N']:
# 16位灰度图像，转换为8位
img = img.point(lambda i: i * (255 / 65535))
img = img.convert('L')
elif img.mode == 'F':
# 浮点图像
img = img.point(lambda i: i * 255)
img = img.convert('L')

# 转换为灰度
if img.mode != 'L':
img = img.convert('L')
print(" 转换为灰度")

# 调整图像大小（如果太大）
max_size = 1000
width, height = img.size
if max(width, height) > max_size:
ratio = max_size / max(width, height)
new_size = (int(width * ratio), int(height * ratio))
img = img.resize(new_size, Image.Resampling.LANCZOS)
print(f" 调整尺寸: {new_size}")

# 创建临时 BMP 文件
with tempfile.NamedTemporaryFile(suffix='.bmp', delete=False) as temp_bmp:
temp_bmp_path = temp_bmp.name
img.save(temp_bmp_path, format='BMP')
print(f" 创建临时文件: {os.path.basename(temp_bmp_path)}")

# 2. 使用 potrace 进行矢量转换
cmd = [
'potrace',
temp_bmp_path,
'-s', # 输出 SVG 格式
'-o', output_file, # 输出文件
'--flat' # 确保完全矢量化
]

print(" 运行 potrace...")
result = subprocess.run(cmd, capture_output=True, text=True)

# 3. 清理临时文件
os.unlink(temp_bmp_path)

if result.returncode == 0:
# 检查输出文件大小
if os.path.exists(output_file):
file_size = os.path.getsize(output_file)
print(f"✅ 成功: {os.path.basename(output_file)} ({file_size} 字节)")
return True
else:
print("❌ 输出文件未生成")
return False
else:
print(f"❌ potrace 错误: {result.stderr}")
return False

except Exception as e:
print(f"❌ 转换失败: {e}")
# 清理临时文件（如果存在）
if 'temp_bmp_path' in locals() and os.path.exists(temp_bmp_path):
os.unlink(temp_bmp_path)
return False

def optimize_svg_for_font(svg_file):
"""优化 SVG 文件，使其更适合字体使用"""
try:
with open(svg_file, 'r', encoding='utf-8') as f:
content = f.read()

# 简单的优化
optimized = content

# 确保有 viewBox
if 'viewBox' not in content and 'width' in content and 'height' in content:
# 从 width 和 height 提取数值
import re
width_match = re.search(r'width="([^"]+)"', content)
height_match = re.search(r'height="([^"]+)"', content)

if width_match and height_match:
width = width_match.group(1)
height = height_match.group(1)
# 移除单位
width_num = ''.join(filter(str.isdigit, width))
height_num = ''.join(filter(str.isdigit, height))
if width_num and height_num:
optimized = optimized.replace(
'<svg ',
f'<svg viewBox="0 0 {width_num} {height_num}" '
)

with open(svg_file, 'w', encoding='utf-8') as f:
f.write(optimized)

return True

except Exception as e:
print(f"优化失败: {e}")
return False

def batch_convert_all_formats():
"""批量转换所有支持的格式"""
print("=== 批量转换工具 (支持 TIF) ===\n")

# 检查 TIF 支持
check_tif_support()

# 查找所有支持的图片文件
supported_formats = ['*.png', '*.jpg', '*.jpeg', '*.bmp', '*.tif', '*.tiff']
files = []

for format in supported_formats:
found_files = glob.glob(format)
files.extend(found_files)
if found_files:
print(f"找到 {format} 文件: {len(found_files)} 个")

if not files:
print("当前目录没有找到支持的图片文件")
print("支持格式: PNG, JPG, JPEG, BMP, TIF, TIFF")
print("当前目录:", os.getcwd())

# 显示当前目录内容
print("\n当前目录内容:")
for item in os.listdir('.'):
if os.path.isfile(item):
print(f" 📄 {item}")
else:
print(f" 📁 {item}/")
return

print(f"\n总共找到 {len(files)} 个文件:")
for file in files:
file_size = os.path.getsize(file)
with Image.open(file) as img:
format_info = img.format
print(f" - {file} ({format_info}, {file_size} 字节)")

# 创建输出目录
output_dir = "vector_svgs"
if not os.path.exists(output_dir):
os.makedirs(output_dir)
print(f"创建输出目录: {output_dir}")

print(f"\n开始转换...")
print("-" * 50)

success_count = 0
failed_files = []

# 转换每个文件
for file in files:
output_file = os.path.join(output_dir, os.path.splitext(os.path.basename(file))[0] + ".svg")

if convert_image_to_svg(file, output_file):
# 优化 SVG 文件
optimize_svg_for_font(output_file)
success_count += 1
else:
failed_files.append(os.path.basename(file))

# 显示结果
print("\n" + "=" * 50)
print("📊 转换结果统计:")
print(f"✅ 成功: {success_count} 个文件")
print(f"❌ 失败: {len(failed_files)} 个文件")
print(f"📁 输出位置: {os.path.abspath(output_dir)}")

if failed_files:
print("\n失败的文件:")
for file in failed_files:
print(f" - {file}")

if success_count > 0:
print(f"\n🎉 矢量转换完成!")
print("这些 SVG 文件包含真正的矢量路径，可以在 FontForge 中使用了")

def preview_svg_files():
"""预览生成的 SVG 文件"""
output_dir = "vector_svgs"

if not os.path.exists(output_dir):
print("输出文件夹不存在")
return

svg_files = glob.glob(os.path.join(output_dir, "*.svg"))

if not svg_files:
print("没有找到 SVG 文件")
return

print(f"\n📁 生成的 SVG 文件 ({len(svg_files)} 个):")
for i, svg_file in enumerate(svg_files[:5], 1):
size = os.path.getsize(svg_file)
with open(svg_file, 'r', encoding='utf-8') as f:
content = f.read()
has_paths = 'path d=' in content
path_count = content.count('path d=')
path_type = f"矢量路径({path_count}个)" if has_paths else "其他"

print(f" {i}. {os.path.basename(svg_file)}")
print(f" 大小: {size} 字节, 类型: {path_type}")

def convert_specific_tif_files():
"""专门处理 TIF 文件的函数"""
print("=== TIF 文件专门处理 ===")

tif_files = glob.glob("*.tif") + glob.glob("*.tiff")

if not tif_files:
print("没有找到 TIF 文件")
return

print(f"找到 {len(tif_files)} 个 TIF 文件:")

for tif_file in tif_files:
print(f"\n处理: {tif_file}")

try:
with Image.open(tif_file) as img:
print(f" 格式: {img.format}, 模式: {img.mode}, 尺寸: {img.size}")

# 显示 TIF 文件信息
if hasattr(img, 'tag'):
print(" TIF 标签信息:")
for tag, value in list(img.tag_v2.items())[:5]: # 只显示前5个标签
print(f" {tag}: {value}")

except Exception as e:
print(f" 读取 TIF 文件信息失败: {e}")

if __name__ == "__main__":
# 显示系统信息
print(f"Python版本: {sys.version}")
print(f"Pillow版本: {Image.__version__}")
print()

# 执行批量转换
batch_convert_all_formats()

# 预览结果
preview_svg_files()

# 专门显示 TIF 文件信息
convert_specific_tif_files()

print(f"\n💡 现在你可以在 FontForge 中导入这些 SVG 文件了!")

@阿东 #197023

看不看得懂都没事，传给deepseek，让它读，有问题就问它，根据提示做就好了。

svg矢量图片转字体运行，有些瑕疵，问题不大，成功转字体，字体文件my_font.ttf使用fontforge打开正常。

代码如下：

import subprocess
import os
import tempfile
import sys

def get_fontforge_path():
"""获取FontForge可执行文件路径"""
possible_paths = [
r"C:\Program Files\FontForgeBuilds\bin\fontforge.exe",
r"C:\Program Files (x86)\FontForgeBuilds\fontforge.exe",
r"C:\Program Files\FontForge\fontforge.exe",
]

for path in possible_paths:
if os.path.exists(path):
return path

return possible_paths[0] # 返回默认路径

def create_fontforge_script(svg_dir, output_path):
"""创建FontForge脚本 - 修复编码问题"""
script_content = '''# -*- coding: utf-8 -*-
import fontforge
import os
import sys

def main():
svg_dir = r"{0}"
output_path = r"{1}"

print("Starting font creation...")
print("SVG directory: " + svg_dir)
print("Output file: " + output_path)

# Create new font
font = fontforge.font()
font.fontname = "MyFont"
font.familyname = "My Font Family"
font.fullname = "My Font Regular"
font.weight = "Regular"

# Set font metrics
font.ascent = 800
font.descent = 200

# Check if SVG directory exists
if not os.path.exists(svg_dir):
print("Error: SVG directory does not exist: " + svg_dir)
return 1

# Get SVG files
svg_files = [f for f in os.listdir(svg_dir) if f.lower().endswith('.svg')]

if not svg_files:
print("No SVG files found in directory: " + svg_dir)
return 1

print("Found " + str(len(svg_files)) + " SVG files")

count = 0
for filename in svg_files:
try:
# Get character name from filename
char_name = os.path.splitext(filename)[0]
svg_path = os.path.join(svg_dir, filename)

print("Processing: " + filename)

# Determine Unicode code point
codepoint = 0
if char_name.startswith('uni'):
# uni0041 format
codepoint_str = char_name.replace('uni', '')
codepoint = int(codepoint_str, 16)
elif char_name.startswith('u'):
# u0041 format
codepoint_str = char_name.replace('u', '')
codepoint = int(codepoint_str, 16)
elif char_name.startswith('unicode_'):
# unicode_0041 format
codepoint_str = char_name[8:]
codepoint = int(codepoint_str, 16)
elif len(char_name) == 1:
# Single character name: A.svg
codepoint = ord(char_name)
else:
# Use private use area
codepoint = 0xE000 + (hash(char_name) % 0x1000)
print("Using private use area U+" + format(codepoint, '04X') + " for " + filename)

# Create character
glyph = font.createChar(codepoint)
glyph.importOutlines(svg_path)
glyph.width = 600 # Set character width

count += 1
print("Imported: " + filename + " -> U+" + format(codepoint, '04X'))

except Exception as e:
print("Failed to import " + filename + ": " + str(e))

# Generate font file
print("Generating font file...")
font.generate(output_path)
font.close()

print("Complete! Successfully imported " + str(count) + " characters")
return 0

if __name__ == "__main__":
sys.exit(main())
'''.format(svg_dir, output_path)

# Create temporary script file
with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False, encoding='utf-8') as f:
f.write(script_content)
return f.name

def batch_convert_svg_to_font(svg_dir, output_font):
"""批量转换SVG到字体"""

# 获取FontForge路径
fontforge_path = get_fontforge_path()

if not os.path.exists(fontforge_path):
print(f"错误: FontForge不存在于: {fontforge_path}")
print("请确保已安装FontForge并指定正确路径")
return False

print(f"使用FontForge路径: {fontforge_path}")

# 创建脚本文件
script_path = create_fontforge_script(svg_dir, output_font)

try:
print("开始执行字体生成...")

# 执行FontForge脚本
result = subprocess.run(
[fontforge_path, '-script', script_path],
capture_output=True,
text=True,
encoding='utf-8'
)

# 输出结果
if result.stdout:
print("输出信息:")
print(result.stdout)

if result.stderr:
print("错误信息:")
print(result.stderr)

if result.returncode == 0:
print(f"✓ 字体生成成功: {output_font}")
return True
else:
print(f"✗ 字体生成失败，返回码: {result.returncode}")
return False

except Exception as e:
print(f"执行过程中发生错误: {str(e)}")
return False
finally:
# 清理临时文件
if os.path.exists(script_path):
os.unlink(script_path)

# 使用示例
if __name__ == "__main__":
# 设置SVG目录和输出字体文件
svg_directory = "./svgs" # 修改为你的SVG文件目录
output_font_file = "./my_font.ttf" # 输出的字体文件

# 确保SVG目录存在
if not os.path.exists(svg_directory):
print(f"创建SVG目录: {svg_directory}")
os.makedirs(svg_directory, exist_ok=True)
print(f"请将SVG文件放入 {svg_directory} 目录后重新运行")
else:
# 执行转换
success = batch_convert_svg_to_font(svg_directory, output_font_file)
if success:
print("字体生成完成！")
else:
print("字体生成失败，请检查以上错误信息")

回到重命名步骤，重写脚本，将图片重命名为Unicode字符，也可以用之前的代码，查询到汉字编码后使用正则表达式替换并重新修订csv表格即可。

或者新代码：

import csv
import unicodedata
import codecs

def export_to_csv_excel_friendly(characters, output_file="unicode_results.csv"):
"""
导出为Excel友好的CSV格式（带BOM的UTF-8）
"""
if not characters:
print("没有找到汉字，不创建文件")
return

# 使用BOM写入UTF-8文件，这样Excel就能正确识别编码
with open(output_file, 'w', encoding='utf-8-sig', newline='') as csvfile:
writer = csv.writer(csvfile)
# 写入表头
writer.writerow(['序号', '汉字', 'Unicode', 'UTF-8编码', 'Unicode名称', '字符分类'])

# 写入数据
for i, char in enumerate(characters, 1):
unicode_point = ord(char)
utf8_hex = ' '.join([f'{b:02X}' for b in char.encode('utf-8')])

try:
name = unicodedata.name(char)
category = unicodedata.category(char)
except ValueError:
name = "未知字符"
category = "未知"

writer.writerow([
i,
char,
f"U+{unicode_point:04X}",
utf8_hex,
name,
category
])

print(f"结果已导出到 {output_file}，共 {len(characters)} 个汉字")
print("提示：这个CSV文件可以在Excel中正常打开，不会出现乱码")

def batch_export_from_file(input_file, output_file="unicode_results.csv"):
"""
从文件读取并导出（Excel友好版本）
"""
try:
# 尝试多种编码读取文件
encodings = ['utf-8', 'gbk', 'gb2312', 'gb18030', 'big5']
content = None

for encoding in encodings:
try:
with open(input_file, 'r', encoding=encoding) as file:
content = file.read()
print(f"成功使用编码: {encoding}")
break
except UnicodeDecodeError:
continue

if content is None:
# 最后尝试忽略错误
with open(input_file, 'r', encoding='utf-8', errors='ignore') as file:
content = file.read()
print("使用UTF-8并忽略错误字符")

# 提取汉字
chinese_chars = extract_chinese_chars(content)
print(f"找到 {len(chinese_chars)} 个汉字")

# 导出为Excel友好格式
export_to_csv_excel_friendly(chinese_chars, output_file)

except Exception as e:
print(f"出错: {e}")

def extract_chinese_chars(text):
"""提取汉字"""
chinese_chars = []
for char in text:
if '\u4e00' <= char <= '\u9fff':
chinese_chars.append(char)
return sorted(list(set(chinese_chars)))

# 使用示例
if __name__ == "__main__":
batch_export_from_file("input.txt", "excel_friendly.csv")

流程已通，本帖使命结束，使用的脚本和测试字体已放网盘，对复刻某本书感兴趣的，可以自行调参，分别切分出大字正文和小字双行注释，制作输入法方案可以参考这个十年前的老帖。一切顺利的话，成品初稿会很快完成，还有异体字问题等等需要处理。附个测试字体的图片。

@许由 #197088

刻本相比写本算是呆板的了，为了提升美观度，刻写时多用异体字，目前的电脑字体一般通通合成一个，如果是要排印出来，又更落下乘。

试验流程圆满结束。

@阿东 #197099

ok，等下我把软件也扔网盘里，使用顺序：先安装python、fontforge、umiocr，直接运行脚本文件.python，有问题就把脚本和问题都给deepseek，根据提示处理即可。python脚本使用顺序：切图、识别、转图、成字。

python安装搜教程，不要自己随便装，这样是用不起的。

@阿东 #197106

传好了，久闻Python大名，没想到使用极其简单，打开IDLE—>file—>open—>run—>runmodule或者file—>newfile—>save—>run—>runmodule

小弟非常希望能出现“开成石经”字体

@阿东 #196950

HulenCut 在原网站下载不了了，您能分享下不？

@善行天下 #197185

通过百度网盘分享的文件：切片工具

链接:pan.baidu.com/s/1mE...g?pwd=ipyv

复制这段内容打开「百度网盘APP 即可获取」

还可以补充手动框选和重新框选已识别不准确的，脚本代码：

import cv2
import numpy as np
import os
import glob

class AncientTextSegmentor:
def __init__(self, min_char_width=20, max_char_width=100, min_char_height=30, max_char_height=100,
width_expansion=0.2, height_expansion=0.3, min_aspect_ratio=0.5, max_aspect_ratio=2.0):
"""
初始化古籍文字分割器 - 二值化图像专用
"""
self.min_char_width = min_char_width
self.max_char_width = max_char_width
self.min_char_height = min_char_height
self.max_char_height = max_char_height
self.width_expansion = width_expansion
self.height_expansion = height_expansion
self.min_aspect_ratio = min_aspect_ratio
self.max_aspect_ratio = max_aspect_ratio
self.manual_regions = [] # 存储手动添加的区域
self.removed_regions = [] # 存储被删除的错误区域

def preprocess_image(self, image_path):
"""图像预处理 - 专为二值化图像优化"""
print(f"尝试读取图像: {image_path}")

if not os.path.exists(image_path):
raise ValueError(f"文件不存在: {image_path}")

# 读取图像
img = cv2.imread(image_path)
if img is None:
try:
with open(image_path, 'rb') as f:
img_data = np.frombuffer(f.read(), np.uint8)
img = cv2.imdecode(img_data, cv2.IMREAD_COLOR)
except Exception as e:
raise ValueError(f"无法读取图像文件: {e}")

if img is None:
raise ValueError("无法读取图像文件")

print(f"图像读取成功，尺寸: {img.shape}")

# 如果已经是单通道，直接使用
if len(img.shape) == 2:
gray = img
else:
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# 确保是二值图像 (0和255)
_, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)

# 反转图像，确保文字为白色(255)，背景为黑色(0)
binary = cv2.bitwise_not(binary)

return img, binary

def detect_text_regions(self, binary_img):
"""检测文本区域 - 二值化图像专用"""
# 使用更精细的形态学操作
kernel_tiny = cv2.getStructuringElement(cv2.MORPH_RECT, (1, 1))
kernel_small = cv2.getStructuringElement(cv2.MORPH_RECT, (2, 2))

# 对于二值化图像，减少形态学操作强度
cleaned = cv2.morphologyEx(binary_img, cv2.MORPH_OPEN, kernel_tiny)
connected = cv2.morphologyEx(cleaned, cv2.MORPH_CLOSE, kernel_small)

# 查找轮廓
contours, _ = cv2.findContours(
connected, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
)

# 放宽筛选条件
char_regions = []
for contour in contours:
x, y, w, h = cv2.boundingRect(contour)

aspect_ratio = w / h if h > 0 else 0
area = w * h

if (h >= self.min_char_height * 0.8 and
w >= self.min_char_width * 0.8 and
w <= self.max_char_width * 1.2 and
h <= self.max_char_height * 1.2 and
self.min_aspect_ratio * 0.7 <= aspect_ratio <= self.max_aspect_ratio * 1.3 and
area > 50 and area < 100000):

char_regions.append((x, y, w, h))

print(f"初步检测到 {len(char_regions)} 个候选区域")
return char_regions

def adjust_region_size(self, region, img_width, img_height):
"""调整选区大小"""
x, y, w, h = region

width_padding = int(w * self.width_expansion)
height_padding = int(h * self.height_expansion)

new_x = max(0, x - width_padding)
new_y = max(0, y - height_padding)
new_w = min(img_width - new_x, w + 2 * width_padding)
new_h = min(img_height - new_y, h + 2 * height_padding)

return (new_x, new_y, new_w, new_h)

def merge_overlapping_regions(self, regions, overlap_threshold=0.2):
"""合并重叠的区域 - 更宽松的合并策略"""
if not regions:
return []

regions.sort(key=lambda r: r[2] * r[3], reverse=True)

merged_regions = []
used = [False] * len(regions)

for i, (x1, y1, w1, h1) in enumerate(regions):
if used[i]:
continue

current_region = (x1, y1, w1, h1)

for j, (x2, y2, w2, h2) in enumerate(regions[i+1:], i+1):
if used[j]:
continue

overlap_x = max(x1, x2)
overlap_y = max(y1, y2)
overlap_w = min(x1 + w1, x2 + w2) - overlap_x
overlap_h = min(y1 + h1, y2 + h2) - overlap_y

if overlap_w > 0 and overlap_h > 0:
overlap_area = overlap_w * overlap_h
area1 = w1 * h1
area2 = w2 * h2

if overlap_area / min(area1, area2) > overlap_threshold:
new_x = min(x1, x2)
new_y = min(y1, y2)
new_w = max(x1 + w1, x2 + w2) - new_x
new_h = max(y1 + h1, y2 + h2) - new_y
current_region = (new_x, new_y, new_w, new_h)
used[j] = True

merged_regions.append(current_region)
used[i] = True

print(f"区域合并: {len(regions)} -> {len(merged_regions)}")
return merged_regions

def filter_main_text(self, regions, img_height):
"""过滤出大字正文 - 改进版"""
if not regions:
return []

regions.sort(key=lambda r: r[1])

heights = [h for _, _, _, h in regions]
avg_height = np.mean(heights) if heights else self.min_char_height

lines = []
current_line = []
line_y = -1

for region in regions:
x, y, w, h = region

if line_y == -1:
line_y = y
current_line.append(region)
elif abs(y - line_y) <= avg_height * 1.0:
current_line.append(region)
else:
if current_line:
current_line.sort(key=lambda r: r[0])
lines.append(current_line)
current_line = [region]
line_y = y

if current_line:
current_line.sort(key=lambda r: r[0])
lines.append(current_line)

main_text_regions = []
for i, line in enumerate(lines):
if len(line) >= 1:
line_heights = [h for _, _, _, h in line]
avg_line_height = np.mean(line_heights)

if (avg_line_height >= self.min_char_height * 0.8 and
len(line) >= 1):

if len(line) > 1:
spacings = []
for j in range(1, len(line)):
prev_right = line[j-1][0] + line[j-1][2]
curr_left = line[j][0]
spacings.append(curr_left - prev_right)
avg_spacing = np.mean(spacings) if spacings else 0

if avg_spacing <= avg_line_height * 3:
main_text_regions.extend(line)
else:
main_text_regions.extend(line)

print(f"识别出 {len(main_text_regions)} 个正文区域")
return main_text_regions

def manual_region_selection(self, image, existing_regions):
"""手动区域选择功能 - 增强版：支持添加和删除区域"""
print("\n=== 手动区域选择模式 ===")
print("操作说明:")
print("- 按住鼠标左键拖动来绘制矩形框")
print("- 按 's' 键保存当前框选")
print("- 按 'd' 键删除最后一个手动框选")
print("- 按 'r' 键删除选中的自动框选")
print("- 按 'c' 键清除所有手动框选")
print("- 按 'a' 键显示/隐藏自动检测区域")
print("- 按 'q' 键完成手动选择")
print("- 按 'h' 键显示帮助信息")

# 调整图像大小以便显示
height, width = image.shape[:2]
if width > 1200:
scale = 1200 / width
display_width = int(width * scale)
display_height = int(height * scale)
else:
display_width = width
display_height = height

temp_image = cv2.resize(image.copy(), (display_width, display_height))
scale_x = width / display_width
scale_y = height / display_height

manual_regions = [] # 存储手动添加的区域（原始坐标）
removed_regions = [] # 存储被删除的自动区域
current_region = None
drawing = False
ix, iy = -1, -1
show_auto_regions = True # 是否显示自动检测区域

def mouse_callback(event, x, y, flags, param):
nonlocal temp_image, current_region, drawing, ix, iy

if event == cv2.EVENT_LBUTTONDOWN:
drawing = True
ix, iy = x, y
current_region = [x, y, 0, 0]

elif event == cv2.EVENT_MOUSEMOVE:
if drawing:
temp_image = cv2.resize(image.copy(), (display_width, display_height))
self._draw_regions(temp_image, existing_regions, manual_regions, removed_regions,
scale_x, scale_y, show_auto_regions)

# 绘制当前正在框选的区域
cv2.rectangle(temp_image, (ix, iy), (x, y), (0, 255, 0), 2)

elif event == cv2.EVENT_LBUTTONUP:
drawing = False
current_region[2] = abs(x - ix)
current_region[3] = abs(y - iy)

if current_region[2] > 0 and current_region[3] > 0:
# 调整坐标，确保x,y是左上角
if x < ix:
current_region[0] = x
if y < iy:
current_region[1] = y

temp_image = cv2.resize(image.copy(), (display_width, display_height))
self._draw_regions(temp_image, existing_regions, manual_regions, removed_regions,
scale_x, scale_y, show_auto_regions)

# 绘制当前框选区域（绿色）
cv2.rectangle(temp_image,
(current_region[0], current_region[1]),
(current_region[0] + current_region[2], current_region[1] + current_region[3]),
(0, 255, 0), 2)

# 创建窗口并设置鼠标回调
window_name = "Manual Region Selection - Press 'h' for help"
cv2.namedWindow(window_name, cv2.WINDOW_NORMAL)
cv2.resizeWindow(window_name, display_width, display_height)
cv2.setMouseCallback(window_name, mouse_callback)

# 初始绘制
temp_image = cv2.resize(image.copy(), (display_width, display_height))
self._draw_regions(temp_image, existing_regions, manual_regions, removed_regions,
scale_x, scale_y, show_auto_regions)

print("手动选择窗口已打开，请查看...")

while True:
cv2.imshow(window_name, temp_image)
key = cv2.waitKey(1) & 0xFF

if key == ord('s') and current_region is not None: # 保存当前框选
# 转换回原始坐标
orig_x = int(current_region[0] * scale_x)
orig_y = int(current_region[1] * scale_y)
orig_w = int(current_region[2] * scale_x)
orig_h = int(current_region[3] * scale_y)

manual_regions.append((orig_x, orig_y, orig_w, orig_h))
print(f"添加手动区域 {len(manual_regions)}: 位置({orig_x}, {orig_y}), 尺寸({orig_w}x{orig_h})")
current_region = None

# 更新显示
temp_image = cv2.resize(image.copy(), (display_width, display_height))
self._draw_regions(temp_image, existing_regions, manual_regions, removed_regions,
scale_x, scale_y, show_auto_regions)

elif key == ord('d'): # 删除最后一个手动框选
if manual_regions:
removed = manual_regions.pop()
print(f"删除手动区域: 位置({removed[0]}, {removed[1]}), 尺寸({removed[2]}x{removed[3]})")
temp_image = cv2.resize(image.copy(), (display_width, display_height))
self._draw_regions(temp_image, existing_regions, manual_regions, removed_regions,
scale_x, scale_y, show_auto_regions)

elif key == ord('r'): # 删除选中的自动区域
if current_region is not None:
# 转换当前框选到原始坐标
orig_x = int(current_region[0] * scale_x)
orig_y = int(current_region[1] * scale_y)
orig_w = int(current_region[2] * scale_x)
orig_h = int(current_region[3] * scale_y)

# 找到与当前框选重叠的自动区域
for i, (rx, ry, rw, rh) in enumerate(existing_regions):
if (abs(rx - orig_x) < 20 and abs(ry - orig_y) < 20 and
abs(rw - orig_w) < 20 and abs(rh - orig_h) < 20):

if (rx, ry, rw, rh) not in removed_regions:
removed_regions.append((rx, ry, rw, rh))
print(f"标记删除自动区域 {i}: 位置({rx}, {ry}), 尺寸({rw}x{rh})")
break

current_region = None
temp_image = cv2.resize(image.copy(), (display_width, display_height))
self._draw_regions(temp_image, existing_regions, manual_regions, removed_regions,
scale_x, scale_y, show_auto_regions)

elif key == ord('c'): # 清除所有手动框选
manual_regions.clear()
print("清除所有手动框选")
temp_image = cv2.resize(image.copy(), (display_width, display_height))
self._draw_regions(temp_image, existing_regions, manual_regions, removed_regions,
scale_x, scale_y, show_auto_regions)

elif key == ord('a'): # 切换显示自动区域
show_auto_regions = not show_auto_regions
print(f"{'显示' if show_auto_regions else '隐藏'}自动检测区域")
temp_image = cv2.resize(image.copy(), (display_width, display_height))
self._draw_regions(temp_image, existing_regions, manual_regions, removed_regions,
scale_x, scale_y, show_auto_regions)

elif key == ord('h'): # 显示帮助
print("\n操作说明:")
print("- 按住鼠标左键拖动来绘制矩形框")
print("- 按 's' 键保存当前框选")
print("- 按 'd' 键删除最后一个手动框选")
print("- 按 'r' 键删除选中的自动框选")
print("- 按 'c' 键清除所有手动框选")
print("- 按 'a' 键显示/隐藏自动检测区域")
print("- 按 'q' 键完成手动选择")

elif key == ord('q'): # 退出
break

cv2.destroyWindow(window_name)
print(f"手动选择完成，添加了 {len(manual_regions)} 个手动区域，删除了 {len(removed_regions)} 个自动区域")
return manual_regions, removed_regions

def _draw_regions(self, image, existing_regions, manual_regions, removed_regions, scale_x, scale_y, show_auto=True):
"""绘制所有区域到图像上"""
# 绘制自动检测的区域（蓝色边框）
if show_auto:
for i, (rx, ry, rw, rh) in enumerate(existing_regions):
# 检查是否被标记删除
is_removed = any(
abs(rx - rx_rem) < 5 and abs(ry - ry_rem) < 5 and
abs(rw - rw_rem) < 5 and abs(rh - rh_rem) < 5
for rx_rem, ry_rem, rw_rem, rh_rem in removed_regions
)

if not is_removed:
# 缩放坐标到显示尺寸
rx_disp = int(rx / scale_x)
ry_disp = int(ry / scale_y)
rw_disp = int(rw / scale_x)
rh_disp = int(rh / scale_y)
cv2.rectangle(image, (rx_disp, ry_disp), (rx_disp + rw_disp, ry_disp + rh_disp), (255, 0, 0), 2)
cv2.putText(image, f'A{i}', (rx_disp, ry_disp-5), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 1)
else:
# 绘制被删除的区域（红色边框）
rx_disp = int(rx / scale_x)
ry_disp = int(ry / scale_y)
rw_disp = int(rw / scale_x)
rh_disp = int(rh / scale_y)
cv2.rectangle(image, (rx_disp, ry_disp), (rx_disp + rw_disp, ry_disp + rh_disp), (0, 0, 255), 2)
cv2.putText(image, f'X{i}', (rx_disp, ry_disp-5), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 1)

# 绘制手动添加的区域（黄色边框）
for i, (rx, ry, rw, rh) in enumerate(manual_regions):
rx_disp = int(rx / scale_x)
ry_disp = int(ry / scale_y)
rw_disp = int(rw / scale_x)
rh_disp = int(rh / scale_y)
cv2.rectangle(image, (rx_disp, ry_disp), (rx_disp + rw_disp, ry_disp + rh_disp), (0, 255, 255), 2)
cv2.putText(image, f'M{i}', (rx_disp, ry_disp-5), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 255), 1)

def segment_characters(self, image_path, output_dir="./output_chars", show_windows=False, enable_manual=False):
"""主函数：分割字符并保存 - 增强调试信息"""
os.makedirs(output_dir, exist_ok=True)

print("正在处理图像...")
try:
original_img, binary_img = self.preprocess_image(image_path)
except Exception as e:
print(f"图像处理错误: {e}")
return []

img_height, img_width = original_img.shape[:2]

print("检测文字区域...")
regions = self.detect_text_regions(binary_img)

# 输出区域统计信息
if regions:
widths = [w for _, _, w, _ in regions]
heights = [h for _, _, _, h in regions]
print(f"区域尺寸统计 - 宽度: min={min(widths)}, max={max(widths)}, avg={np.mean(widths):.1f}")
print(f"区域尺寸统计 - 高度: min={min(heights)}, max={max(heights)}, avg={np.mean(heights):.1f}")

# 合并重叠区域
merged_regions = self.merge_overlapping_regions(regions)

# 过滤出大字正文
main_text_regions = self.filter_main_text(merged_regions, img_height)

if not main_text_regions:
print("未检测到大字正文区域，使用所有检测区域")
main_text_regions = merged_regions

# 手动补框选和删除错误区域
manual_regions = []
removed_regions = []
if enable_manual:
use_manual = input("\n是否启用手动补框选和删除错误区域？(y/N): ").strip().lower()
if use_manual == 'y':
print("正在打开手动选择窗口...")
manual_regions, removed_regions = self.manual_region_selection(original_img, main_text_regions)
if manual_regions:
print(f"添加了 {len(manual_regions)} 个手动区域")
if removed_regions:
print(f"删除了 {len(removed_regions)} 个自动区域")

# 过滤掉被删除的区域
filtered_regions = []
for region in main_text_regions:
is_removed = any(
abs(region[0] - removed[0]) < 5 and abs(region[1] - removed[1]) < 5 and
abs(region[2] - removed[2]) < 5 and abs(region[3] - removed[3]) < 5
for removed in removed_regions
)
if not is_removed:
filtered_regions.append(region)

# 添加手动区域
final_regions = filtered_regions + manual_regions

# 调整选区大小
adjusted_regions = []
for region in final_regions:
adjusted_region = self.adjust_region_size(region, img_width, img_height)
adjusted_regions.append(adjusted_region)

print(f"最终得到 {len(adjusted_regions)} 个调整后的区域 (自动: {len(filtered_regions)}, 手动: {len(manual_regions)}, 删除: {len(removed_regions)})")

# 按从右到左的顺序排序
adjusted_regions.sort(key=lambda r: r[0], reverse=True)

# 保存单个字符图片
char_images = []
for i, (x, y, w, h) in enumerate(adjusted_regions):
# 确保在图像范围内
x_start = max(0, x)
y_start = max(0, y)
x_end = min(img_width, x + w)
y_end = min(img_height, y + h)

char_img = original_img[y_start:y_end, x_start:x_end]

# 检查图像是否有效
if char_img.size == 0:
print(f"跳过空图像区域: {i}")
continue

# 标记区域类型
is_manual = any(
abs(x - mx) < 5 and abs(y - my) < 5 and abs(w - mw) < 5 and abs(h - mh) < 5
for mx, my, mw, mh in manual_regions
)
region_type = "manual" if is_manual else "auto"
output_path = os.path.join(output_dir, f"char_{i:03d}_{region_type}.png")
cv2.imwrite(output_path, char_img)
char_images.append(output_path)

print(f"保存字符 {i:03d} ({region_type}): 位置({x}, {y}), 尺寸({w}x{h})")

# 创建可视化结果
self.create_visualization(original_img, regions, adjusted_regions, manual_regions, removed_regions, output_dir, show_windows)

print(f"处理完成！共分割出 {len(char_images)} 个字符")
return char_images

def create_visualization(self, original_img, all_regions, main_regions, manual_regions, removed_regions, output_dir, show_windows=False):
"""创建可视化结果"""
result_img = original_img.copy()

# 绘制所有检测到的区域（半透明红色）
for x, y, w, h in all_regions:
overlay = result_img.copy()
cv2.rectangle(overlay, (x, y), (x + w, y + h), (0, 0, 255), -1)
cv2.addWeighted(overlay, 0.3, result_img, 0.7, 0, result_img)
cv2.rectangle(result_img, (x, y), (x + w, y + h), (0, 0, 255), 1)

# 绘制最终区域
auto_count = 0
manual_count = 0
removed_count = len(removed_regions)

for x, y, w, h in main_regions:
is_manual = any(
abs(x - mx) < 5 and abs(y - my) < 5 and abs(w - mw) < 5 and abs(h - mh) < 5
for mx, my, mw, mh in manual_regions
)
if is_manual:
cv2.rectangle(result_img, (x, y), (x + w, y + h), (0, 255, 255), 3) # 黄色：手动添加
manual_count += 1
else:
cv2.rectangle(result_img, (x, y), (x + w, y + h), (0, 255, 0), 2) # 绿色：自动检测
auto_count += 1

# 绘制被删除的区域（红色边框）
for x, y, w, h in removed_regions:
cv2.rectangle(result_img, (x, y), (x + w, y + h), (0, 0, 255), 2)

# 添加图例
legend_y = 30
cv2.putText(result_img, "Red: Removed Regions", (10, legend_y), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2)
cv2.putText(result_img, "Green: Auto-detected", (10, legend_y + 30), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
cv2.putText(result_img, "Yellow: Manual Regions", (10, legend_y + 60), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 255), 2)
cv2.putText(result_img, f"Auto: {auto_count}, Manual: {manual_count}, Removed: {removed_count}",
(10, legend_y + 90), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)

vis_path = os.path.join(output_dir, "segmentation_result.jpg")
cv2.imwrite(vis_path, result_img)
print(f"可视化结果已保存: {vis_path}")

if show_windows:
height, width = result_img.shape[:2]
if width > 1200:
scale = 1200 / width
display_img = cv2.resize(result_img, (int(width * scale), int(height * scale)))
else:
display_img = result_img

cv2.imshow('Segmentation Result', display_img)
print("按任意键关闭窗口...")
cv2.waitKey(0)
cv2.destroyAllWindows()

# 其余函数保持不变（interactive_adjustment, batch_process_images, single_image_process, main）
def interactive_adjustment():
"""交互式参数调整"""
print("=== 古籍文字分割参数调整 ===")

min_char_width = int(input("最小字符宽度 (默认20): ") or 20)
max_char_width = int(input("最大字符宽度 (默认150): ") or 150)
min_char_height = int(input("最小字符高度 (默认25): ") or 25)
max_char_height = int(input("最大字符高度 (默认150): ") or 150)
width_expansion = float(input("宽度扩展比例 (默认0.05): ") or 0.05)
height_expansion = float(input("高度扩展比例 (默认0.1): ") or 0.1)
min_aspect_ratio = float(input("最小宽高比 (默认0.2): ") or 0.2)
max_aspect_ratio = float(input("最大宽高比 (默认4.0): ") or 4.0)

return AncientTextSegmentor(
min_char_width=min_char_width,
max_char_width=max_char_width,
min_char_height=min_char_height,
max_char_height=max_char_height,
width_expansion=width_expansion,
height_expansion=height_expansion,
min_aspect_ratio=min_aspect_ratio,
max_aspect_ratio=max_aspect_ratio
)

def batch_process_images():
"""批量处理文件夹中的所有图像"""
print("=== 批量处理模式 ===")

input_folder = input("请输入包含古籍图像的文件夹路径: ").strip().strip('"')

if not input_folder or not os.path.exists(input_folder):
print("文件夹不存在")
return

image_extensions = ['*.jpg', '*.jpeg', '*.png', '*.bmp', '*.tiff', '*.tif']
image_files = []

for extension in image_extensions:
image_files.extend(glob.glob(os.path.join(input_folder, extension)))
image_files.extend(glob.glob(os.path.join(input_folder, extension.upper())))

if not image_files:
print("在指定文件夹中未找到图像文件")
return

print(f"找到 {len(image_files)} 个图像文件")

print("\n选择参数模式:")
print("1. 自动模式 (使用优化参数)")
print("2. 手动调整参数")
mode = input("请选择 (1/2): ").strip()

if mode == "2":
segmentor = interactive_adjustment()
else:
segmentor = AncientTextSegmentor(
min_char_width=15,
max_char_width=180,
min_char_height=20,
max_char_height=180,
width_expansion=0,
height_expansion=0,
min_aspect_ratio=0.1,
max_aspect_ratio=5.0
)

show_windows = input("处理时是否显示可视化窗口？(y/N): ").strip().lower() == 'y'
enable_manual = input("是否启用手动补框选？(y/N): ").strip().lower() == 'y'

main_output_dir = os.path.join(input_folder, "batch_output")
os.makedirs(main_output_dir, exist_ok=True)

total_images = len(image_files)
processed_count = 0
success_count = 0

print(f"\n开始批量处理 {total_images} 个图像...")

for i, image_path in enumerate(image_files):
print(f"\n{'='*50}")
print(f"处理图像 {i+1}/{total_images}: {os.path.basename(image_path)}")
print(f"{'='*50}")

try:
image_name = os.path.splitext(os.path.basename(image_path))[0]
output_dir = os.path.join(main_output_dir, image_name)

char_images = segmentor.segment_characters(image_path, output_dir, show_windows=show_windows, enable_manual=enable_manual)

if char_images:
success_count += 1
print(f"✅ 成功处理: {os.path.basename(image_path)} - 分割出 {len(char_images)} 个字符")
else:
print(f"⚠️ 警告: {os.path.basename(image_path)} - 未分割出字符")

except Exception as e:
print(f"❌ 处理失败: {os.path.basename(image_path)} - 错误: {e}")

processed_count += 1

print(f"\n{'='*60}")
print("批量处理完成！")
print(f"{'='*60}")
print(f"总图像数: {total_images}")
print(f"成功处理: {success_count}")
print(f"失败数量: {processed_count - success_count}")
print(f"输出目录: {main_output_dir}")
print(f"{'='*60}")

def single_image_process():
"""单张图像处理模式"""
print("=== 单张图像处理模式 ===")

input_image = input("请输入古籍图像路径: ").strip().strip('"')

if not input_image or not os.path.exists(input_image):
print("文件不存在")
return

print("\n选择模式:")
print("1. 自动模式 (使用优化参数)")
print("2. 手动调整参数")
mode = input("请选择 (1/2): ").strip()

if mode == "2":
segmentor = interactive_adjustment()
else:
segmentor = AncientTextSegmentor(
min_char_width=15,
max_char_width=180,
min_char_height=20,
max_char_height=180,
width_expansion=0,
height_expansion=0,
min_aspect_ratio=0.1,
max_aspect_ratio=5.0
)

print(f"处理图像: {input_image}")

output_dir = "./output_chars"
char_images = segmentor.segment_characters(input_image, output_dir, show_windows=True, enable_manual=True)

if char_images:
print(f"\n✅ 处理完成！字符图片保存在: {output_dir}")
print(f"共生成 {len(char_images)} 个字符图片")
else:
print("\n❌ 处理失败")

def main():
"""主函数"""
print("=== 古籍文字分割工具 (增强版：手动补框选 + 删除错误区域) ===")

while True:
print("\n选择处理模式:")
print("1. 单张图像处理")
print("2. 批量处理文件夹")
print("3. 退出")

choice = input("请选择 (1/2/3): ").strip()

if choice == "1":
single_image_process()
elif choice == "2":
batch_process_images()
elif choice == "3":
print("再见！")
break
else:
print("无效选择，

@阿东 #197227

你让deepseek发国内安装镜像，opencv（切图）、paddle（识别）、potrace（转图），繁体识别可能还会用到opencc

@典中典 #197242

重新正确安装python

@雲灬甫 #197247

精品

@独自成俑 #197256

感谢推荐，我也发现umi的rapid版本比paddle版本正确率高，阅读paddle文档感觉是要用显卡的版本才行。

哈哈，cnocr也是基于paddle的，等用了看效果。