Python 30个自动化办公图像处理的方法

from PIL import Image
img = Image.open('example.jpg')
img.show()  # Pillow方式

import cv2
image = cv2.imread('example.jpg')
cv2.imshow('Image', image)  # OpenCV方式
cv2.waitKey(0)
cv2.destroyAllWindows()

width, height = img.size  # Pillowp
rint(width, height)
h, w = image.shape[:2]    # OpenCV
print(h,w)

cropped = img.crop((50, 50, 200, 200))  # Pillow
cropped.show()

cropped = image[50:200, 50:200]         # OpenCV
cv2.imshow('Cropped Image', cropped)
cv2.waitKey(0)
cv2.destroyAllWindows()

resized = img.resize((400, 400))  # Pillow
resized.show()

resized = cv2.resize(image, (400, 400))  # OpenCV
cv2.imshow('Resized Image',resized)
cv2.waitKey(0)
cv2.destroyAllWindows()

rotated = img.rotate(90)  # Pillow
rotated.show()

rotated = cv2.rotate(image, cv2.ROTATE_90_CLOCKWISE)  # OpenCV
cv2.imshow('Rotated Image', rotated)
cv2.waitKey(0)
cv2.destroyAllWindows()

flipped = img.transpose(Image.FLIP_LEFT_RIGHT)  # Pillow水平翻转
flipped.show()

flipped = cv2.flip(image, 1)
cv2.imshow('flipped Image', flipped)
cv2.waitKey(0)
cv2.destroyAllWindows()                   # OpenCV水平翻转

gray_img = img.convert('L')                     # Pillow灰度图
gray_img.show()

gray_img = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)  # OpenCV灰度图
cv2.imshow('gray Image', gray_img)
cv2.waitKey(0)
cv2.destroyAllWindows()

brightened = cv2.convertScaleAbs(image, alpha=1.0, beta=50) # 增加亮度（beta 控制亮度）contrasted = cv2.convertScaleAbs(image, alpha=1.5, beta=0)  # 增加对比度（alpha 控制对比度）
# 显示结果
cv2.imshow('Original', image)
cv2.imshow('Brightened', brightened)
cv2.imshow('Contrasted', contrasted)
cv2.waitKey(0)cv2.destroyAllWindows()

blurred = cv2.GaussianBlur(image, (5, 5), 0)  # OpenCV
cv2.imshow('Blurred Image', blurred)
cv2.waitKey(0)
cv2.destroyAllWindows()

edges = cv2.Canny(image, 100, 200)  # OpenCV
cv2.imshow('Edged Image', edges)
cv2.waitKey(0)
cv2.destroyAllWindows()

inverted = 255 - image
blurred = cv2.GaussianBlur(inverted, (19, 19), 0)
cv2.imshow('Blurred Image', blurred)
sketch = cv2.divide(image, 255 - blurred, scale=256.0)
cv2.imshow('sketched Image', sketch)
cv2.waitKey(0)
cv2.destroyAllWindows()

_, binary = cv2.threshold(image, 127, 255, cv2.THRESH_BINARY) 
cv2.imshow('Binary Image', binary)
cv2.waitKey(0)
cv2.destroyAllWindows()

contours, _ = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)cv2.drawContours(image, contours, -1, (0, 255, 0), 2)
cv2.imshow('Contours', image)
cv2.waitKey(0)
cv2.destroyAllWindows()

face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
faces = face_cascade.detectMultiScale(image, 1.1, 4)
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=4)

for (x, y, w, h) in faces:    
cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2)

cv2.imshow('Face Detection', image)
cv2.waitKey(0)
cv2.destroyAllWindows()

x, y, w, h = 100, 100, 200, 200  # 示例坐标，请根据实际情况修改
# 创建KCF跟踪器
tracker = cv2.TrackerKCF_create()
# 初始化跟踪器
ok = tracker.init(image, (x, y, w, h))

import cv2
# 打开视频文件或摄像头
cap = cv2.VideoCapture('video.mp4')  # 或者使用 0 表示摄像头
# 创建 MOG2 背景减除器
fgbg = cv2.createBackgroundSubtractorMOG2()
while True:    
ret, frame = cap.read()    
if not ret:        
break
    # 应用背景减除，获取前景掩码    
    fgmask = fgbg.apply(frame)
    # 显示原始帧和前景掩码    
    cv2.imshow('Original Frame', frame)    
    cv2.imshow('Foreground Mask', fgmask)
    # 按 'q' 键退出    
    if cv2.waitKey(30) & 0xFF == ord('q'):        
    break
    
cap.release()
cv2.destroyAllWindows()

# 打开两张图像
img1 = Image.open('image1.jpg')
img2 = Image.open('image2.jpg')
# 确保两张图像高度一致（可选）
img2 = img2.resize((img2.width, img1.height))
# 创建新图像，宽度为两张图宽度之和，高度为图像高度
new_img = Image.new('RGB', (img1.width + img2.width, img1.height))
# 将两张图像粘贴到新图像上
new_img.paste(img1, (0, 0))
new_img.paste(img2, (img1.width, 0))
# 显示或保存结果
new_img.show()
new_img.save('concatenated.jpg')

# 打开图像
img = Image.open('your_image.jpg').convert("RGBA")
# 创建一个可绘制的图像对象
draw = ImageDraw.Draw(img)
# 设置字体（可选，推荐指定字体文件以获得更好效果）
font = ImageFont.truetype("arial.ttf", 36)  # 字体路径和大小
# 添加文字水印
draw.text((10, 10), "Nicholas与Pypi", fill=(255, 0, 0), font=font)
# 显示或保存图像
img.show()
img.save('watermarked_image.png')

# 确保输出目录存在
os.makedirs('output', exist_ok=True)
# 遍历 images 文件夹中的所有文件
for filename in os.listdir('images/'):    # 拼接完整路径    
input_path = os.path.join('images', filename)        # 检查是否是图片文件（可选）    
if not filename.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.gif')):        continue
    # 打开图像    
    with Image.open(input_path) as img:        
    # 调整尺寸为 300x300（注意：可能会变形）        
    resized_img = img.resize((300, 300))
        # 保存到 output 文件夹        
        output_path = os.path.join('output', filename)        
        resized_img.save(output_path)
        
print("批量调整完成！")

# 加载风格迁移模型（TensorFlow Hub）
hub_model = hub.load('https://tfhub.dev/google/magenta/arbitrary-image-stylization-v1-256/2')
# 加载并预处理图像
def load_image(image_path, max_dim=512):    
img = tf.io.read_file(image_path)    
img = tf.image.decode_image(img, channels=3)    
img = tf.image.convert_image_dtype(img, tf.float32)    
img = tf.image.resize(img, (max_dim, max_dim), preserve_aspect_ratio=True)    
img = img[tf.newaxis, :]  # 添加 batch 维度    
return img

# 加载内容图和风格图
content_img = load_image('content.jpg')
style_img = load_image('style.jpg')

# 执行风格迁移
stylized = hub_model(tf.constant(content_img), tf.constant(style_img))[0]
# 显示结果
def tensor_to_image(tensor):    
tensor = tensor * 255    
tensor = np.array(tensor, dtype=np.uint8)    
if np.ndim(tensor) > 3:        
tensor = tensor[0]    
return Image.fromarray(tensor)

result_image = tensor_to_image(stylized)
result_image.show()
result_image.save('stylized_output.jpg')

import osfrom PIL import Image
input_folder = 'input_images'
output_folder = 'processed_images'
# 创建输出文件夹
os.makedirs(output_folder, exist_ok=True)
# 遍历输入文件夹中的所有图像
for filename in os.listdir(input_folder):    
if filename.lower().endswith(('.png', '.jpg', '.jpeg')):        
# 打开图像        
img_path = os.path.join(input_folder, filename)        
image = Image.open(img_path)                
# 应用处理：这里以缩略图生成为例        
image.thumbnail((200, 200))                
# 保存处理后的图像        
output_path = os.path.join(output_folder, filename)        
image.save(output_path)                

print(f"已处理: {filename}")

def add_watermark(image_path, watermark_text, output_path, position="bottom-right", opacity=128):
    # 打开图像
    im = Image.open(image_path).convert("RGBA")
    # 创建一个透明层
    txt_layer = Image.new("RGBA", im.size, (255, 255, 255, 0))
    draw = ImageDraw.Draw(txt_layer)
    # 尝试加载字体，失败则使用默认字体
    try:
        font = ImageFont.truetype("arial.ttf", 40)
    except IOError:
        font = ImageFont.load_default()
    # 获取文本尺寸
    bbox = draw.textbbox((0, 0), watermark_text, font=font)
    text_width = bbox[2] - bbox[0]
    text_height = bbox[3] - bbox[1]
    # 根据位置计算坐标
    if position == "bottom-right":
        x = im.width - text_width - 10
        y = im.height - text_height - 10
    elif position == "top-left":
        x, y = 10, 10
    elif position == "center":
        x = (im.width - text_width) // 2
        y = (im.height - text_height) // 2
    else:
        x, y = 10, 10  # 默认左上角
    # 添加半透明水印
    draw.text((x, y), watermark_text, font=font, fill=(255, 255, 255, opacity))
    # 合并图层
    watermarked = Image.alpha_composite(im, txt_layer)
    # 转换为 RGB 并保存
    watermarked.convert("RGB").save(output_path)

# 批量添加水印
input_folder = "./assets"
output_folder = "./output"
os.makedirs(output_folder, exist_ok=True)

images = ["image1.jpg", "image2.jpg", "image3.jpg"]

for i, filename in enumerate(images):
    input_path = os.path.join(input_folder, filename)
    output_path = os.path.join(output_folder, f"watermarked_{i}.jpg")
    add_watermark(input_path, "Nicholas与Pypi", output_path, position="bottom-right")

from PIL import Image, ImageFilter

def apply_filter(image_path, output_path, filter_type):
    # 打开图像
    im = Image.open(image_path)
    
    # 应用滤镜
    if filter_type == "blur":
        filtered = im.filter(ImageFilter.BLUR)
    elif filter_type == "emboss":
        filtered = im.filter(ImageFilter.EMBOSS)
    elif filter_type == "contour":
        filtered = im.filter(ImageFilter.CONTOUR)
    else:
        filtered = im
    
    # 保存图像
    filtered.save(output_path)

# 应用不同滤镜
apply_filter("./assets/photo.jpg", "blurred.jpg", "blur")
apply_filter("./assets/photo.jpg", "embossed.jpg", "emboss")
apply_filter("./assets/photo.jpg", "contoured.jpg", "contour")

from PIL import Image

def concatenate_images(image_paths, output_path, direction='horizontal'):
    # 打开所有图像
    images = [Image.open(path) for path in image_paths]
    
    # 确定新图像的尺寸
    if direction == 'horizontal':
        total_width = sum(img.width for img in images)
        max_height = max(img.height for img in images)
        new_img = Image.new('RGB', (total_width, max_height))       
        # 粘贴图像
        x_offset = 0
        for img in images:
            new_img.paste(img, (x_offset, 0))
            x_offset += img.width
    else:  # 垂直拼接
        total_height = sum(img.height for img in images)
        max_width = max(img.width for img in images)
        new_img = Image.new('RGB', (max_width, total_height))       
        # 粘贴图像
        y_offset = 0
        for img in images:
            new_img.paste(img, (0, y_offset))
            y_offset += img.height  
    # 保存结果
    new_img.save(output_path)

image_paths = ["./assets/image1.jpg", "./assets/image2.jpg"]
concatenate_images(image_paths, "combined.jpg", direction='horizontal')

import numpy as np
from PIL import Image, ImageEnhance
import random

def augment_image(image_path, output_prefix):
    # 打开图像
    img = Image.open(image_path)    
    # 随机旋转
    rotated = img.rotate(random.randint(-15, 15))
    rotated.save(f"{output_prefix}_rotated.jpg")    
    # 随机亮度调整
    enhancer = ImageEnhance.Brightness(img)
    brightened = enhancer.enhance(random.uniform(0.7, 1.3))
    brightened.save(f"{output_prefix}_brightened.jpg")    
    # 随机对比度调整
    enhancer = ImageEnhance.Contrast(img)
    contrasted = enhancer.enhance(random.uniform(0.7, 1.3))
    contrasted.save(f"{output_prefix}_contrasted.jpg")  
    # 随机颜色调整
    enhancer = ImageEnhance.Color(img)
    colored = enhancer.enhance(random.uniform(0.7, 1.3))
    colored.save(f"{output_prefix}_colored.jpg")
    
augment_image("./assets/training.jpg", "augmented")

from PIL import Image, ImageDraw, ImageFont
import os
import random
import qrcode
import pandas as pd

# 1. 创建名片模板
def create_card_template(width=900, height=500):
    bg_color = (random.randint(200, 255),
                random.randint(200, 255),
                random.randint(200, 255))
    card = Image.new('RGB', (width, height), color=bg_color)
    return card

# 2. 添加文本信息
def add_text(card, name, title, phone, email, font_path="arial.ttf"):
    draw = ImageDraw.Draw(card)
    try:
        name_font = ImageFont.truetype(font_path, 60)
        title_font = ImageFont.truetype(font_path, 40)
        contact_font = ImageFont.truetype(font_path, 30)
    except IOError:
        name_font = title_font = contact_font = ImageFont.load_default()


    draw.text((100, 100), name, fill='black', font=name_font)
    draw.text((100, 180), title, fill='gray', font=title_font)
    draw.text((100, 250), f"电话: {phone}", fill='gray', font=contact_font)
    draw.text((100, 300), f"邮箱: {email}", fill='gray', font=contact_font)
    draw.line((80, 220, 820, 220), fill='lightblue', width=3)

# 3. 添加 Logo 和照片（支持圆形照片）
def add_images(card, logo_path=None, photo_path=None):
    if logo_path and os.path.exists(logo_path):
        logo = Image.open(logo_path).convert("RGBA")
        logo = logo.resize((100, 100))
        card.paste(logo, (card.width - 150, 50), logo)

    if photo_path and os.path.exists(photo_path):
        photo = Image.open(photo_path).convert("RGBA")
        photo = photo.resize((150, 150))

        # 创建圆形蒙版
        mask = Image.new('L', (150, 150), 0)
        draw = ImageDraw.Draw(mask)
        draw.ellipse((0, 0, 150, 150), fill=255)

        card.paste(photo, (card.width - 180, 150), mask)

# 4. 添加二维码
def add_qr_code(card, url, position=(750, 320)):
    qr = qrcode.QRCode(version=1, box_size=4, border=2)
    qr.add_data(url)
    qr.make(fit=True)
    qr_img = qr.make_image(fill_color="black", back_color="white")
    qr_img = qr_img.resize((100, 100))
    card.paste(qr_img, position)

# 5. 从 Excel 导入人员信息
def load_people_info_from_excel(excel_path):
    df = pd.read_excel(excel_path)
    return df.to_dict('records')

# 6. 批量生成名片
def generate_business_cards(people_info, output_folder):
    os.makedirs(output_folder, exist_ok=True)
    for person in people_info:
        card = create_card_template()
        add_text(card, person['name'], person['title'], person['phone'], person['email'])
        add_images(card, person.get('logo'), person.get('photo'))
        if 'qr_url' in person:
            add_qr_code(card, person['qr_url'])
        output_path = os.path.join(output_folder, f"{person['name']}_card.png")
        card.save(output_path)
        print(f"已生成: {output_path}")


if __name__ == "__main__":
    # 从 Excel 文件加载数据（可选）
    people = load_people_info_from_excel('people_info.xlsx')
    # 生成名片
    generate_business_cards(people, 'output_cards')

import cv2

def detect_faces(image_path, output_path):
    # 加载图像
    image = cv2.imread(image_path)   
    # 转换为灰度图（人脸检测通常在灰度图上进行）
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)   
    # 加载预训练的人脸检测器
    face_cascade = cv2.CascadeClassifier(
        cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')  
    # 检测人脸
    faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5)    
    # 在检测到的人脸周围绘制矩形
    for (x, y, w, h) in faces:
        cv2.rectangle(image, (x, y), (x+w, y+h), (255, 0, 0), 2)    
    # 保存结果
    cv2.imwrite(output_path, image)
    print(f"检测到 {len(faces)} 张人脸，结果已保存到 {output_path}")

detect_faces('group_photo.jpg', 'detected_faces.jpg')

import cv2

def realtime_face_detection(window_title='Real-time Face Detection',
                            scale_factor=1.3,
                            min_neighbors=5,
                            rectangle_color=(255, 0, 0),
                            rectangle_thickness=2):
    """
    实时人脸检测函数。

    参数:
        window_title (str): 窗口标题。
        scale_factor (float): 图像缩放比例，默认 1.3。
        min_neighbors (int): 最小邻居数，默认 5。
        rectangle_color (tuple): 矩形框颜色 (B, G, R)。
        rectangle_thickness (int): 矩形框线宽。
    """
    # 打开摄像头
    cap = cv2.VideoCapture(0)
    if not cap.isOpened():
        print("错误：无法打开摄像头。")
        return

    # 加载人脸检测器
    face_cascade = cv2.CascadeClassifier(
        cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
    if face_cascade.empty():
        print("错误：无法加载人脸检测器 XML 文件。")
        cap.release()
        return
    print("按 'q' 键退出实时检测。")

    while True:
        # 读取视频帧
        ret, frame = cap.read()
        if not ret:
            print("警告：无法读取视频帧。")
            break
        # 转换为灰度图
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        # 检测人脸
        faces = face_cascade.detectMultiScale(gray, scale_factor, min_neighbors)
        # 绘制矩形框
        for (x, y, w, h) in faces:
            cv2.rectangle(frame, (x, y), (x + w, y + h),
                          rectangle_color, rectangle_thickness)
        # 添加退出提示文字
        cv2.putText(frame, "Press 'q' to quit", (10, 30),
                    cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
        # 显示结果
        cv2.imshow(window_title, frame)
        # 按 'q' 退出
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

    # 释放资源
    cap.release()
    cv2.destroyAllWindows()
    print("实时检测已结束。")

if __name__ == "__main__":
    realtime_face_detection(scale_factor=1.2, min_neighbors=5

import tensorflow as tf
from tensorflow.keras.models import load_model
from tensorflow.keras.preprocessing import image
from tensorflow.keras.applications.imagenet_utils import preprocess_input

def load_deep_face_model(model_path):
    """加载预训练的深度学习人脸识别模型"""
    model = load_model(model_path)
    return model

def recognize_face_deep(model, image_path, known_embeddings):
    """使用深度学习模型识别人脸"""
    # 加载和预处理图像
    img = image.load_img(image_path, target_size=(160, 160))
    img_array = image.img_to_array(img)
    img_array = np.expand_dims(img_array, axis=0)
    img_array = preprocess_input(img_array)    
    # 获取嵌入向量
    embedding = model.predict(img_array)[0]   
    # 计算与已知人脸的相似度
    distances = {}
    for name, known_embed in known_embeddings.items():
        dist = np.linalg.norm(embedding - known_embed)
        distances[name] = dist    
    # 返回最相似的人脸
    recognized_name = min(distances.items(), key=lambda x: x[0]
    return recognized_name, distances[recognized_name]
    
model = load_deep_face_model('facenet.h5')
known_embeddings = {'Alice': np.array([...]), 'Bob': np.array([...])}
name, confidence = recognize_face_deep(model, 'unknown.jpg', known_embeddings)
print(f"识别结果: {name}, 置信度: {confidence:.2f}")

import os
import cv2
import numpy as np
import pandas as pd
import datetime
from deepface import DeepFace

class AttendanceSystem:
    def __init__(self, model_name='Facenet', db_path='employee_db'):
        self.model_name = model_name
        self.db_path = db_path  # 员工照片库路径
        self.attendance_records = []

    def recognize_and_record(self, image_path, threshold=0.4):
        """识别人脸并记录考勤"""
        try:
            result = DeepFace.find(
                img_path=image_path,
                db_path=self.db_path,
                model_name=self.model_name,
                enforce_detection=False
            )

            if result and len(result[0]) > 0:
                matched = result[0].iloc[0]
                name = os.path.basename(os.path.dirname(matched['identity']))
                distance = matched['distance']
                if distance < threshold:
                    timestamp = datetime.datetime.now()
                    self.attendance_records.append({
                        'name': name,
                        'time': timestamp,
                        'confidence': 1 - distance  # 转换为置信度
                    })
                    print(f"{timestamp}: {name} 签到成功")
                else:
                    print("未识别到有效员工")
            else:
                print("未识别到任何人脸")
        except Exception as e:
            print(f"识别失败：{e}")

    def generate_attendance_report(self, output_path='attendance.csv'):
        """生成考勤报表"""
        if not self.attendance_records:
            print("没有考勤记录。")
            return

        df = pd.DataFrame(self.attendance_records)
        df.to_csv(output_path, index=False)
        print(f"考勤报表已生成: {output_path}")

if __name__ == "__main__":
    # 初始化系统
    attendance_sys = AttendanceSystem(model_name='Facenet', db_path='employee_db')

    # 模拟员工照片库结构如下：
    # employee_db/
    # ├── Alice/
    # │   └── alice.jpg
    # ├── Bob/
    # │   └── bob.jpg
    # └── Charlie/
    #     └── charlie.jpg

    # 识别并记录考勤
    attendance_sys.recognize_and_record('employee1.jpg')
    attendance_sys.recognize_and_record('employee2.jpg')

    # 生成报表
    attendance_sys.generate_attendance_report('attendance.csv')