import cv2
import numpy as np
 
# 異なる露出の画像を読み込み
images = [cv2.imread(f"exposure_{i}.jpg") for i in range(4)]
exposure_times = np.array([1/30, 1/15, 1/8, 1/4], dtype=np.float32)
 
# カメラレスポンス関数の推定
calibrate = cv2.createCalibrateDebevec()
response = calibrate.process(images, exposure_times)
 
# HDR画像の合成
merge = cv2.createMergeDebevec()
hdr_image = merge.process(images, exposure_times, response)
 
# トーンマッピング（HDR → 表示可能な画像へ）
tonemap = cv2.createTonemap(gamma=2.2)
ldr_image = tonemap.process(hdr_image)
ldr_image = np.clip(ldr_image * 255, 0, 255).astype(np.uint8)
 
cv2.imwrite("hdr_result.jpg", ldr_image)
print("HDR合成完了: ダイナミックレンジを拡大しました")

import torch
import cv2
import numpy as np
 
# MiDaS 深度推定モデル
model = torch.hub.load("intel-isl/MiDaS", "MiDaS_small")
model.eval()
 
transform = torch.hub.load("intel-isl/MiDaS", "transforms").small_transform
 
def portrait_mode(image_path, blur_strength=25):
    """AI深度推定でポートレートモード（背景ぼかし）を実現"""
    img = cv2.imread(image_path)
    img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
 
    # 深度推定
    input_tensor = transform(img_rgb)
    with torch.no_grad():
        depth = model(input_tensor).squeeze().numpy()
 
    # 深度マップを正規化（0〜1）
    depth = (depth - depth.min()) / (depth.max() - depth.min())
    depth = cv2.resize(depth, (img.shape[1], img.shape[0]))
 
    # 前景マスク（深度が近いほど1に近い）
    foreground_mask = (depth > 0.5).astype(np.float32)
    foreground_mask = cv2.GaussianBlur(foreground_mask, (21, 21), 0)
 
    # 背景をぼかす
    blurred = cv2.GaussianBlur(img, (blur_strength, blur_strength), 0)
 
    # 合成: 前景は鮮明、背景はぼかし
    mask_3ch = np.stack([foreground_mask] * 3, axis=-1)
    result = (img * mask_3ch + blurred * (1 - mask_3ch)).astype(np.uint8)
 
    return result
 
result = portrait_mode("photo.jpg")
cv2.imwrite("portrait_result.jpg", result)

import cv2
import numpy as np
 
def night_mode_simulation(frames, alignment_method="ecc"):
    """
    複数の暗い画像を合成してナイトモードを再現
    原理: N枚平均でノイズが1/√N に減少
    """
    # フレームのアライメント（手ブレ補正）
    reference = frames[0]
    aligned_frames = [reference.astype(np.float64)]
 
    for frame in frames[1:]:
        # ECC（Enhanced Correlation Coefficient）で位置合わせ
        gray_ref = cv2.cvtColor(reference, cv2.COLOR_BGR2GRAY)
        gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
 
        warp_matrix = np.eye(2, 3, dtype=np.float32)
        criteria = (
            cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT,
            50, 0.001
        )
        _, warp_matrix = cv2.findTransformECC(
            gray_ref, gray_frame, warp_matrix,
            cv2.MOTION_EUCLIDEAN, criteria
        )
 
        aligned = cv2.warpAffine(
            frame, warp_matrix,
            (frame.shape[1], frame.shape[0])
        )
        aligned_frames.append(aligned.astype(np.float64))
 
    # 平均合成（ノイズ低減）
    merged = np.mean(aligned_frames, axis=0)
 
    # ガンマ補正で明るさ調整
    gamma = 2.0
    merged = np.power(merged / 255.0, 1.0 / gamma) * 255.0
 
    return merged.astype(np.uint8)
 
# 使用例: 15フレームを合成
frames = [cv2.imread(f"dark_frame_{i:02d}.jpg") for i in range(15)]
result = night_mode_simulation(frames)
cv2.imwrite("night_mode_result.jpg", result)

import com.google.mlkit.vision.face.FaceDetection
import com.google.mlkit.vision.face.FaceDetectorOptions
 
fun detectAndEnhanceFaces(bitmap: Bitmap) {
    val options = FaceDetectorOptions.Builder()
        .setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE)
        .setLandmarkMode(FaceDetectorOptions.LANDMARK_MODE_ALL)
        .setContourMode(FaceDetectorOptions.CONTOUR_MODE_ALL)
        .build()
 
    val detector = FaceDetection.getClient(options)
    val image = InputImage.fromBitmap(bitmap, 0)
 
    detector.process(image)
        .addOnSuccessListener { faces ->
            for (face in faces) {
                val bounds = face.boundingBox
                val smile = face.smilingProbability ?: 0f
                val leftEyeOpen = face.leftEyeOpenProbability ?: 0f
 
                println("顔検出: ${bounds}")
                println("笑顔度: ${(smile * 100).toInt()}%")
                println("左目開き: ${(leftEyeOpen * 100).toInt()}%")
 
                // ベストショット選択: 笑顔 + 目が開いている
                if (smile > 0.8f && leftEyeOpen > 0.5f) {
                    println("→ ベストショット候補!")
                }
            }
        }
}

import cv2
import numpy as np
from diffusers import StableDiffusionInpaintPipeline
import torch
 
def magic_eraser(image_path, mask_path, prompt="clean background"):
    """
    AI消しゴム: マスク領域を自然に補完する
    Stable Diffusion Inpainting を使用
    """
    # 画像とマスクの読み込み
    image = cv2.imread(image_path)
    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    mask = cv2.imread(mask_path, cv2.IMREAD_GRAYSCALE)
 
    # PIL形式に変換
    from PIL import Image
    image_pil = Image.fromarray(image).resize((512, 512))
    mask_pil = Image.fromarray(mask).resize((512, 512))
 
    # Inpainting パイプライン
    pipe = StableDiffusionInpaintPipeline.from_pretrained(
        "runwayml/stable-diffusion-inpainting",
        torch_dtype=torch.float16
    ).to("cuda")
 
    result = pipe(
        prompt=prompt,
        image=image_pil,
        mask_image=mask_pil,
        num_inference_steps=30,
        guidance_scale=7.5
    ).images[0]
 
    result.save("erased_result.png")
    print("AI消しゴム完了: 不要物を除去しました")
 
# 使用例
magic_eraser("photo.jpg", "mask.png", "seamless grass background")

import CoreML
import Vision
import CoreImage
import UIKit
 
class AIImageFilter {
    /// Core ML モデルを使ったリアルタイム画像フィルタ
 
    let model: VNCoreMLModel
    let context = CIContext()
 
    init() throws {
        // 事前に変換したセグメンテーションモデルをロード
        let config = MLModelConfiguration()
        config.computeUnits = .all  // CPU + GPU + Neural Engine
        let segModel = try DeepLabV3(configuration: config)
        self.model = try VNCoreMLModel(for: segModel.model)
    }
 
    func applyPortraitEffect(to image: UIImage) -> UIImage? {
        guard let cgImage = image.cgImage else { return nil }
 
        let request = VNCoreMLRequest(model: model) { request, error in
            guard let results = request.results as? [VNPixelBufferObservation],
                  let segMask = results.first?.pixelBuffer else { return }
 
            // セグメンテーションマスクを CIImage に変換
            let maskImage = CIImage(cvPixelBuffer: segMask)
            let originalImage = CIImage(cgImage: cgImage)
 
            // 背景にガウスぼかしを適用
            let blurred = originalImage.applyingGaussianBlur(sigma: 15)
 
            // マスクで合成（前景: 鮮明、背景: ぼかし）
            let composite = originalImage
                .applyingFilter("CIBlendWithMask", parameters: [
                    "inputBackgroundImage": blurred,
                    "inputMaskImage": maskImage
                ])
        }
 
        let handler = VNImageRequestHandler(cgImage: cgImage)
        try? handler.perform([request])
 
        return nil // 実際にはコールバックで結果を返す
    }
 
    /// カメラプレビューでのリアルタイムフィルタ適用
    func processLiveFrame(_ sampleBuffer: CMSampleBuffer) {
        guard let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else { return }
 
        let request = VNCoreMLRequest(model: model) { request, _ in
            // Neural Engine で ~8ms で推論完了
            // フレームレート 30fps を維持可能
        }
 
        // パフォーマンス最適化: 入力を縮小して推論
        request.imageCropAndScaleOption = .scaleFill
 
        let handler = VNImageRequestHandler(cvPixelBuffer: pixelBuffer)
        try? handler.perform([request])
    }
}

import mediapipe as mp
import cv2
import numpy as np
 
class AIBeautyFilter:
    """
    MediaPipe Face Mesh による468ポイント顔メッシュ検出と
    リアルタイム美顔フィルタの実装
    """
    def __init__(self):
        self.mp_face_mesh = mp.solutions.face_mesh
        self.face_mesh = self.mp_face_mesh.FaceMesh(
            max_num_faces=5,
            refine_landmarks=True,   # 虹彩検出も有効化
            min_detection_confidence=0.5,
            min_tracking_confidence=0.5
        )
 
    def process_frame(self, frame, smooth_skin=True,
                      brighten_eyes=True, slim_face=False):
        """リアルタイム美顔処理パイプライン"""
        rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
        results = self.face_mesh.process(rgb)
 
        if not results.multi_face_landmarks:
            return frame
 
        output = frame.copy()
 
        for face_landmarks in results.multi_face_landmarks:
            h, w, _ = frame.shape
            landmarks = [(int(l.x * w), int(l.y * h))
                        for l in face_landmarks.landmark]
 
            if smooth_skin:
                output = self._smooth_skin(output, landmarks)
 
            if brighten_eyes:
                output = self._brighten_eyes(output, landmarks)
 
            if slim_face:
                output = self._slim_face(output, landmarks)
 
        return output
 
    def _smooth_skin(self, frame, landmarks):
        """
        肌のスムージング処理
        ビラテラルフィルタで肌の質感を保ちつつノイズ除去
        """
        # 顔領域のマスクを生成（顔の輪郭ランドマーク使用）
        face_outline = [10, 338, 297, 332, 284, 251, 389, 356,
                       454, 323, 361, 288, 397, 365, 379, 378,
                       400, 377, 152, 148, 176, 149, 150, 136,
                       172, 58, 132, 93, 234, 127, 162, 21, 54, 103, 67, 109]
 
        points = np.array([landmarks[i] for i in face_outline])
        mask = np.zeros(frame.shape[:2], dtype=np.uint8)
        cv2.fillConvexPoly(mask, points, 255)
 
        # 目・口の領域を除外（ぼかしたくない部分）
        left_eye = [33, 133, 160, 159, 158, 157, 173, 144, 145, 153]
        right_eye = [362, 263, 387, 386, 385, 384, 398, 373, 374, 380]
        mouth = [61, 146, 91, 181, 84, 17, 314, 405, 321, 375, 291]
 
        for region in [left_eye, right_eye, mouth]:
            pts = np.array([landmarks[i] for i in region])
            cv2.fillConvexPoly(mask, pts, 0)
 
        # ビラテラルフィルタ（エッジ保持スムージング）
        smoothed = cv2.bilateralFilter(frame, 9, 75, 75)
 
        # マスクで合成
        mask_3ch = cv2.merge([mask, mask, mask]) / 255.0
        result = (smoothed * mask_3ch + frame * (1 - mask_3ch)).astype(np.uint8)
 
        return result
 
    def _brighten_eyes(self, frame, landmarks):
        """目元を明るくする処理"""
        eye_indices = [
            [33, 133, 160, 159, 158, 157, 173, 144, 145, 153],  # 左目
            [362, 263, 387, 386, 385, 384, 398, 373, 374, 380],  # 右目
        ]
 
        for indices in eye_indices:
            pts = np.array([landmarks[i] for i in indices])
            mask = np.zeros(frame.shape[:2], dtype=np.uint8)
            cv2.fillConvexPoly(mask, pts, 255)
 
            # ガンマ補正で明るく
            eye_region = frame.copy()
            gamma = 1.3
            lut = np.array([((i / 255.0) ** (1.0 / gamma)) * 255
                           for i in range(256)]).astype(np.uint8)
            eye_region = cv2.LUT(eye_region, lut)
 
            mask_3ch = cv2.merge([mask, mask, mask]) / 255.0
            frame = (eye_region * mask_3ch + frame * (1 - mask_3ch)).astype(np.uint8)
 
        return frame
 
    def _slim_face(self, frame, landmarks):
        """顔のスリム効果（ワープ処理）"""
        # 頬のランドマークを内側に移動
        # 液化（Liquify）変換で実装
        h, w = frame.shape[:2]
 
        # 左右の頬の基準点
        left_cheek = landmarks[234]
        right_cheek = landmarks[454]
        chin = landmarks[152]
 
        # 基準点に向かってワープ（簡易版）
        # 実際の実装ではThin Plate Spline等を使用
        map_x = np.float32([[i for i in range(w)] for _ in range(h)])
        map_y = np.float32([[j for _ in range(w)] for j in range(h)])
 
        # 頬を中心に向かって2%収縮
        center_x = w // 2
        strength = 0.02
        for y in range(h):
            for x in range(w):
                dx = x - center_x
                if abs(dx) > w * 0.1:  # 頬の領域のみ
                    map_x[y][x] -= dx * strength
 
        result = cv2.remap(frame, map_x, map_y, cv2.INTER_LINEAR)
        return result
 
# 使用例: Webカメラでリアルタイム美顔
filter_engine = AIBeautyFilter()
cap = cv2.VideoCapture(0)
while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break
    result = filter_engine.process_frame(frame, smooth_skin=True, brighten_eyes=True)
    cv2.imshow("AI Beauty Filter", result)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

import torch
import torch.nn as nn
import cv2
import numpy as np
 
class ESPCN(nn.Module):
    """
    Efficient Sub-Pixel CNN (ESPCN) による超解像
    モバイルデバイスでも動作する軽量モデル
 
    なぜESPCNか:
    - PixelShuffle で効率的なアップサンプリング
    - 低解像度空間で特徴抽出 → 計算量削減
    - リアルタイム処理が可能（~5ms on GPU）
    """
    def __init__(self, upscale_factor=2, num_channels=1):
        super().__init__()
        self.conv1 = nn.Conv2d(num_channels, 64, 5, padding=2)
        self.conv2 = nn.Conv2d(64, 32, 3, padding=1)
        self.conv3 = nn.Conv2d(32, num_channels * (upscale_factor ** 2), 3, padding=1)
        self.pixel_shuffle = nn.PixelShuffle(upscale_factor)
        self.relu = nn.ReLU()
 
    def forward(self, x):
        x = self.relu(self.conv1(x))
        x = self.relu(self.conv2(x))
        x = self.pixel_shuffle(self.conv3(x))
        return x
 
def super_resolve(image_path, scale=2):
    """画像を AI で高解像度化"""
    model = ESPCN(upscale_factor=scale)
    model.load_state_dict(torch.load("espcn_x2.pth", map_location="cpu"))
    model.eval()
 
    # 画像読み込みと前処理
    img = cv2.imread(image_path, cv2.IMREAD_COLOR)
    img_ycrcb = cv2.cvtColor(img, cv2.COLOR_BGR2YCrCb)
 
    # Y チャンネル（輝度）のみ超解像
    y_channel = img_ycrcb[:, :, 0].astype(np.float32) / 255.0
    y_tensor = torch.from_numpy(y_channel).unsqueeze(0).unsqueeze(0)
 
    with torch.no_grad():
        y_sr = model(y_tensor).squeeze().numpy()
 
    y_sr = np.clip(y_sr * 255, 0, 255).astype(np.uint8)
 
    # CrCb チャンネルを双三次補間でアップスケール
    cr = cv2.resize(img_ycrcb[:, :, 1],
                    (y_sr.shape[1], y_sr.shape[0]),
                    interpolation=cv2.INTER_CUBIC)
    cb = cv2.resize(img_ycrcb[:, :, 2],
                    (y_sr.shape[1], y_sr.shape[0]),
                    interpolation=cv2.INTER_CUBIC)
 
    # 合成して出力
    result_ycrcb = cv2.merge([y_sr, cr, cb])
    result = cv2.cvtColor(result_ycrcb, cv2.COLOR_YCrCb2BGR)
 
    cv2.imwrite(f"sr_x{scale}_{image_path}", result)
    print(f"超解像完了: {img.shape[:2]} → {result.shape[:2]}")
    return result
 
# 使用例
super_resolve("low_res_photo.jpg", scale=2)

import cv2
import numpy as np
 
class AIDocumentScanner:
    """
    AIを活用したドキュメントスキャナー
    - 自動エッジ検出で書類の四隅を特定
    - 透視変換で正面からの画像に補正
    - 二値化とノイズ除去で読みやすく変換
    """
    def __init__(self):
        self.edge_model = None  # 本番ではMLモデルを使用
 
    def detect_document(self, frame):
        """書類のエッジを検出"""
        # 前処理
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        blurred = cv2.GaussianBlur(gray, (5, 5), 0)
        edges = cv2.Canny(blurred, 50, 150)
 
        # 輪郭検出
        contours, _ = cv2.findContours(edges, cv2.RETR_LIST,
                                        cv2.CHAIN_APPROX_SIMPLE)
        contours = sorted(contours, key=cv2.contourArea, reverse=True)
 
        for contour in contours[:5]:
            peri = cv2.arcLength(contour, True)
            approx = cv2.approxPolyDP(contour, 0.02 * peri, True)
 
            if len(approx) == 4:  # 四角形を検出
                return approx.reshape(4, 2)
 
        return None
 
    def perspective_transform(self, frame, corners):
        """透視変換で正面画像に補正"""
        # 四隅を並べ替え（左上、右上、右下、左下）
        rect = self._order_points(corners)
        (tl, tr, br, bl) = rect
 
        # 出力サイズの計算
        width = max(
            np.linalg.norm(br - bl),
            np.linalg.norm(tr - tl)
        )
        height = max(
            np.linalg.norm(tr - br),
            np.linalg.norm(tl - bl)
        )
 
        dst = np.array([
            [0, 0], [width - 1, 0],
            [width - 1, height - 1], [0, height - 1]
        ], dtype=np.float32)
 
        M = cv2.getPerspectiveTransform(rect.astype(np.float32), dst)
        warped = cv2.warpPerspective(frame, M, (int(width), int(height)))
 
        return warped
 
    def enhance_document(self, image):
        """AIベースの文書画像強調"""
        # 適応的二値化
        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
 
        # CLAHE（コントラスト制限付き適応的ヒストグラム均等化）
        clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
        enhanced = clahe.apply(gray)
 
        # 適応的閾値処理
        binary = cv2.adaptiveThreshold(
            enhanced, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
            cv2.THRESH_BINARY, 11, 2
        )
 
        return binary
 
    def _order_points(self, pts):
        """四隅を左上→右上→右下→左下の順に並べ替え"""
        rect = np.zeros((4, 2), dtype=np.float32)
        s = pts.sum(axis=1)
        rect[0] = pts[np.argmin(s)]   # 左上
        rect[2] = pts[np.argmax(s)]   # 右下
        diff = np.diff(pts, axis=1)
        rect[1] = pts[np.argmin(diff)] # 右上
        rect[3] = pts[np.argmax(diff)] # 左下
        return rect
 
# 使用例
scanner = AIDocumentScanner()
frame = cv2.imread("document_photo.jpg")
corners = scanner.detect_document(frame)
if corners is not None:
    warped = scanner.perspective_transform(frame, corners)
    result = scanner.enhance_document(warped)
    cv2.imwrite("scanned_document.jpg", result)

import torch
from torchvision import transforms, models
from PIL import Image
import json
 
class FoodAIAnalyzer:
    """
    AI食事認識: 写真から食材を識別し栄養情報を推定
    スマートフォンの NPU で動作可能な軽量モデルを使用
    """
    def __init__(self):
        # 食品分類モデル（MobileNetV3をFine-tuning済み）
        self.model = models.mobilenet_v3_small(pretrained=False)
        self.model.classifier[-1] = torch.nn.Linear(1024, 256)  # 256種の食品
        self.model.load_state_dict(torch.load("food_classifier.pth"))
        self.model.eval()
 
        # 栄養データベース（100gあたり）
        self.nutrition_db = {
            "white_rice": {"calories": 168, "protein": 2.5, "carbs": 37, "fat": 0.3},
            "grilled_salmon": {"calories": 208, "protein": 20, "carbs": 0, "fat": 13},
            "miso_soup": {"calories": 40, "protein": 3.3, "carbs": 4.3, "fat": 1.0},
            "salad": {"calories": 15, "protein": 1.2, "carbs": 2.5, "fat": 0.2},
        }
 
        self.transform = transforms.Compose([
            transforms.Resize(256),
            transforms.CenterCrop(224),
            transforms.ToTensor(),
            transforms.Normalize(mean=[0.485, 0.456, 0.406],
                               std=[0.229, 0.224, 0.225])
        ])
 
    def analyze_meal(self, image_path):
        """食事画像を分析"""
        image = Image.open(image_path).convert("RGB")
        input_tensor = self.transform(image).unsqueeze(0)
 
        with torch.no_grad():
            output = self.model(input_tensor)
            probabilities = torch.softmax(output, dim=1)
 
            # 上位5件の予測
            top5_prob, top5_idx = torch.topk(probabilities, 5)
 
        results = []
        for prob, idx in zip(top5_prob[0], top5_idx[0]):
            food_name = self.idx_to_name[idx.item()]
            nutrition = self.nutrition_db.get(food_name, {})
            results.append({
                "food": food_name,
                "confidence": f"{prob.item():.1%}",
                "nutrition_per_100g": nutrition
            })
 
        return results

import cv2
import numpy as np
from skimage.metrics import structural_similarity as ssim
from skimage.metrics import peak_signal_noise_ratio as psnr
 
def evaluate_image_quality(original, processed):
    """
    画像処理AIの品質評価メトリクス
    モデル選定やハイパーパラメータ調整に使用
    """
    # PSNR（ピーク信号対雑音比）: 高いほど良い
    psnr_value = psnr(original, processed)
 
    # SSIM（構造的類似度）: 1に近いほど良い
    ssim_value = ssim(original, processed, channel_axis=2)
 
    # BRISQUE（無参照画質評価）: 低いほど良い
    # ブラインド/リファレンスレス画質評価
    # OpenCV の quality モジュールを使用
 
    # 色相の一貫性チェック
    hsv_orig = cv2.cvtColor(original, cv2.COLOR_BGR2HSV)
    hsv_proc = cv2.cvtColor(processed, cv2.COLOR_BGR2HSV)
    hue_diff = np.mean(np.abs(hsv_orig[:,:,0].astype(float) -
                               hsv_proc[:,:,0].astype(float)))
 
    results = {
        "PSNR (dB)": f"{psnr_value:.2f}",      # 目安: 30dB以上
        "SSIM": f"{ssim_value:.4f}",             # 目安: 0.90以上
        "色相差 (平均)": f"{hue_diff:.2f}",      # 目安: 5以下
        "判定": "PASS" if psnr_value > 30 and ssim_value > 0.90 else "FAIL"
    }
 
    return results
 
# 使用例: AI処理前後の品質を評価
original = cv2.imread("original.jpg")
processed = cv2.imread("ai_enhanced.jpg")
quality = evaluate_image_quality(original, processed)
for k, v in quality.items():
    print(f"  {k}: {v}")

class ResilientCameraAI:
    """
    AI処理が失敗した場合のフォールバック付きパイプライン
 
    なぜ必要か:
    - MLモデルの推論は入力によっては予期しない結果を返す
    - メモリ不足で推論が中断される場合がある
    - NPUが他のアプリに占有されている場合がある
    """
    def __init__(self):
        self.ai_depth_estimator = load_model("midas_small")
        self.fallback_depth = None  # 直前の成功結果をキャッシュ
 
    def estimate_depth(self, frame):
        try:
            # 優先: AI深度推定（NPU）
            depth = self.ai_depth_estimator.predict(frame)
            self.fallback_depth = depth  # キャッシュ
            return depth, "ai"
        except (RuntimeError, MemoryError):
            # フォールバック1: 直前の推定結果を再利用
            if self.fallback_depth is not None:
                return self.fallback_depth, "cache"
 
            # フォールバック2: 古典的手法（コントラストベース）
            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
            laplacian = cv2.Laplacian(gray, cv2.CV_64F)
            depth_approx = np.abs(laplacian)
            return depth_approx, "classical"

# 演習1: 基本実装のテンプレート
class Exercise1:
    """基本的な実装パターンの演習"""
 
    def __init__(self):
        self.data = []
 
    def validate_input(self, value):
        """入力値の検証"""
        if value is None:
            raise ValueError("入力値がNoneです")
        return True
 
    def process(self, value):
        """データ処理のメインロジック"""
        self.validate_input(value)
        self.data.append(value)
        return self.data
 
    def get_results(self):
        """処理結果の取得"""
        return {
            'count': len(self.data),
            'data': self.data
        }
 
# テスト
def test_exercise1():
    ex = Exercise1()
    assert ex.process(1) == [1]
    assert ex.process(2) == [1, 2]
    assert ex.get_results()['count'] == 2
 
    try:
        ex.process(None)
        assert False, "例外が発生するべき"
    except ValueError:
        pass
 
    print("全テスト合格!")
 
test_exercise1()

# 演習2: 応用パターン
from typing import List, Dict, Optional
from datetime import datetime
 
class AdvancedExercise:
    """応用パターンの演習"""
 
    def __init__(self, max_size: int = 100):
        self._items: List[Dict] = []
        self._max_size = max_size
        self._created_at = datetime.now()
 
    def add(self, key: str, value: any) -> bool:
        """アイテムの追加（サイズ制限付き）"""
        if len(self._items) >= self._max_size:
            return False
        self._items.append({
            'key': key,
            'value': value,
            'timestamp': datetime.now().isoformat()
        })
        return True
 
    def find(self, key: str) -> Optional[Dict]:
        """キーによる検索"""
        for item in reversed(self._items):
            if item['key'] == key:
                return item
        return None
 
    def remove(self, key: str) -> bool:
        """キーによる削除"""
        for i, item in enumerate(self._items):
            if item['key'] == key:
                self._items.pop(i)
                return True
        return False
 
    def stats(self) -> Dict:
        """統計情報"""
        return {
            'total_items': len(self._items),
            'max_size': self._max_size,
            'usage_percent': len(self._items) / self._max_size * 100,
            'uptime': str(datetime.now() - self._created_at)
        }
 
# テスト
def test_advanced():
    ex = AdvancedExercise(max_size=3)
    assert ex.add("a", 1) == True
    assert ex.add("b", 2) == True
    assert ex.add("c", 3) == True
    assert ex.add("d", 4) == False  # サイズ制限
    assert ex.find("b")['value'] == 2
    assert ex.remove("b") == True
    assert ex.find("b") is None
    stats = ex.stats()
    assert stats['total_items'] == 2
    print("応用テスト全合格!")
 
test_advanced()

# 演習3: パフォーマンス最適化
import time
from functools import lru_cache
 
# 最適化前（O(n^2)）
def slow_search(data: list, target: int) -> int:
    """非効率な検索"""
    for i in range(len(data)):
        for j in range(i + 1, len(data)):
            if data[i] + data[j] == target:
                return (i, j)
    return (-1, -1)
 
# 最適化後（O(n)）
def fast_search(data: list, target: int) -> tuple:
    """ハッシュマップを使った効率的な検索"""
    seen = {}
    for i, num in enumerate(data):
        complement = target - num
        if complement in seen:
            return (seen[complement], i)
        seen[num] = i
    return (-1, -1)
 
# ベンチマーク
def benchmark():
    import random
    data = list(range(5000))
    random.shuffle(data)
    target = data[100] + data[4000]
 
    start = time.time()
    result1 = slow_search(data, target)
    slow_time = time.time() - start
 
    start = time.time()
    result2 = fast_search(data, target)
    fast_time = time.time() - start
 
    print(f"非効率版: {slow_time:.4f}秒")
    print(f"効率版:   {fast_time:.6f}秒")
    print(f"高速化率: {slow_time/fast_time:.0f}倍")
 
benchmark()