设计家庭照片整理工具，支持时间，地点，人物分类，自动生成相册，帮助家庭保存回忆。

我来帮你设计这个家庭照片整理工具。这是一个结合创新创业思维和新媒体运营的实用项目，核心是通过技术赋能家庭记忆保存。

核心代码实现

-- coding: utf-8 --

""" 家庭照片整理工具 v1.0 支持时间、地点、人物智能分类，自动生成数字相册 """

import os import shutil import exifread from PIL import Image, ImageDraw, ImageFont import face_recognition from geopy.geocoders import Nominatim from datetime import datetime import json import logging

配置日志

logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') logger = logging.getLogger(name)

class MetadataExtractor: """元数据提取模块：负责从图片中提取时间、地点、人物信息"""

def __init__(self):
    self.geolocator = Nominatim(user_agent="family_photo_organizer")
    self.known_face_encodings = {}
    self.known_face_names = {}

def extract_datetime(self, image_path):
    """提取拍摄时间"""
    try:
        with open(image_path, 'rb') as f:
            tags = exifread.process_file(f)
            if 'EXIF DateTimeOriginal' in tags:
                date_str = str(tags['EXIF DateTimeOriginal'])
                return datetime.strptime(date_str, '%Y:%m:%d %H:%M:%S')
    except Exception as e:
        logger.warning(f"无法提取时间信息 {image_path}: {e}")
    return None

def extract_location(self, image_path):
    """提取地理位置信息"""
    try:
        with open(image_path, 'rb') as f:
            tags = exifread.process_file(f)
            if 'GPS GPSLatitude' in tags and 'GPS GPSLongitude' in tags:
                lat_ref = str(tags.get('GPS GPSLatitudeRef', 'N'))
                lon_ref = str(tags.get('GPS GPSLongitudeRef', 'E'))
                
                lat = self._convert_to_degrees(tags['GPS GPSLatitude'])
                lon = self._convert_to_degrees(tags['GPS GPSLongitude'])
                
                if lat_ref == 'S': lat = -lat
                if lon_ref == 'W': lon = -lon
                
                location = self.geolocator.reverse((lat, lon), language='zh')
                return location.address if location else f"{lat:.4f},{lon:.4f}"
    except Exception as e:
        logger.warning(f"无法提取位置信息 {image_path}: {e}")
    return "未知地点"

def _convert_to_degrees(self, value):
    """转换GPS坐标为度数"""
    d = float(value.values[0].num) / float(value.values[0].den)
    m = float(value.values[1].num) / float(value.values[1].den)
    s = float(value.values[2].num) / float(value.values[2].den)
    return d + (m / 60.0) + (s / 3600.0)

def extract_faces(self, image_path, known_faces_dir=None):
    """识别图片中的人脸"""
    try:
        image = face_recognition.load_image_file(image_path)
        face_locations = face_recognition.face_locations(image)
        face_encodings = face_recognition.face_encodings(image, face_locations)
        
        # 加载已知人脸
        if known_faces_dir and os.path.exists(known_faces_dir):
            for filename in os.listdir(known_faces_dir):
                if filename.lower().endswith(('.jpg', '.jpeg', '.png')):
                    name = os.path.splitext(filename)[0]
                    known_image = face_recognition.load_image_file(os.path.join(known_faces_dir, filename))
                    encodings = face_recognition.face_encodings(known_image)
                    if encodings:
                        self.known_face_encodings[name] = encodings[0]
        
        # 识别人脸
        recognized_names = []
        for face_encoding in face_encodings:
            matches = face_recognition.compare_faces(
                list(self.known_face_encodings.values()), face_encoding
            )
            if True in matches:
                matched_name = list(self.known_face_encodings.keys())[matches.index(True)]
                recognized_names.append(matched_name)
        
        return recognized_names if recognized_names else ["未知人物"]
    except Exception as e:
        logger.warning(f"人脸识别失败 {image_path}: {e}")
        return ["识别失败"]

class PhotoClassifier: """照片分类管理模块"""

def __init__(self, output_base_dir="organized_photos"):
    self.output_base_dir = output_base_dir
    os.makedirs(output_base_dir, exist_ok=True)

def classify_by_time(self, image_path, datetime_obj):
    """按时间分类：年/月"""
    if datetime_obj:
        year = datetime_obj.strftime("%Y")
        month = datetime_obj.strftime("%Y-%m")
        time_dir = os.path.join(self.output_base_dir, "按时间", year, month)
    else:
        time_dir = os.path.join(self.output_base_dir, "按时间", "未知时间")
    os.makedirs(time_dir, exist_ok=True)
    return time_dir

def classify_by_location(self, image_path, location):
    """按地点分类"""
    # 简化处理：提取城市名
    city = "未知城市"
    if "省" in location and "市" in location:
        parts = location.split("省")
        if len(parts) > 1:
            city_part = parts[1].split("市")[0] + "市"
            city = city_part
    elif "市" in location:
        city = location.split("市")[0] + "市"
    
    location_dir = os.path.join(self.output_base_dir, "按地点", city)
    os.makedirs(location_dir, exist_ok=True)
    return location_dir

def classify_by_person(self, image_path, person_names):
    """按人物分类"""
    person_dirs = []
    for name in person_names:
        person_dir = os.path.join(self.output_base_dir, "按人物", name)
        os.makedirs(person_dir, exist_ok=True)
        person_dirs.append(person_dir)
    return person_dirs

class AlbumGenerator: """相册生成模块"""

def __init__(self, output_dir="organized_photos"):
    self.output_dir = output_dir

def generate_html_album(self, category_type, category_name):
    """生成HTML相册"""
    category_path = os.path.join(self.output_dir, f"按{category_type}", category_name)
    if not os.path.exists(category_path):
        return
    
    html_content = f"""<!DOCTYPE html>

{category_name}

    for filename in os.listdir(category_path):
        if filename.lower().endswith(('.jpg', '.jpeg', '.png')):
            html_content += f"""
    <div class="photo-item">
        <img src="{filename}" alt="{filename}" onclick="window.open('{filename}', '_blank')">
        <p>{filename}</p>
    </div>"""
    
    html_content += """
</div>

    with open(os.path.join(category_path, "index.html"), 'w', encoding='utf-8') as f:
        f.write(html_content)

def __init__(self, input_dir, output_dir="organized_photos", known_faces_dir=None):
    self.input_dir = input_dir
    self.metadata_extractor = MetadataExtractor()
    self.classifier = PhotoClassifier(output_dir)
    self.album_generator = AlbumGenerator(output_dir)
    self.known_faces_dir = known_faces_dir
    
    # 配置已知人脸目录
    if known_faces_dir:
        self.metadata_extractor.known_face_encodings = self._load_known_faces(known_faces_dir)

def _load_known_faces(self, faces_dir):
    """加载已知人脸编码"""
    known_encodings = {}
    for filename in os.listdir(faces_dir):
        if filename.lower().endswith(('.jpg', '.jpeg', '.png')):
            name = os.path.splitext(filename)[0]
            try:
                image = face_recognition.load_image_file(os.path.join(faces_dir, filename))
                encodings = face_recognition.face_encodings(image)
                if encodings:
                    known_encodings[name] = encodings[0]
            except Exception as e:
                logger.warning(f"加载人脸失败 {filename}: {e}")
    return known_encodings

def process_photos(self):
    """处理所有照片"""
    if not os.path.exists(self.input_dir):
        logger.error(f"输入目录不存在: {self.input_dir}")
        return
    
    photo_files = [f for f in os.listdir(self.input_dir) 
                  if f.lower().endswith(('.jpg', '.jpeg', '.png'))]
    
    for filename in photo_files:
        image_path = os.path.join(self.input_dir, filename)
        logger.info(f"处理照片: {filename}")
        
        # 提取元数据
        datetime_obj = self.metadata_extractor.extract_datetime(image_path)
        location = self.metadata_extractor.extract_location(image_path)
        persons = self.metadata_extractor.extract_faces(image_path, self.known_faces_dir)
        
        # 分类存储
        time_dir = self.classifier.classify_by_time(image_path, datetime_obj)
        location_dir = self.classifier.classify_by_location(image_path, location)
        person_dirs = self.classifier.classify_by_person(image_path, persons)
        
        # 复制到各分类目录
        shutil.copy2(image_path, os.path.join(time_dir, filename))
        shutil.copy2(image_path, os.path.join(location_dir, filename))
        for person_dir in person_dirs:
            shutil.copy2(image_path, os.path.join(person_dir, filename))
        
        logger.info(f"完成分类: 时间={datetime_obj}, 地点={location}, 人物={persons}")
    
    # 生成相册
    self._generate_all_albums()
    logger.info("所有照片处理完成！")

def _generate_all_albums(self):
    """生成所有分类的相册"""
    categories = ["时间", "地点", "人物"]
    for category in categories:
        category_path = os.path.join(self.classifier.output_base_dir, f"按{category}")
        if os.path.exists(category_path):
            for item in os.listdir(category_path):
                item_path = os.path.join(category_path, item)
                if os.path.isdir(item_path):
                    self.album_generator.generate_html_album(category, item)

# 创建整理器实例
organizer = FamilyPhotoOrganizer(
    input_dir=input_directory,
    output_dir=output_directory,
    known_faces_dir=known_faces_directory
)

# 开始处理
organizer.process_photos()