# 解像度計算の実装例
import math

class PrintResolutionCalculator:
    def __init__(self):
        # 標準的な視覚特性パラメータ
        self.visual_acuity_arcmin = 1.0  # 1分角（20/20視力）
        self.eye_lens_accommodation = 0.3  # 調節能力（ディオプター）
        
    def calculate_minimum_resolution(self, viewing_distance_cm, print_type='offset'):
        """視距離から必要最小解像度を算出"""
        
        # 視距離をインチに変換
        viewing_distance_inch = viewing_distance_cm / 2.54
        
        # 最小識別角度（ラジアン）
        min_angle_rad = math.radians(self.visual_acuity_arcmin / 60.0)
        
        # 視距離における最小識別距離
        min_resolvable_distance_inch = viewing_distance_inch * math.tan(min_angle_rad)
        
        # 理論上の最大有効解像度
        theoretical_max_ppi = 1.0 / min_resolvable_distance_inch
        
        # 印刷方式による調整係数
        adjustment_factors = {
            'offset': 0.7,      # オフセット印刷（高品質）
            'digital': 0.6,     # デジタル印刷（やや粗い）
            'inkjet': 0.5,      # インクジェット（ドット拡散）
            'laser': 0.65,      # レーザープリンター
            'newspaper': 0.4,   # 新聞印刷（紙質による制約）
            'billboard': 0.3    # 看板・ポスター（粗くても可）
        }
        
        practical_max_ppi = theoretical_max_ppi * adjustment_factors.get(print_type, 0.6)
        
        return {
            'theoretical_max_ppi': round(theoretical_max_ppi, 1),
            'practical_max_ppi': round(practical_max_ppi, 1),
            'recommended_ppi': round(practical_max_ppi * 1.2, 1),  # 20% マージン
            'viewing_distance_cm': viewing_distance_cm,
            'print_type': print_type
        }
    
    def recommend_resolution_by_use_case(self, use_case):
        """用途別の推奨解像度"""
        
        use_case_configs = {
            'business_card': {
                'viewing_distance': 25,  # 25cm
                'print_type': 'offset',
                'special_notes': '細かい文字が多いため高解像度推奨'
            },
            'brochure': {
                'viewing_distance': 35,  # 35cm
                'print_type': 'offset',
                'special_notes': '写真品質と読みやすさのバランス'
            },
            'poster_a1': {
                'viewing_distance': 100,  # 1m
                'print_type': 'digital',
                'special_notes': '遠距離視認のため低解像度でも可'
            },
            'magazine': {
                'viewing_distance': 40,  # 40cm
                'print_type': 'offset',
                'special_notes': '長時間読書のため適度な解像度'
            },
            'billboard': {
                'viewing_distance': 500,  # 5m以上
                'print_type': 'inkjet',
                'special_notes': '超大判・遠距離視認特化'
            },
            'photo_print': {
                'viewing_distance': 30,  # 30cm
                'print_type': 'inkjet',
                'special_notes': '写真鑑賞用最高品質'
            }
        }
        
        if use_case not in use_case_configs:
            raise ValueError(f"未対応の用途: {use_case}")
        
        config = use_case_configs[use_case]
        base_calculation = self.calculate_minimum_resolution(
            config['viewing_distance'], 
            config['print_type']
        )
        
        # 用途別の追加調整
        if use_case == 'business_card':
            # 名刺は文字が小さいため 1.5倍
            base_calculation['recommended_ppi'] *= 1.5
        elif use_case == 'photo_print':
            # 写真プリントは品質重視で 1.3倍
            base_calculation['recommended_ppi'] *= 1.3
        elif use_case == 'billboard':
            # 看板は逆に 0.8倍でOK
            base_calculation['recommended_ppi'] *= 0.8
        
        base_calculation['use_case'] = use_case
        base_calculation['special_notes'] = config['special_notes']
        
        return base_calculation

# 実使用例
calculator = PrintResolutionCalculator()

print("=== 用途別推奨解像度 ===")
use_cases = ['business_card', 'brochure', 'poster_a1', 'magazine', 'photo_print']

for case in use_cases:
    result = calculator.recommend_resolution_by_use_case(case)
    print(f"\n{case.upper()}:")
    print(f"  推奨解像度: {result['recommended_ppi']} PPI")
    print(f"  視距離: {result['viewing_distance_cm']} cm")
    print(f"  特記: {result['special_notes']}")

# 年齢・視力による視覚特性の変化
class VisualAcuityModel:
    def __init__(self):
        self.base_acuity_20_20 = 1.0  # 20/20視力の基準値
        
    def age_adjusted_acuity(self, age, base_acuity=1.0):
        """年齢による視力低下を考慮"""
        
        if age < 20:
            # 若年層: 理論値以上の視力
            age_factor = 1.1
        elif age < 40:
            # 壮年層: 基準視力維持
            age_factor = 1.0
        elif age < 60:
            # 中高年: 緩やかな低下
            age_factor = 0.9 - (age - 40) * 0.01
        else:
            # 高齢層: より顕著な低下
            age_factor = 0.7 - (age - 60) * 0.015
            age_factor = max(age_factor, 0.3)  # 下限設定
        
        return base_acuity * age_factor
    
    def lighting_adjustment(self, lux_level):
        """照明条件による視力への影響"""
        
        if lux_level < 50:
            # 薄暗い環境
            lighting_factor = 0.6
        elif lux_level < 200:
            # 室内標準照明
            lighting_factor = 0.8
        elif lux_level < 1000:
            # 明るい室内
            lighting_factor = 1.0
        else:
            # 屋外・強照明
            lighting_factor = 1.1
        
        return lighting_factor
    
    def calculate_effective_resolution_need(self, viewing_distance_cm, age=30, 
                                          acuity=1.0, lux=500):
        """総合的な解像度必要性を算出"""
        
        base_calculator = PrintResolutionCalculator()
        base_result = base_calculator.calculate_minimum_resolution(viewing_distance_cm)
        
        # 個人差・環境要因の調整
        age_factor = self.age_adjusted_acuity(age, acuity)
        lighting_factor = self.lighting_adjustment(lux)
        
        # 総合調整係数
        total_factor = age_factor * lighting_factor
        
        adjusted_ppi = base_result['practical_max_ppi'] / total_factor
        
        return {
            **base_result,
            'age_adjusted_acuity': age_factor,
            'lighting_factor': lighting_factor,
            'total_adjustment': total_factor,
            'adjusted_recommended_ppi': round(adjusted_ppi * 1.2, 1)
        }

# 利用例: 高齢者向け印刷物の解像度設定
visual_model = VisualAcuityModel()
elderly_reading = visual_model.calculate_effective_resolution_need(
    viewing_distance_cm=45,  # やや遠めで読む
    age=70,                  # 70歳
    acuity=0.8,             # やや視力低下
    lux=300                  # 標準的な室内照明
)

print(f"高齢者向け印刷物推奨解像度: {elderly_reading['adjusted_recommended_ppi']} PPI")

# オフセット印刷での線数とPPIの関係
class OffsetPrintOptimizer:
    def __init__(self):
        # 標準的な線数（LPI: Lines Per Inch）
        self.standard_screen_rulings = {
            'newspaper': 85,      # 新聞
            'magazine': 133,      # 雑誌
            'art_book': 150,      # 美術書
            'fine_art': 175,      # 高級印刷物
            'packaging': 120      # パッケージ
        }
    
    def calculate_optimal_ppi_for_offset(self, print_type, quality_factor=1.5):
        """線数に基づく最適PPI算出"""
        
        if print_type not in self.standard_screen_rulings:
            raise ValueError(f"未対応の印刷タイプ: {print_type}")
        
        screen_ruling = self.standard_screen_rulings[print_type]
        
        # PPI = 線数 × 品質係数（1.5〜2.0が一般的）
        optimal_ppi = screen_ruling * quality_factor
        
        # 実用的な範囲での調整
        if optimal_ppi < 150:
            practical_ppi = 150  # 最低限の品質保証
        elif optimal_ppi > 350:
            practical_ppi = 350  # 過剰品質の抑制
        else:
            practical_ppi = optimal_ppi
        
        return {
            'print_type': print_type,
            'screen_ruling_lpi': screen_ruling,
            'quality_factor': quality_factor,
            'calculated_ppi': round(optimal_ppi, 1),
            'practical_ppi': round(practical_ppi, 1),
            'file_size_impact': self.estimate_file_size_impact(practical_ppi)
        }
    
    def estimate_file_size_impact(self, ppi, base_size_inches=(8, 10)):
        """解像度によるファイルサイズ影響を試算"""
        
        width_inch, height_inch = base_size_inches
        total_pixels = (width_inch * ppi) * (height_inch * ppi)
        
        # RGB 24bit, 非圧縮での概算
        uncompressed_mb = (total_pixels * 3) / (1024 * 1024)
        
        # JPEG圧縮後の概算（品質90%想定）
        jpeg_mb = uncompressed_mb * 0.15
        
        # TIFF LZW圧縮の概算
        tiff_lzw_mb = uncompressed_mb * 0.4
        
        return {
            'dimensions_pixels': f"{int(width_inch * ppi)}×{int(height_inch * ppi)}",
            'uncompressed_mb': round(uncompressed_mb, 1),
            'jpeg_90_mb': round(jpeg_mb, 1),
            'tiff_lzw_mb': round(tiff_lzw_mb, 1)
        }

# 印刷タイプ別の推奨設定
optimizer = OffsetPrintOptimizer()

print("=== オフセット印刷タイプ別最適化 ===")
for print_type in ['newspaper', 'magazine', 'art_book', 'fine_art']:
    result = optimizer.calculate_optimal_ppi_for_offset(print_type)
    print(f"\n{print_type.upper()}:")
    print(f"  線数: {result['screen_ruling_lpi']} LPI")
    print(f"  推奨PPI: {result['practical_ppi']}")
    print(f"  8×10インチでのファイルサイズ:")
    print(f"    JPEG: {result['file_size_impact']['jpeg_90_mb']} MB")
    print(f"    TIFF: {result['file_size_impact']['tiff_lzw_mb']} MB")

# インクジェット印刷の最適化
class InkjetOptimizer:
    def __init__(self):
        self.printer_types = {
            'consumer_inkjet': {
                'native_dpi': 300,
                'interpolated_dpi': 1200,
                'optimal_ppi_range': (150, 300),
                'paper_types': ['plain', 'photo', 'matte']
            },
            'professional_inkjet': {
                'native_dpi': 600,
                'interpolated_dpi': 2400,
                'optimal_ppi_range': (240, 360),
                'paper_types': ['photo', 'fine_art', 'canvas']
            },
            'large_format': {
                'native_dpi': 150,
                'interpolated_dpi': 600,
                'optimal_ppi_range': (72, 150),
                'paper_types': ['banner', 'poster', 'vinyl']
            }
        }
    
    def optimize_for_inkjet(self, printer_type, paper_type, image_content='photo'):
        """インクジェット印刷の最適化"""
        
        if printer_type not in self.printer_types:
            raise ValueError(f"未対応のプリンタータイプ: {printer_type}")
        
        printer_spec = self.printer_types[printer_type]
        
        if paper_type not in printer_spec['paper_types']:
            print(f"警告: {paper_type} は {printer_type} で推奨されていません")
        
        # 用紙タイプによる調整
        paper_adjustments = {
            'plain': 0.8,        # 普通紙は解像度を下げても差が少ない
            'photo': 1.0,        # フォト紙は標準
            'matte': 0.9,        # マット紙は中間
            'fine_art': 1.1,     # ファインアート紙は高解像度が活きる
            'canvas': 0.85,      # キャンバスは織り目で解像感が制限
            'banner': 0.7,       # バナーは遠距離視認
            'vinyl': 0.75        # ビニールは表面特性による
        }
        
        # コンテンツタイプによる調整
        content_adjustments = {
            'photo': 1.0,        # 写真は標準
            'illustration': 1.1,  # イラストは線の鮮明さが重要
            'text': 1.2,         # テキストは高解像度が効果的
            'mixed': 1.05        # 混在コンテンツは中間値
        }
        
        base_ppi = (printer_spec['optimal_ppi_range'][0] + 
                   printer_spec['optimal_ppi_range'][1]) / 2
        
        adjusted_ppi = (base_ppi * 
                       paper_adjustments.get(paper_type, 1.0) * 
                       content_adjustments.get(image_content, 1.0))
        
        # 実用範囲内でのクランプ
        min_ppi, max_ppi = printer_spec['optimal_ppi_range']
        final_ppi = max(min_ppi, min(max_ppi, adjusted_ppi))
        
        return {
            'printer_type': printer_type,
            'paper_type': paper_type,
            'content_type': image_content,
            'recommended_ppi': round(final_ppi, 1),
            'native_dpi': printer_spec['native_dpi'],
            'ppi_efficiency': self.calculate_ppi_efficiency(final_ppi, printer_spec['native_dpi']),
            'quality_notes': self.generate_quality_notes(printer_type, paper_type, final_ppi)
        }
    
    def calculate_ppi_efficiency(self, input_ppi, printer_native_dpi):
        """PPI効率性の評価"""
        
        # プリンターネイティブDPIとの関係
        efficiency_ratio = input_ppi / printer_native_dpi
        
        if 0.4 <= efficiency_ratio <= 1.2:
            efficiency = "最適"
        elif 0.2 <= efficiency_ratio < 0.4 or 1.2 < efficiency_ratio <= 2.0:
            efficiency = "良好"
        else:
            efficiency = "非効率"
        
        return {
            'ratio': round(efficiency_ratio, 2),
            'assessment': efficiency,
            'recommendation': self.get_efficiency_recommendation(efficiency_ratio)
        }
    
    def get_efficiency_recommendation(self, ratio):
        """効率性に基づく推奨事項"""
        
        if ratio < 0.2:
            return "解像度不足。画質劣化の可能性"
        elif ratio < 0.4:
            return "やや低解像度。用途によっては問題なし"
        elif ratio <= 1.2:
            return "最適な解像度範囲"
        elif ratio <= 2.0:
            return "やや高解像度。ファイルサイズ増大"
        else:
            return "過剰解像度。処理時間とストレージを浪費"

# 実用例
inkjet_optimizer = InkjetOptimizer()

test_cases = [
    ('consumer_inkjet', 'photo', 'photo'),
    ('professional_inkjet', 'fine_art', 'photo'),
    ('large_format', 'banner', 'illustration')
]

print("=== インクジェット最適化結果 ===")
for printer, paper, content in test_cases:
    result = inkjet_optimizer.optimize_for_inkjet(printer, paper, content)
    print(f"\n{printer} + {paper} + {content}:")
    print(f"  推奨PPI: {result['recommended_ppi']}")
    print(f"  効率性: {result['ppi_efficiency']['assessment']} (比率: {result['ppi_efficiency']['ratio']})")
    print(f"  推奨: {result['ppi_efficiency']['recommendation']}")

# 総合的な解像度決定システム
class ResolutionDecisionEngine:
    def __init__(self):
        self.resolution_calc = PrintResolutionCalculator()
        self.visual_model = VisualAcuityModel()
        self.offset_optimizer = OffsetPrintOptimizer()
        self.inkjet_optimizer = InkjetOptimizer()
    
    def decide_optimal_resolution(self, project_specs):
        """プロジェクト仕様から最適解像度を決定"""
        
        required_keys = ['print_method', 'final_size_cm', 'viewing_distance_cm', 
                        'target_audience', 'content_type', 'budget_level']
        
        for key in required_keys:
            if key not in project_specs:
                raise ValueError(f"必須パラメータが不足: {key}")
        
        # 各手法での推奨値を算出
        recommendations = {}
        
        # 1. 視距離ベースの計算
        visual_rec = self.resolution_calc.calculate_minimum_resolution(
            project_specs['viewing_distance_cm'],
            project_specs['print_method']
        )
        recommendations['visual_based'] = visual_rec['recommended_ppi']
        
        # 2. 印刷技術ベースの計算
        if project_specs['print_method'] in ['offset', 'digital']:
            # オフセット/デジタル印刷
            print_mapping = {
                'business_card': 'fine_art',
                'brochure': 'magazine', 
                'poster': 'magazine',
                'book': 'magazine',
                'magazine': 'magazine',
                'art_print': 'art_book'
            }
            print_type = print_mapping.get(project_specs.get('product_type', 'magazine'), 'magazine')
            
            offset_rec = self.offset_optimizer.calculate_optimal_ppi_for_offset(print_type)
            recommendations['print_tech_based'] = offset_rec['practical_ppi']
            
        elif project_specs['print_method'] == 'inkjet':
            # インクジェット印刷
            printer_mapping = {
                'small': 'consumer_inkjet',
                'medium': 'professional_inkjet', 
                'large': 'large_format'
            }
            printer_type = printer_mapping.get(project_specs.get('size_category', 'medium'), 'professional_inkjet')
            
            inkjet_rec = self.inkjet_optimizer.optimize_for_inkjet(
                printer_type,
                project_specs.get('paper_type', 'photo'),
                project_specs['content_type']
            )
            recommendations['print_tech_based'] = inkjet_rec['recommended_ppi']
        
        # 3. 対象オーディエンスによる調整
        audience_factors = {
            'general': 1.0,
            'elderly': 0.8,      # 視力低下を考慮して低めでも可
            'professional': 1.2,  # 品質要求が高い
            'children': 0.9      # 至近距離で見る傾向
        }
        
        audience_factor = audience_factors.get(project_specs['target_audience'], 1.0)
        
        # 4. 予算レベルによる調整
        budget_factors = {
            'low': 0.8,          # コスト重視
            'medium': 1.0,       # バランス
            'high': 1.15         # 品質重視
        }
        
        budget_factor = budget_factors.get(project_specs['budget_level'], 1.0)
        
        # 5. 最終的な推奨値の算出
        base_recommendations = list(recommendations.values())
        median_recommendation = sorted(base_recommendations)[len(base_recommendations)//2]
        
        final_ppi = median_recommendation * audience_factor * budget_factor
        
        # 実用的な値への丸め
        practical_ppi = self.round_to_practical_value(final_ppi)
        
        return {
            'recommended_ppi': practical_ppi,
            'calculation_breakdown': recommendations,
            'adjustment_factors': {
                'audience': audience_factor,
                'budget': budget_factor
            },
            'final_image_specs': self.calculate_final_specs(
                practical_ppi, 
                project_specs['final_size_cm']
            ),
            'alternative_options': self.generate_alternatives(practical_ppi)
        }
    
    def round_to_practical_value(self, calculated_ppi):
        """実用的な値に丸める"""
        
        # 一般的に使われる解像度値
        common_values = [72, 96, 150, 200, 240, 300, 360, 400]
        
        # 最も近い値を探す
        closest_value = min(common_values, key=lambda x: abs(x - calculated_ppi))
        
        # ±20%以内なら標準値を採用、そうでなければ計算値
        if abs(closest_value - calculated_ppi) / calculated_ppi <= 0.2:
            return closest_value
        else:
            return round(calculated_ppi / 10) * 10  # 10の倍数に丸める
    
    def calculate_final_specs(self, ppi, size_cm):
        """最終的な画像仕様を算出"""
        
        width_cm, height_cm = size_cm
        width_inch = width_cm / 2.54
        height_inch = height_cm / 2.54
        
        pixel_width = int(width_inch * ppi)
        pixel_height = int(height_inch * ppi)
        
        # ファイルサイズ概算
        uncompressed_mb = (pixel_width * pixel_height * 3) / (1024 * 1024)
        
        return {
            'pixel_dimensions': f"{pixel_width}×{pixel_height}",
            'ppi': ppi,
            'physical_size_cm': f"{width_cm}×{height_cm}",
            'estimated_file_size': {
                'uncompressed_mb': round(uncompressed_mb, 1),
                'jpeg_high_mb': round(uncompressed_mb * 0.2, 1),
                'tiff_lzw_mb': round(uncompressed_mb * 0.4, 1)
            }
        }
    
    def generate_alternatives(self, base_ppi):
        """代替案の生成"""
        
        return {
            'economy': {
                'ppi': round(base_ppi * 0.75),
                'use_case': 'コスト重視、一般的な品質で十分'
            },
            'standard': {
                'ppi': base_ppi,
                'use_case': '推奨設定、品質とコストのバランス'
            },
            'premium': {
                'ppi': round(base_ppi * 1.3),
                'use_case': '最高品質要求、アーカイブ用途'
            }
        }

# 実使用例
decision_engine = ResolutionDecisionEngine()

# プロジェクト仕様例
project = {
    'print_method': 'offset',
    'final_size_cm': (21, 29.7),  # A4サイズ
    'viewing_distance_cm': 40,    # 40cm（雑誌読書距離）
    'target_audience': 'general',
    'content_type': 'mixed',      # 写真とテキストの混在
    'budget_level': 'medium',
    'product_type': 'magazine'
}

result = decision_engine.decide_optimal_resolution(project)

print("=== 解像度決定結果 ===")
print(f"推奨PPI: {result['recommended_ppi']}")
print(f"最終画像サイズ: {result['final_image_specs']['pixel_dimensions']} pixels")
print(f"推定ファイルサイズ（JPEG高品質）: {result['final_image_specs']['estimated_file_size']['jpeg_high_mb']} MB")

print("\n=== 代替案 ===")
for option, specs in result['alternative_options'].items():
    print(f"{option.upper()}: {specs['ppi']} PPI - {specs['use_case']}")

# コスト効率分析システム
class CostEfficiencyAnalyzer:
    def __init__(self):
        # 処理時間の基準値（秒/メガピクセル）
        self.processing_time_per_mp = {
            'photoshop_filter': 2.5,    # 複雑なフィルター処理
            'ai_upscaling': 15.0,       # AI超解像処理
            'color_correction': 1.2,    # 色補正
            'sharpening': 0.8,          # シャープネス処理
            'noise_reduction': 5.0      # ノイズ除去
        }
        
        # ストレージコスト（$/GB/月）
        self.storage_cost_per_gb_month = 0.023  # AWS S3スタンダード概算
        
        # 印刷コスト係数
        self.print_cost_factors = {
            'paper_cost': 1.0,          # 基準
            'ink_consumption': 1.2,     # 高解像度で若干増加
            'processing_time': 0.8      # 印刷機での処理時間
        }
    
    def analyze_resolution_costs(self, resolution_options, project_volume):
        """解像度オプションのコスト分析"""
        
        cost_analysis = {}
        
        for option_name, ppi in resolution_options.items():
            # 例: A4サイズでの分析
            a4_width_inch = 8.27
            a4_height_inch = 11.69
            
            pixel_width = int(a4_width_inch * ppi)
            pixel_height = int(a4_height_inch * ppi)
            total_pixels = pixel_width * pixel_height
            megapixels = total_pixels / 1_000_000
            
            # ファイルサイズ（MB）
            uncompressed_mb = (total_pixels * 3) / (1024 * 1024)
            working_file_mb = uncompressed_mb * 1.5  # 作業ファイルは大きめ
            
            # 処理時間コスト
            processing_costs = {}
            for process, time_per_mp in self.processing_time_per_mp.items():
                time_seconds = megapixels * time_per_mp
                # 時給換算（例: デザイナー時給 $50）
                labor_cost = (time_seconds / 3600) * 50 * project_volume
                processing_costs[process] = {
                    'time_seconds': time_seconds,
                    'cost_usd': round(labor_cost, 2)
                }
            
            # ストレージコスト（1年間）
            storage_gb = working_file_mb / 1024
            annual_storage_cost = storage_gb * self.storage_cost_per_gb_month * 12 * project_volume
            
            # 印刷コスト（概算）
            base_print_cost = 5.0 * project_volume  # 基準印刷コスト
            resolution_impact = min(1 + (ppi - 300) / 1000, 1.3)  # 300PPI基準で調整
            adjusted_print_cost = base_print_cost * resolution_impact
            
            # 総コスト
            total_processing_cost = sum(cost['cost_usd'] for cost in processing_costs.values())
            total_cost = total_processing_cost + annual_storage_cost + adjusted_print_cost
            
            cost_analysis[option_name] = {
                'ppi': ppi,
                'megapixels': round(megapixels, 1),
                'file_size_mb': round(working_file_mb, 1),
                'processing_costs': processing_costs,
                'storage_cost_annual': round(annual_storage_cost, 2),
                'print_cost': round(adjusted_print_cost, 2),
                'total_cost': round(total_cost, 2),
                'cost_per_unit': round(total_cost / project_volume, 2)
            }
        
        return cost_analysis
    
    def recommend_cost_optimal_resolution(self, cost_analysis, quality_threshold=0.9):
        """コスト効率の観点から最適解像度を推奨"""
        
        # コスト効率（品質/コスト比）を算出
        cost_efficiency = {}
        
        base_quality = 1.0  # 標準解像度での品質を1.0とする
        
        for option, analysis in cost_analysis.items():
            ppi = analysis['ppi']
            
            # 解像度による品質スコア（対数的改善）
            quality_score = min(1.0 + math.log(ppi / 300) * 0.3, 1.5)
            
            # コスト効率
            efficiency = quality_score / analysis['cost_per_unit']
            
            cost_efficiency[option] = {
                'quality_score': round(quality_score, 2),
                'cost_per_unit': analysis['cost_per_unit'],
                'efficiency': round(efficiency, 4),
                'meets_threshold': quality_score >= quality_threshold
            }
        
        # 効率順でソート
        sorted_options = sorted(
            cost_efficiency.items(), 
            key=lambda x: x[1]['efficiency'], 
            reverse=True
        )
        
        return {
            'cost_efficiency_ranking': sorted_options,
            'recommended_option': sorted_options[0][0],
            'cost_savings_analysis': self.calculate_savings(cost_analysis)
        }
    
    def calculate_savings(self, cost_analysis):
        """コスト削減効果の分析"""
        
        costs = [(option, data['total_cost']) for option, data in cost_analysis.items()]
        costs.sort(key=lambda x: x[1])
        
        cheapest = costs[0]
        most_expensive = costs[-1]
        
        absolute_savings = most_expensive[1] - cheapest[1]
        percentage_savings = (absolute_savings / most_expensive[1]) * 100
        
        return {
            'cheapest_option': cheapest[0],
            'most_expensive_option': most_expensive[0],
            'absolute_savings_usd': round(absolute_savings, 2),
            'percentage_savings': round(percentage_savings, 1)
        }

# 実使用例
cost_analyzer = CostEfficiencyAnalyzer()

# 解像度オプション
resolution_options = {
    'low': 200,
    'standard': 300,
    'high': 360,
    'premium': 450
}

# プロジェクト規模（1000冊の雑誌）
project_volume = 1000

# コスト分析実行
cost_analysis = cost_analyzer.analyze_resolution_costs(resolution_options, project_volume)
recommendations = cost_analyzer.recommend_cost_optimal_resolution(cost_analysis)

print("=== コスト効率分析結果 ===")
for option, analysis in cost_analysis.items():
    print(f"\n{option.upper()} ({analysis['ppi']} PPI):")
    print(f"  単位コスト: ${analysis['cost_per_unit']}")
    print(f"  ファイルサイズ: {analysis['file_size_mb']} MB")
    print(f"  総コスト: ${analysis['total_cost']}")

print(f"\n推奨オプション: {recommendations['recommended_option'].upper()}")
print(f"最大コスト削減: ${recommendations['cost_savings_analysis']['absolute_savings_usd']} ({recommendations['cost_savings_analysis']['percentage_savings']}%)")

# 解像度品質検証システム
import numpy as np
from scipy import ndimage
import cv2

class ResolutionQualityValidator:
    def __init__(self):
        self.quality_thresholds = {
            'sharpness_score': 0.3,     # エッジ強度スコア
            'detail_preservation': 0.7,  # 細部保持率
            'artifact_level': 0.1       # アーティファクト許容レベル
        }
    
    def analyze_image_quality(self, image_path, target_print_size_cm, viewing_distance_cm):
        """画像品質の総合分析"""
        
        # 画像読み込み
        image = cv2.imread(image_path)
        if image is None:
            raise ValueError(f"画像を読み込めません: {image_path}")
        
        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        
        # 現在の解像度を取得
        height, width = gray.shape
        
        # メタデータから PPI を取得（または推定）
        current_ppi = self.extract_ppi_from_metadata(image_path)
        if current_ppi is None:
            current_ppi = self.estimate_ppi(width, height, target_print_size_cm)
        
        # 各種品質指標を計算
        quality_metrics = {
            'sharpness': self.calculate_sharpness(gray),
            'detail_score': self.analyze_detail_level(gray),
            'noise_level': self.estimate_noise_level(gray),
            'resolution_adequacy': self.check_resolution_adequacy(
                current_ppi, target_print_size_cm, viewing_distance_cm
            )
        }
        
        # 総合評価
        overall_quality = self.calculate_overall_quality(quality_metrics)
        
        return {
            'current_ppi': current_ppi,
            'image_dimensions': f"{width}×{height}",
            'quality_metrics': quality_metrics,
            'overall_assessment': overall_quality,
            'recommendations': self.generate_quality_recommendations(quality_metrics, current_ppi)
        }
    
    def calculate_sharpness(self, gray_image):
        """シャープネススコアの算出"""
        
        # Laplacian フィルターによるエッジ検出
        laplacian = cv2.Laplacian(gray_image, cv2.CV_64F)
        variance = laplacian.var()
        
        # 正規化スコア
        normalized_score = min(variance / 1000, 1.0)
        
        return {
            'variance': round(variance, 2),
            'normalized_score': round(normalized_score, 3),
            'assessment': 'sharp' if normalized_score > 0.3 else 'soft'
        }
    
    def analyze_detail_level(self, gray_image):
        """細部レベルの分析"""
        
        # 高周波成分の分析
        f_transform = np.fft.fft2(gray_image)
        f_shift = np.fft.fftshift(f_transform)
        magnitude_spectrum = np.log(np.abs(f_shift) + 1)
        
        # 高周波エネルギーの比率
        height, width = gray_image.shape
        center_y, center_x = height // 2, width // 2
        
        # 中心から外側の領域での高周波エネルギー
        y, x = np.ogrid[:height, :width]
        mask = ((x - center_x)**2 + (y - center_y)**2) > (min(width, height) // 4)**2
        
        high_freq_energy = np.mean(magnitude_spectrum[mask])
        total_energy = np.mean(magnitude_spectrum)
        
        detail_ratio = high_freq_energy / total_energy if total_energy > 0 else 0
        
        return {
            'detail_ratio': round(detail_ratio, 3),
            'high_freq_energy': round(high_freq_energy, 2),
            'assessment': 'detailed' if detail_ratio > 0.7 else 'smooth'
        }
    
    def estimate_noise_level(self, gray_image):
        """ノイズレベルの推定"""
        
        # ガウシアンフィルターとの差分でノイズを推定
        smooth = cv2.GaussianBlur(gray_image, (5, 5), 0)
        noise = cv2.absdiff(gray_image, smooth)
        
        noise_std = np.std(noise)
        noise_mean = np.mean(noise)
        
        # 正規化ノイズレベル
        normalized_noise = min(noise_std / 20, 1.0)
        
        return {
            'std_deviation': round(noise_std, 2),
            'mean_difference': round(noise_mean, 2),
            'normalized_level': round(normalized_noise, 3),
            'assessment': 'noisy' if normalized_noise > 0.3 else 'clean'
        }
    
    def check_resolution_adequacy(self, current_ppi, print_size_cm, viewing_distance_cm):
        """解像度適正性の評価"""
        
        # 必要解像度の計算
        calc = PrintResolutionCalculator()
        required = calc.calculate_minimum_resolution(viewing_distance_cm)
        
        adequacy_ratio = current_ppi / required['recommended_ppi']
        
        if adequacy_ratio >= 1.0:
            status = 'adequate'
        elif adequacy_ratio >= 0.8:
            status = 'marginal'
        else:
            status = 'insufficient'
        
        return {
            'current_ppi': current_ppi,
            'required_ppi': required['recommended_ppi'],
            'adequacy_ratio': round(adequacy_ratio, 2),
            'status': status
        }
    
    def calculate_overall_quality(self, metrics):
        """総合品質評価"""
        
        # 重み付きスコア
        weights = {
            'sharpness': 0.3,
            'detail_score': 0.3,
            'resolution_adequacy': 0.3,
            'noise_level': 0.1  # ノイズは減点要素
        }
        
        scores = {
            'sharpness': metrics['sharpness']['normalized_score'],
            'detail_score': metrics['detail_score']['detail_ratio'],
            'resolution_adequacy': min(metrics['resolution_adequacy']['adequacy_ratio'], 1.0),
            'noise_level': 1.0 - metrics['noise_level']['normalized_level']  # ノイズは逆転
        }
        
        weighted_score = sum(scores[key] * weights[key] for key in weights.keys())
        
        if weighted_score >= 0.8:
            grade = 'excellent'
        elif weighted_score >= 0.6:
            grade = 'good'
        elif weighted_score >= 0.4:
            grade = 'fair'
        else:
            grade = 'poor'
        
        return {
            'weighted_score': round(weighted_score, 2),
            'grade': grade,
            'component_scores': scores
        }
    
    def generate_quality_recommendations(self, metrics, current_ppi):
        """品質改善の推奨事項"""
        
        recommendations = []
        
        # シャープネス関連
        if metrics['sharpness']['normalized_score'] < 0.3:
            recommendations.append({
                'issue': 'low_sharpness',
                'description': '画像のシャープネスが不足',
                'solution': 'アンシャープマスクまたは高解像度での再スキャン'
            })
        
        # 解像度関連
        if metrics['resolution_adequacy']['status'] == 'insufficient':
            target_ppi = metrics['resolution_adequacy']['required_ppi']
            recommendations.append({
                'issue': 'insufficient_resolution',
                'description': f'解像度不足（現在{current_ppi}、必要{target_ppi}）',
                'solution': 'より高解像度での画像取得またはAI超解像処理'
            })
        
        # ノイズ関連
        if metrics['noise_level']['normalized_level'] > 0.4:
            recommendations.append({
                'issue': 'excessive_noise',
                'description': 'ノイズレベルが高い',
                'solution': 'ノイズ除去フィルターまたは撮影条件の改善'
            })
        
        return recommendations

# 実使用例
validator = ResolutionQualityValidator()

# 画像の品質検証
image_path = "sample_image.jpg"
target_size = (21, 29.7)  # A4サイズ（cm）
viewing_distance = 40     # 40cm

try:
    quality_report = validator.analyze_image_quality(
        image_path, target_size, viewing_distance
    )
    
    print("=== 画像品質検証レポート ===")
    print(f"現在の解像度: {quality_report['current_ppi']} PPI")
    print(f"画像サイズ: {quality_report['image_dimensions']}")
    print(f"総合評価: {quality_report['overall_assessment']['grade'].upper()}")
    print(f"総合スコア: {quality_report['overall_assessment']['weighted_score']}")
    
    if quality_report['recommendations']:
        print("\n=== 改善推奨事項 ===")
        for rec in quality_report['recommendations']:
            print(f"問題: {rec['description']}")
            print(f"解決策: {rec['solution']}\n")
    
except Exception as e:
    print(f"検証エラー: {e}")

// 印刷用途向け画像変換パイプライン
class PrintOptimizedConverter {
  async convertForPrint(inputFile, printSpecs) {
    const { targetPPI, printSize, colorSpace, outputFormat } = printSpecs;
    
    // 1. 解像度調整
    const resizedImage = await this.adjustResolution(inputFile, targetPPI, printSize);
    
    // 2. 色空間変換
    const colorCorrected = await this.convertColorSpace(resizedImage, colorSpace);
    
    // 3. シャープネス最適化
    const sharpened = await this.optimizeSharpness(colorCorrected, targetPPI);
    
    // 4. 出力形式での保存
    return await this.saveWithMetadata(sharpened, outputFormat, printSpecs);
  }
}