【実践事例】画像の一部に着目して分類する『OpenCV＋OCR』（コピペで使えるサンプルコード付き）

import os
import random
from datasets import load_dataset
from PIL import Image, ImageDraw, ImageFont

# ★★★★　出力ディレクトリの作成　★★★★
output_dir = "p:/annotated_factorio_images_random"
os.makedirs(output_dir, exist_ok=True)

# データセットのロード
ds = load_dataset("piebro/factorio-blueprint-visualizations")
train_ds = ds['train']

# 埋め込む文字列のリスト
texts = ["■分類１■", "★分類２★", "●分類３●", "▲分類４▲", "▼分類５▼"]

# 基本パラメータ
base_rect_position = (50, 50, 300, 150) # 四角形の左上の座標、右下の座標
base_rect_outline_color = 128           # 四角形の枠線の色（グレースケール値）
base_rect_line_width = 5                # 四角形の枠線の太さ
base_font_size = 40                     # 四角形の中に書くテキストのフォントサイズ
font = ImageFont.truetype("C:/WINDOWS/Fonts/MEIRYOB.TTC", base_font_size) # 使用するフォントとサイズ
text_color = "black"                    # テキストの色（黒）
bg_color = "white"                      # テキスト背景の色（白）
base_text_position_offset = (10, 10)    # テキストを描画する際の、四角形の左上からのオフセット（X方向、Y方向）

# ランダム変動の範囲 (調整可能)
rect_x_offset_range = (-20, 20)         # 四角形のX座標のランダムなオフセット範囲（最小値、最大値）
rect_y_offset_range = (-20, 20)         # 四角形のY座標のランダムなオフセット範囲（最小値、最大値）
rect_width_scale_range = (0.8, 1.2)     # 四角形の幅のランダムなスケール範囲（最小倍率、最大倍率）
rect_height_scale_range = (0.8, 1.2)    # 四角形の高さのランダムなスケール範囲（最小倍率、最大倍率）
rect_angle_range = (-10, 10)            # 四角形のランダムな回転角度の範囲（最小角度、最大角度）
text_x_offset_range = (-10, 10)         # テキストのX座標のランダムなオフセット範囲（最小値、最大値）
text_y_offset_range = (-10, 10)         # テキストのY座標のランダムなオフセット範囲（最小値、最大値）
overall_angle_range = (-5, 5)           # 全体的な画像のランダムな回転角度の範囲（最小角度、最大角度）

for i, example in enumerate(train_ds):
    image = example['image'].copy()
    draw = ImageDraw.Draw(image)
    img_width, img_height = image.size

    # ランダムな変動値を生成
    rect_x_offset = random.randint(*rect_x_offset_range)
    rect_y_offset = random.randint(*rect_y_offset_range)
    rect_width_scale = random.uniform(*rect_width_scale_range)
    rect_height_scale = random.uniform(*rect_height_scale_range)
    rect_angle = random.uniform(*rect_angle_range)
    text_x_offset = random.randint(*text_x_offset_range)
    text_y_offset = random.randint(*text_y_offset_range)
    overall_angle = random.uniform(*overall_angle_range)

    # ランダムな位置とサイズで長方形を描画
    rect_left = base_rect_position[0] + rect_x_offset
    rect_top = base_rect_position[1] + rect_y_offset
    rect_right = base_rect_position[2] * rect_width_scale + rect_x_offset
    rect_bottom = base_rect_position[3] * rect_height_scale + rect_y_offset
    current_rect_position = (rect_left, rect_top, rect_right, rect_bottom)

    # 長方形を描画（回転前に描画）
    draw.rectangle(current_rect_position, fill=bg_color, outline=base_rect_outline_color, width=base_rect_line_width)

    # 埋め込む文字列を決定
    text_to_embed = texts[i % len(texts)]

    # テキストの位置をランダムに計算
    text_x = int(rect_left + base_text_position_offset[0] + text_x_offset)
    text_y = int(rect_top + base_text_position_offset[1] + text_y_offset)

    # テキストを描画（回転前に描画）
    draw.text((text_x, text_y), text_to_embed, fill=text_color, font=font)

    # 画像全体をランダムな角度で回転
    rotated_image = image.rotate(overall_angle, resample=Image.Resampling.BILINEAR, fillcolor=bg_color)

    # 保存ファイル名の作成
    output_filename = f"annotated_blueprint_random_{i}.png"
    output_path = os.path.join(output_dir, output_filename)
    rotated_image.save(output_path)

print(f"ランダムな注釈付き画像を {output_dir} に保存しました。")

import os
import cv2
from PIL import Image
import numpy as np

class ImageProcessor:
    @staticmethod
    def crop_image(img, crop_area):
        """
        PIL Image オブジェクトを指定した範囲でクリッピングします。
        """
        try:
            cropped_img = img.crop(crop_area)
            return cropped_img
        except Exception as e:
            print(f"画像のクリッピングでエラーが発生しました: {e}")
            return None
        
    @staticmethod
    def extract_first_rectangle_gray(pil_img, target_color=(0, 0, 0), color_tolerance=30):  # target_color は BGR
        """
        指定した色に近い領域から最初の検出された四角形の領域を切り出します。
        """
        try:
            cv_img_bgr = np.array(pil_img.convert('RGB'))[:, :, ::-1].copy() # PIL RGB -> OpenCV BGR

            lower_bound = np.array([max(0, c - color_tolerance) for c in target_color])
            upper_bound = np.array([min(255, c + color_tolerance) for c in target_color])

            mask = cv2.inRange(cv_img_bgr, lower_bound, upper_bound)
            gray = mask  # マスクをグレースケール画像として扱う

            contours, _ = cv2.findContours(gray.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

            if contours:
                largest_contour = max(contours, key=cv2.contourArea)
                approx = cv2.approxPolyDP(largest_contour, 0.02 * cv2.arcLength(largest_contour, True), True)

                if len(approx) == 4:
                    x, y, w, h = cv2.boundingRect(approx)
                    cropped_rect_img = pil_img.crop((x, y, x + w, y + h))
                    return cropped_rect_img
                else:
                    print(f"明確な四角形を検出できませんでした (頂点数: {len(approx)}).")
                    return None
            else:
                print(f"指定した色に近い領域が見つかりませんでした.")
                return None

        except Exception as e:
            print(f"四角形の抽出中にエラーが発生しました: {e}")
            return None

    @staticmethod
    def extract_first_rectangle_color(pil_img):
        """
        PIL Image オブジェクトから最初の検出された四角形の領域を切り出します。

        Args:
            pil_img (PIL.Image.Image): 処理する PIL Image オブジェクト。

        Returns:
            PIL.Image.Image or None: 切り出された四角形の PIL Image オブジェクト。
                                    検出できなかった場合は None を返します。
        """
        try:
            # PIL Image を NumPy 配列に変換
            cv_img = np.array(pil_img.convert('RGB'))
            # NumPy 配列を OpenCV の BGR 形式に変換 (cvtColor は BGR をデフォルトとする場合がある)
            gray = cv2.cvtColor(cv_img, cv2.COLOR_RGB2GRAY)
            blurred = cv2.GaussianBlur(gray, (5, 5), 0)
            edged = cv2.Canny(blurred, 50, 150)

            # 輪郭を検出
            contours, _ = cv2.findContours(edged.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

            if contours:
                # 最も大きい輪郭（面積で判断）を四角形として仮定
                largest_contour = max(contours, key=cv2.contourArea)
                approx = cv2.approxPolyDP(largest_contour, 0.02 * cv2.arcLength(largest_contour, True), True)

                if len(approx) == 4:
                    # 四角形とみなせる場合、座標を取得
                    x, y, w, h = cv2.boundingRect(approx)
                    cropped_rect_img = pil_img.crop((x, y, x + w, y + h))
                    return cropped_rect_img
                else:
                    print(f"明確な四角形を検出できませんでした (頂点数: {len(approx)}).")
                    return None
            else:
                print(f"輪郭を検出できませんでした.")
                return None

        except Exception as e:
            print(f"四角形の抽出中にエラーが発生しました: {e}")
            return None


    @staticmethod
    def binarize_image(pil_img, threshold_value=128):
        """
        PIL Image オブジェクトを二値化します。
        """
        try:
            gray_cv_img = np.array(pil_img.convert('L'))
            _, binary_cv_img = cv2.threshold(gray_cv_img, threshold_value, 255, cv2.THRESH_BINARY)
            binary_pil_img = Image.fromarray(binary_cv_img)
            return binary_pil_img
        except Exception as e:
            print(f"二値化処理でエラーが発生しました: {e}")
            return None

def process_folder_images(input_folder, output_folder, processing_callback):
    """
    指定されたフォルダ内のすべての画像ファイルを処理し、コールバック関数を適用し、
    その結果（画像）を出力フォルダに保存します。
    """
    os.makedirs(output_folder, exist_ok=True)
    image_extensions = ['.png', '.jpg', '.jpeg', '.bmp', '.gif']  # 対応する画像拡張子

    for filename in os.listdir(input_folder):
        if any(filename.lower().endswith(ext) for ext in image_extensions):
            input_path = os.path.join(input_folder, filename)
            output_path = os.path.join(output_folder, filename)

            try:
                pil_image = Image.open(input_path)
                processed_image = processing_callback(pil_image)

                if processed_image:
                    processed_image.save(output_path)
                    print(f"処理された画像を {output_path} に保存しました。")
                else:
                    print(f"コールバック関数が画像を返しませんでした: {output_path} への保存をスキップします。")

            except Exception as e:
                print(f"画像の処理中にエラーが発生しました: {input_path} - {e}")

# コールバック関数(クリッピングと四角形抽出)
def callback(img):
    """
    画像をクリッピングし、その後二値化処理を適用して四角形を抽出します。
    クリッピング領域と二値化閾値はここで直接定義。
    """
    crop_area = (0, 0, 800, 400)
    img = ImageProcessor.crop_image(img, crop_area)
    if img:
        res = ImageProcessor.extract_first_rectangle_gray(img) 
        if res is None:
            res = ImageProcessor.extract_first_rectangle_color(img)
        return res
    else:
        None

# =========== 画像の切り出し処理 ===============
input_directory = r"P:\annotated_factorio_images_random"
output_directory_binarized = r"P:\extract_binarized_pipeline"

# 関数の呼び出し
process_folder_images(input_directory, output_directory_binarized, processing_callback=callback)

import easyocr
import os

def perform_ocr_on_folder(folder_path, languages=['en', 'ja']):
    """
    指定されたフォルダ内のすべての画像ファイルに対してOCRを実行し、
    ファイル名、認識されたテキスト文字、信頼度をリスト形式で返します。

    Args:
        folder_path (str): 画像ファイルが格納されたフォルダのパス。
        languages (list, optional): OCRで認識する言語のリスト。デフォルトは ['en', 'ja']。

    Returns:
        list: 各要素が [ファイル名, 認識されたテキスト, 信頼度] のリスト。
              OCRに失敗したファイルの場合は、ファイル名と信頼度 None が格納されます。
    """
    results_list = []
    reader = easyocr.Reader(languages)
    image_extensions = ['.png', '.jpg', '.jpeg', '.bmp', '.gif']  # 対応する画像拡張子

    for filename in os.listdir(folder_path):
        if any(filename.lower().endswith(ext) for ext in image_extensions):
            file_path = os.path.join(folder_path, filename)
            try:
                result = reader.readtext(file_path)
                for detection in result:
                    _, text, confidence = detection
                    results_list.append([filename, text, confidence])
                if not result:  # テキストが何も認識されなかった場合も追加
                    results_list.append([filename, None, None])
            except Exception as e:
                print(f"Error processing file: {filename} - {e}")
                results_list.append([filename, None, None])
    return results_list

folder_to_process = 'P:/extract_binarized_pipeline'
ocr_results_list = perform_ocr_on_folder(folder_to_process)

for item in ocr_results_list:
    filename, text, confidence = item
    print(f"File: {filename}, Text: '{text}', Confidence: {confidence}")

import os
import shutil
import re

def distribute_files(ocr_results, input_folder, output_folder, distribution_rules):
    """
    OCR結果のリストに基づいて、入力フォルダからファイルを取得し、
    出力フォルダ配下のワイルドカード '%' を使用したルールに従ったフォルダに振り分けます。

    Args:
        ocr_results (list): 各要素が [ファイル名, 認識されたテキスト, 信頼度] のリスト。
        input_folder (str): 元の画像ファイルが格納されているフォルダのパス。
        output_folder (str): 振り分け先のルートフォルダのパス。
        distribution_rules (list): 振り分けルールを定義したリスト。
                                  各要素は ['%検索キーワード%', '振り分け先フォルダ名'] のリスト形式。
                                  '%' は0個以上の任意の文字にマッチするワイルドカードとして扱われます。
    """
    os.makedirs(output_folder, exist_ok=True)

    for result in ocr_results:
        filename, text, confidence = result

        if filename is None:
            print(f"警告: ファイル名が不明なOCR結果をスキップします。")
            continue

        source_path = os.path.join(input_folder, filename)

        if not os.path.exists(source_path):
            print(f"警告: 入力フォルダにファイル '{filename}' が見つかりません。スキップします。")
            continue

        destination_folder = None
        if text:
            for rule in distribution_rules:
                pattern, destination = rule
                # ワイルドカード '%' を正規表現の '.*' に置換してマッチング
                regex_pattern = "^" + re.escape(pattern).replace('%', '.*') + "$"
                if re.search(regex_pattern, text.lower()):
                    destination_folder = os.path.join(output_folder, destination)
                    break

        if destination_folder:
            os.makedirs(destination_folder, exist_ok=True)
            destination_path = os.path.join(destination_folder, filename)
            try:
                shutil.copy2(source_path, destination_path)
                print(f"ファイル '{filename}' を '{destination}' フォルダに振り分けました (ルール: '{pattern}')。")
            except Exception as e:
                print(f"エラー: ファイル '{filename}' のコピー中にエラーが発生しました: {e}")
        else:
            default_destination = os.path.join(output_folder, 'unclassified')
            os.makedirs(default_destination, exist_ok=True)
            destination_path = os.path.join(default_destination, filename)
            try:
                shutil.copy2(source_path, destination_path)
                print(f"ファイル '{filename}' は分類ルールに合致せず、'unclassified' フォルダに振り分けました。")
            except Exception as e:
                print(f"エラー: ファイル '{filename}' のコピー中にエラーが発生しました: {e}")

# 切り出した画像（OCRに掛けたい画像）を格納したフォルダ
folder_to_process = 'P:/extract_binarized_pipeline'

# 切り出した画像をOCRで文字列化する
ocr_results_list = perform_ocr_on_folder_simplified(folder_to_process)

# 分類結果を画面に表示する
for item in ocr_results_list:
    filename, text, confidence = item
    print(f"File: {filename}, Text: '{text}', Confidence: {confidence}")


# 入力フォルダと出力フォルダのパスを設定 (実際のものに合わせてください)
input_directory = r'P:\annotated_factorio_images_random'  # 例: 元の画像が入っているフォルダ
output_directory = r'P:\classified_images' # 例: 振り分け先のルートフォルダ

# ワイルドカード '%' を使用した振り分けルールのリスト
classification_rules_wildcard = [
        ['%分類1%', '分類1'],
        ['%分類2%', '分類2'],
        ['%分類3%', '分類3'],
        ['%分類4%', '分類4'],
        ['%分類5%', '分類5'],
    ]

# 実際にファイルを振り分ける関数を呼び出す
distribute_files(ocr_results_list, input_directory, output_directory, classification_rules_wildcard)

print("ファイルの振り分け処理が完了しました ")