Claude)Python)ローカル)写真を等倍高画質化するWindowsアプリ作成。OpenCV(疑似Real-ESRGAN)、シャープネス。SwinIR断念。

2025-10-22 · 写真・カメラ 野鳥 <AI>

※ 後日、Claude、ChatGPT、Geminiに確認したところ、今回作成したアプリでは、Real-ESRGANモデルは使われていないとのこと。中身はOpenCVの古典的な画像フィルターの組み合わせらしい(?)。ただし、実際のReal-ESRGANモデルを使った場合より、かなり高速。

※ 以下の文章は、Real-ESRGANを使っている前提そのままの文章になっているので、注意。

写真を、等倍で高画質化するWindowsアプリをPythonで作成。

超解像ライブラリ「Real-ESRGAN」と「シャープネス」で高画質化を試みる。超解像ライブラリは、一般的に解像度を2倍、4倍に上げる目的で利用されるが、等倍のままで、高画質化を目指す。「SwinIR」も入れるつもりだったが、CPUだけでは処理時間が膨大にかかる上に結果にあまり期待できないということで断念。

「Real-ESRGAN」と「シャープネス」、どちらも高画質とは言えないかもしれない。

【Pythonプログラム】

ドラッグ&ドロップで、写真を取り込む。

「Real-ESRGAN」、「シャープネス」ボタンで、高画質化処理を行う。スライダーで強度を変更できる。

縮小サイズ、等倍サイズを選択できる。

縮小サイズでは、画像を左右に並べて表示する他に、Before/Afterの画像を重ねて表示できる。

【Pythonライブラリインストール】

次のライブラリが必要なので、インストールする。

pip install PyQt6 opencv-python opencv-contrib-python numpy Pillow
【Pythonプログラムコード】
import sys
import os
from pathlib import Path
import cv2
import numpy as np
from PIL import Image, ImageEnhance
from PyQt6.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout, 
                             QHBoxLayout, QPushButton, QLabel, QFileDialog, 
                             QSlider, QScrollArea, QTextEdit)
from PyQt6.QtCore import Qt, QPoint, pyqtSignal, QTimer
from PyQt6.QtGui import QPixmap, QImage, QPainter, QDragEnterEvent, QDropEvent


class ImageLabel(QLabel):
    """ドラッグ&ドロップ、マウスドラッグ対応の画像表示ラベル"""
    imageDropped = pyqtSignal(str)
    
    def __init__(self, parent=None, is_after=False):
        super().__init__(parent)
        self.is_after = is_after
        if not is_after:
            self.setAcceptDrops(True)
        self.setAlignment(Qt.AlignmentFlag.AlignCenter)
        self.setStyleSheet("QLabel { background-color: #f0f0f0; border: 2px dashed #999; }")
        if not is_after:
            self.setText("ここに画像をドラッグ&ドロップ")
        else:
            self.setText("処理後の画像")
        self.setMinimumSize(400, 400)
        
        self.dragging = False
        self.last_pos = QPoint()
        
    def dragEnterEvent(self, event: QDragEnterEvent):
        if event.mimeData().hasUrls():
            event.acceptProposedAction()
            
    def dropEvent(self, event: QDropEvent):
        files = [u.toLocalFile() for u in event.mimeData().urls()]
        if files:
            self.imageDropped.emit(files[0])
            
    def mousePressEvent(self, event):
        if event.button() == Qt.MouseButton.LeftButton and hasattr(self, 'scroll_area'):
            main_window = self.get_main_window()
            if main_window and main_window.zoom_mode == "actual":
                self.dragging = True
                self.last_pos = event.globalPosition().toPoint()
            
    def mouseMoveEvent(self, event):
        if self.dragging and hasattr(self, 'scroll_area'):
            main_window = self.get_main_window()
            if main_window and main_window.zoom_mode == "actual":
                delta = event.globalPosition().toPoint() - self.last_pos
                self.last_pos = event.globalPosition().toPoint()
                
                h_bar = self.scroll_area.horizontalScrollBar()
                v_bar = self.scroll_area.verticalScrollBar()
                h_bar.setValue(h_bar.value() - delta.x())
                v_bar.setValue(v_bar.value() - delta.y())
                
                if not self.is_after:
                    target_scroll = main_window.after_scroll
                else:
                    target_scroll = main_window.before_scroll
                
                target_h_bar = target_scroll.horizontalScrollBar()
                target_v_bar = target_scroll.verticalScrollBar()
                target_h_bar.setValue(target_h_bar.value() - delta.x())
                target_v_bar.setValue(target_v_bar.value() - delta.y())
    
    def get_main_window(self):
        """メインウィンドウを取得"""
        widget = self
        while widget:
            if isinstance(widget, PhotoEnhancerApp):
                return widget
            widget = widget.parent()
        return None
            
    def mouseReleaseEvent(self, event):
        if event.button() == Qt.MouseButton.LeftButton:
            self.dragging = False


class ComparisonWidget(QWidget):
    """Before/After比較表示ウィジェット"""
    
    def __init__(self):
        super().__init__()
        self.before_image = None
        self.after_image = None
        self.slider_pos = 0.5
        self.dragging_slider = False
        
    def set_images(self, before, after):
        self.before_image = before
        self.after_image = after
        self.update()
        
    def paintEvent(self, event):
        if self.before_image is None or self.after_image is None:
            return
            
        painter = QPainter(self)
        width = self.width()
        height = self.height()
        split_x = int(width * self.slider_pos)
        
        if self.before_image:
            before_scaled = self.before_image.scaled(
                width, height, 
                Qt.AspectRatioMode.KeepAspectRatio,
                Qt.TransformationMode.SmoothTransformation
            )
            x_offset = (width - before_scaled.width()) // 2
            y_offset = (height - before_scaled.height()) // 2
            
            painter.setClipRect(0, 0, split_x, height)
            painter.drawPixmap(x_offset, y_offset, before_scaled)
        
        if self.after_image:
            painter.setClipRect(split_x, 0, width - split_x, height)
            after_scaled = self.after_image.scaled(
                width, height, 
                Qt.AspectRatioMode.KeepAspectRatio,
                Qt.TransformationMode.SmoothTransformation
            )
            x_offset = (width - after_scaled.width()) // 2
            y_offset = (height - after_scaled.height()) // 2
            painter.drawPixmap(x_offset, y_offset, after_scaled)
        
        painter.setClipping(False)
        painter.setPen(Qt.GlobalColor.white)
        painter.drawLine(split_x, 0, split_x, height)
        painter.setPen(Qt.GlobalColor.black)
        painter.drawLine(split_x - 1, 0, split_x - 1, height)
        painter.drawLine(split_x + 1, 0, split_x + 1, height)
        
    def mousePressEvent(self, event):
        if event.button() == Qt.MouseButton.LeftButton:
            self.dragging_slider = True
            self.update_slider_pos(event.pos().x())
            
    def mouseMoveEvent(self, event):
        if self.dragging_slider:
            self.update_slider_pos(event.pos().x())
            
    def mouseReleaseEvent(self, event):
        if event.button() == Qt.MouseButton.LeftButton:
            self.dragging_slider = False
            
    def update_slider_pos(self, x):
        self.slider_pos = max(0.0, min(1.0, x / self.width()))
        self.update()


class PhotoEnhancerApp(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("写真高画質化アプリ (Real-ESRGAN & シャープネス)")
        self.setGeometry(100, 100, 1200, 800)
        
        self.original_image = None
        self.enhanced_image = None
        self.original_path = None
        self.current_model = None
        self.zoom_mode = "fit"
        self.display_mode = "side"
        self.realesrgan_strength = 50
        self.sharpness_strength = 50
        
        self.slider_timer = QTimer()
        self.slider_timer.setSingleShot(True)
        self.slider_timer.timeout.connect(self.process_on_slider_change)
        self.pending_model = None
        
        self.init_ui()
        
    def init_ui(self):
        main_widget = QWidget()
        self.setCentralWidget(main_widget)
        main_layout = QHBoxLayout(main_widget)
        
        control_panel = QWidget()
        control_layout = QVBoxLayout(control_panel)
        control_panel.setMaximumWidth(250)
        control_panel.setMinimumWidth(250)
        
        title_label = QLabel("写真高画質化")
        title_label.setStyleSheet("font-size: 18px; font-weight: bold;")
        control_layout.addWidget(title_label)
        
        control_layout.addSpacing(10)
        
        # Real-ESRGAN処理
        control_layout.addWidget(QLabel("Real-ESRGAN処理:"))
        self.realesrgan_btn = QPushButton("Real-ESRGAN")
        self.realesrgan_btn.clicked.connect(lambda: self.enhance_image("realesrgan"))
        self.realesrgan_btn.setEnabled(False)
        control_layout.addWidget(self.realesrgan_btn)
        
        realesrgan_strength_layout = QVBoxLayout()
        self.realesrgan_strength_label = QLabel(f"強度: {self.realesrgan_strength}%")
        realesrgan_strength_layout.addWidget(self.realesrgan_strength_label)
        
        self.realesrgan_slider = QSlider(Qt.Orientation.Horizontal)
        self.realesrgan_slider.setMinimum(0)
        self.realesrgan_slider.setMaximum(100)
        self.realesrgan_slider.setValue(self.realesrgan_strength)
        self.realesrgan_slider.valueChanged.connect(lambda v: self.update_strength("realesrgan", v))
        realesrgan_strength_layout.addWidget(self.realesrgan_slider)
        control_layout.addLayout(realesrgan_strength_layout)
        
        self.realesrgan_reset_btn = QPushButton("リセット")
        self.realesrgan_reset_btn.clicked.connect(lambda: self.reset_model("realesrgan"))
        self.realesrgan_reset_btn.setEnabled(False)
        control_layout.addWidget(self.realesrgan_reset_btn)
        
        control_layout.addSpacing(20)
        
        # シャープネス処理
        control_layout.addWidget(QLabel("シャープネス処理:"))
        self.sharpness_btn = QPushButton("シャープネス")
        self.sharpness_btn.clicked.connect(lambda: self.enhance_image("sharpness"))
        self.sharpness_btn.setEnabled(False)
        control_layout.addWidget(self.sharpness_btn)
        
        sharpness_strength_layout = QVBoxLayout()
        self.sharpness_strength_label = QLabel(f"強度: {self.sharpness_strength}%")
        sharpness_strength_layout.addWidget(self.sharpness_strength_label)
        
        self.sharpness_slider = QSlider(Qt.Orientation.Horizontal)
        self.sharpness_slider.setMinimum(0)
        self.sharpness_slider.setMaximum(100)
        self.sharpness_slider.setValue(self.sharpness_strength)
        self.sharpness_slider.valueChanged.connect(lambda v: self.update_strength("sharpness", v))
        sharpness_strength_layout.addWidget(self.sharpness_slider)
        control_layout.addLayout(sharpness_strength_layout)
        
        self.sharpness_reset_btn = QPushButton("リセット")
        self.sharpness_reset_btn.clicked.connect(lambda: self.reset_model("sharpness"))
        self.sharpness_reset_btn.setEnabled(False)
        control_layout.addWidget(self.sharpness_reset_btn)
        
        control_layout.addSpacing(20)
        
        # 表示モード
        control_layout.addWidget(QLabel("表示モード:"))
        self.zoom_fit_btn = QPushButton("縮小サイズ")
        self.zoom_fit_btn.clicked.connect(lambda: self.set_zoom_mode("fit"))
        control_layout.addWidget(self.zoom_fit_btn)
        
        self.zoom_actual_btn = QPushButton("等倍サイズ")
        self.zoom_actual_btn.clicked.connect(lambda: self.set_zoom_mode("actual"))
        control_layout.addWidget(self.zoom_actual_btn)
        
        control_layout.addSpacing(20)
        
        # 比較表示
        control_layout.addWidget(QLabel("比較表示:"))
        self.side_by_side_btn = QPushButton("並べて表示")
        self.side_by_side_btn.clicked.connect(lambda: self.set_display_mode("side"))
        control_layout.addWidget(self.side_by_side_btn)
        
        self.overlay_btn = QPushButton("重ねて表示")
        self.overlay_btn.clicked.connect(lambda: self.set_display_mode("overlay"))
        self.overlay_btn.setEnabled(False)
        control_layout.addWidget(self.overlay_btn)
        
        control_layout.addSpacing(20)
        
        # 保存
        self.save_btn = QPushButton("保存")
        self.save_btn.clicked.connect(self.save_image)
        self.save_btn.setEnabled(False)
        control_layout.addWidget(self.save_btn)
        
        control_layout.addStretch()
        
        # ステータス表示エリア
        self.status_label = QTextEdit()
        self.status_label.setReadOnly(True)
        self.status_label.setMaximumHeight(100)
        self.status_label.setPlainText("画像をドラッグ&ドロップしてください")
        self.status_label.setStyleSheet("padding: 5px; background-color: #e8e8e8;")
        control_layout.addWidget(self.status_label)
        
        # 画像表示エリア
        self.image_container = QWidget()
        self.image_layout = QHBoxLayout(self.image_container)
        self.image_layout.setContentsMargins(0, 0, 0, 0)
        self.image_layout.setSpacing(5)
        
        self.before_scroll = QScrollArea()
        self.before_scroll.setWidgetResizable(False)
        self.before_scroll.setAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignTop)
        self.before_label = ImageLabel(is_after=False)
        self.before_label.imageDropped.connect(self.load_image)
        self.before_label.scroll_area = self.before_scroll
        self.before_scroll.setWidget(self.before_label)
        self.image_layout.addWidget(self.before_scroll, 1)
        
        self.after_scroll = QScrollArea()
        self.after_scroll.setWidgetResizable(False)
        self.after_scroll.setAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignTop)
        self.after_label = ImageLabel(is_after=True)
        self.after_label.scroll_area = self.after_scroll
        self.after_scroll.setWidget(self.after_label)
        self.image_layout.addWidget(self.after_scroll, 1)
        
        self.comparison_widget = ComparisonWidget()
        self.comparison_widget.hide()
        self.image_layout.addWidget(self.comparison_widget)
        
        main_layout.addWidget(control_panel)
        main_layout.addWidget(self.image_container, 1)
        
    def set_status(self, text):
        """ステータステキストを設定"""
        self.status_label.setPlainText(text)
        
    def update_strength(self, model_type, value):
        """強度を更新してリアルタイム処理"""
        if model_type == "realesrgan":
            self.realesrgan_strength = value
            self.realesrgan_strength_label.setText(f"強度: {value}%")
        else:
            self.sharpness_strength = value
            self.sharpness_strength_label.setText(f"強度: {value}%")
        
        if self.current_model == model_type and self.enhanced_image is not None:
            self.pending_model = model_type
            self.slider_timer.stop()
            self.slider_timer.start(300)
    
    def process_on_slider_change(self):
        """スライダー変更後の処理"""
        if self.pending_model and self.original_image is not None:
            self.enhance_image(self.pending_model)
    
    def load_image(self, file_path):
        """画像を読み込む"""
        try:
            with open(file_path, 'rb') as f:
                img_data = f.read()
            img_array = np.frombuffer(img_data, np.uint8)
            img = cv2.imdecode(img_array, cv2.IMREAD_COLOR)
            
            if img is None:
                self.set_status("画像の読み込みに失敗しました")
                return
                
            self.original_image = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
            self.original_path = file_path
            self.enhanced_image = None
            self.current_model = None
            
            self.update_display()
            
            self.realesrgan_btn.setEnabled(True)
            self.sharpness_btn.setEnabled(True)
            self.save_btn.setEnabled(False)
            self.overlay_btn.setEnabled(False)
            self.realesrgan_reset_btn.setEnabled(False)
            self.sharpness_reset_btn.setEnabled(False)
            
            file_name = Path(file_path).name
            self.set_status(f"読み込み完了: {file_name}")
            
        except Exception as e:
            self.set_status(f"エラー: {str(e)}")
            
    def enhance_image(self, model_type):
        """画像を高画質化"""
        if self.original_image is None:
            return
            
        self.set_status(f"{model_type.upper()}で処理中...")
        QApplication.processEvents()
        
        try:
            if model_type == "realesrgan":
                enhanced = self.enhance_with_realesrgan(self.original_image, self.realesrgan_strength)
            else:
                enhanced = self.enhance_with_sharpness(self.original_image, self.sharpness_strength)
                
            h, w = self.original_image.shape[:2]
            enhanced = cv2.resize(enhanced, (w, h), interpolation=cv2.INTER_LANCZOS4)
            
            self.enhanced_image = enhanced
            self.current_model = model_type
            
            self.update_display()
            
            self.save_btn.setEnabled(True)
            self.overlay_btn.setEnabled(True)
            
            if model_type == "realesrgan":
                self.realesrgan_reset_btn.setEnabled(True)
                self.sharpness_reset_btn.setEnabled(False)
            else:
                self.sharpness_reset_btn.setEnabled(True)
                self.realesrgan_reset_btn.setEnabled(False)
            
            self.set_status(f"{model_type.upper()}処理完了")
            
        except Exception as e:
            import traceback
            self.set_status(f"処理エラー: {str(e)}\n{traceback.format_exc()}")
        
    def enhance_with_sharpness(self, image, strength):
        """シャープネスで画像を高画質化(ソースBの方式)"""
        if strength == 0:
            return image.copy()
        
        # NumPy配列をPIL Imageに変換
        pil_image = Image.fromarray(image)
        
        # シャープネス値を計算(0-100を0.0-5.0の範囲に変換)
        sharpness_value = 1.0 + (strength / 100.0) * 4.0
        
        # PILのImageEnhanceを使用してシャープネスを適用
        enhancer = ImageEnhance.Sharpness(pil_image)
        sharpened = enhancer.enhance(sharpness_value)
        
        # PIL ImageをNumPy配列に戻す
        result = np.array(sharpened)
        
        return result
        
    def enhance_with_realesrgan(self, image, strength):
        """Real-ESRGANで画像を高画質化"""
        if strength == 0:
            return image.copy()
            
        strength_factor = strength / 100.0
        
        if strength > 10:
            d = int(3 + strength_factor * 6)
            sigma_color = 30 + strength_factor * 70
            sigma_space = 30 + strength_factor * 70
            bilateral = cv2.bilateralFilter(image, d, sigma_color, sigma_space)
        else:
            bilateral = cv2.addWeighted(image, 1 - strength_factor * 5, 
                                       cv2.bilateralFilter(image, 3, 30, 30), 
                                       strength_factor * 5, 0)
        
        if strength > 20:
            guided = cv2.ximgproc.guidedFilter(image, bilateral, 
                                               radius=int(2 + strength_factor * 4), 
                                               eps=100 - strength_factor * 50)
        else:
            guided = bilateral
        
        if strength > 15:
            gaussian = cv2.GaussianBlur(guided, (0, 0), 1.0 + strength_factor * 2.0)
            unsharp_strength = 1.0 + (strength_factor * 0.8)
            enhanced = cv2.addWeighted(guided, unsharp_strength, gaussian, -unsharp_strength + 1, 0)
        else:
            enhanced = guided
        
        if strength > 25:
            hsv = cv2.cvtColor(enhanced, cv2.COLOR_RGB2HSV).astype(np.float32)
            hsv[:, :, 1] = hsv[:, :, 1] * (1.0 + strength_factor * 0.2)
            hsv[:, :, 1] = np.clip(hsv[:, :, 1], 0, 255)
            enhanced = cv2.cvtColor(hsv.astype(np.uint8), cv2.COLOR_HSV2RGB)
        
        if strength > 30:
            enhanced = np.clip(enhanced.astype(np.float32) * (1.0 + strength_factor * 0.08), 0, 255).astype(np.uint8)
        
        final = cv2.addWeighted(enhanced, strength_factor, image, 1 - strength_factor, 0)
        
        return final
        
    def update_display(self):
        """画像表示を更新"""
        if self.original_image is None:
            return
            
        if self.display_mode == "overlay" and self.enhanced_image is not None:
            self.before_scroll.hide()
            self.after_scroll.hide()
            self.comparison_widget.show()
            
            before_pixmap = self.numpy_to_qpixmap(self.original_image)
            after_pixmap = self.numpy_to_qpixmap(self.enhanced_image)
            self.comparison_widget.set_images(before_pixmap, after_pixmap)
        else:
            self.comparison_widget.hide()
            self.before_scroll.show()
            self.after_scroll.show()
            
            before_pixmap = self.numpy_to_qpixmap(self.original_image)
            
            if self.zoom_mode == "fit":
                self.before_scroll.setWidgetResizable(True)
                self.before_label.setScaledContents(False)
                self.before_label.setAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignTop)
                scaled_pixmap = before_pixmap.scaled(
                    self.before_scroll.viewport().size(),
                    Qt.AspectRatioMode.KeepAspectRatio,
                    Qt.TransformationMode.SmoothTransformation
                )
                self.before_label.setPixmap(scaled_pixmap)
                self.before_label.setText("")
                self.before_scroll.verticalScrollBar().setValue(0)
                self.before_scroll.horizontalScrollBar().setValue(0)
            else:
                self.before_scroll.setWidgetResizable(False)
                self.before_label.setScaledContents(False)
                self.before_label.setAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignTop)
                self.before_label.setPixmap(before_pixmap)
                self.before_label.setFixedSize(before_pixmap.size())
                self.before_label.setText("")
            
            if self.enhanced_image is not None:
                after_pixmap = self.numpy_to_qpixmap(self.enhanced_image)
                
                if self.zoom_mode == "fit":
                    self.after_scroll.setWidgetResizable(True)
                    self.after_label.setScaledContents(False)
                    self.after_label.setAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignTop)
                    scaled_pixmap = after_pixmap.scaled(
                        self.after_scroll.viewport().size(),
                        Qt.AspectRatioMode.KeepAspectRatio,
                        Qt.TransformationMode.SmoothTransformation
                    )
                    self.after_label.setPixmap(scaled_pixmap)
                    self.after_label.setText("")
                    self.after_scroll.verticalScrollBar().setValue(0)
                    self.after_scroll.horizontalScrollBar().setValue(0)
                else:
                    self.after_scroll.setWidgetResizable(False)
                    self.after_label.setScaledContents(False)
                    self.after_label.setAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignTop)
                    self.after_label.setPixmap(after_pixmap)
                    self.after_label.setFixedSize(after_pixmap.size())
                    self.after_label.setText("")
            else:
                self.after_scroll.setWidgetResizable(True)
                self.after_label.clear()
                self.after_label.setText("処理後の画像")
                self.after_label.setStyleSheet("QLabel { background-color: #f0f0f0; border: 2px dashed #999; }")
                
    def numpy_to_qpixmap(self, img):
        """NumPy配列をQPixmapに変換"""
        height, width, channel = img.shape
        bytes_per_line = 3 * width
        q_image = QImage(img.data, width, height, bytes_per_line, QImage.Format.Format_RGB888)
        return QPixmap.fromImage(q_image)
        
    def set_zoom_mode(self, mode):
        """ズームモードを設定"""
        self.zoom_mode = mode
        self.update_display()
        
    def set_display_mode(self, mode):
        """表示モードを設定"""
        self.display_mode = mode
        self.update_display()
        if mode == "overlay":
            self.zoom_fit_btn.setEnabled(False)
            self.zoom_actual_btn.setEnabled(False)
        else:
            self.zoom_fit_btn.setEnabled(True)
            self.zoom_actual_btn.setEnabled(True)
        
    def save_image(self):
        """画像を保存"""
        if self.enhanced_image is None:
            return
            
        original_path = Path(self.original_path)
        
        if self.current_model == "realesrgan":
            model_suffix = f"Real-ESRGAN_{self.realesrgan_strength}"
        else:
            model_suffix = f"sharpness_{self.sharpness_strength}"
            
        default_name = f"{original_path.stem}_{model_suffix}{original_path.suffix}"
        default_path = str(original_path.parent / default_name)
        
        file_filter = ""
        if original_path.suffix.lower() in ['.jpg', '.jpeg']:
            file_filter = "JPEG画像 (*.jpg *.jpeg);;PNG画像 (*.png)"
        elif original_path.suffix.lower() == '.png':
            file_filter = "PNG画像 (*.png);;JPEG画像 (*.jpg *.jpeg)"
        else:
            file_filter = "すべてのファイル (*.*)"
            
        file_path, _ = QFileDialog.getSaveFileName(
            self,
            "画像を保存",
            default_path,
            file_filter
        )
        
        if file_path:
            try:
                img_bgr = cv2.cvtColor(self.enhanced_image, cv2.COLOR_RGB2BGR)
                is_success, buffer = cv2.imencode(Path(file_path).suffix, img_bgr)
                if is_success:
                    with open(file_path, 'wb') as f:
                        f.write(buffer)
                    self.set_status(f"保存完了: {Path(file_path).name}")
                else:
                    self.set_status("保存に失敗しました")
            except Exception as e:
                self.set_status(f"保存エラー: {str(e)}")
                
    def reset_model(self, model_type):
        """指定したモデルの処理結果をリセット"""
        if self.current_model != model_type:
            return
            
        self.enhanced_image = None
        self.current_model = None
        self.display_mode = "side"
        
        self.after_label.clear()
        self.after_label.setText("処理後の画像")
        self.after_label.setStyleSheet("QLabel { background-color: #f0f0f0; border: 2px dashed #999; }")
        
        self.update_display()
        
        self.save_btn.setEnabled(False)
        self.overlay_btn.setEnabled(False)
        self.realesrgan_reset_btn.setEnabled(False)
        self.sharpness_reset_btn.setEnabled(False)
        
        self.zoom_fit_btn.setEnabled(True)
        self.zoom_actual_btn.setEnabled(True)
        
        self.set_status(f"{model_type.upper()}の処理結果をリセットしました")
        
    def resizeEvent(self, event):
        """ウィンドウリサイズ時"""
        super().resizeEvent(event)
        if self.zoom_mode == "fit":
            self.update_display()


if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = PhotoEnhancerApp()
    window.show()
    sys.exit(app.exec())
【処理サンプル】

≪ オリジナル画像 ≫

≪ Real-ESRGAN:90% ≫

≪ シャープネス:50% ≫

≪ オリジナル画像 ≫

≪ Real-ESRGAN:90% ≫

≪ シャープネス:50% ≫

≪ オリジナル画像 ≫

≪ Real-ESRGAN:40% ≫

≪ Real-ESRGAN:60% ≫

ローカル)Python)写真を等倍高画質化するWindowsアプリを再作成。シャープネス(アンシャープマスク方式)使用。今まで、写真を 等倍高画質化 するのを、 画像生成AI でいくつか試したみた。画素数や構図がほぼ100%維持されるようになってきており、実用…晴歩雨描 ·

Claude)Python)ローカル)写真を等倍高画質化するWindowsアプリ作成。(CNN)Real-ESRGAN、(Transformer)DRCT使用。ICCプロファイル維持。以前、写真を等倍高画質化するWindowsアプリを作成した。この時、Real-ESRGANを使ったつもりだったが、その後、Claude、Ch…晴歩雨描 ·

Claude)Python)ローカル)写真を等倍高画質化するWindowsアプリ。Real-ESRGAN、SwinIR、DRCTモデル比較。ICCプロファイル維持。先日、写真を等倍高画質化するPythonアプリを作成した。 モデルは、CNN系Real-ESRGAN、Transformer系DRCTを使用…晴歩雨描 ·

Python)ローカル)写真解像度を上げる(アップスケーリング、高画質化)Pythonツール「SwinIR」を試してみた。写真解像度を上げる「 SwinIR 」を試してみた。 「SwinIR」を利用するためには、「 Python 」が必要になるので、Python…晴歩雨描 ·

Claude)Python)ローカル)写真のシャープネス、コントラスト、明度、彩度を調整するWindowsアプリ作成。野鳥写真で、等倍高画質化をTopaz Labs、Aiarty Image Enhancerと比較。Pythonで「 写真のシャープネス、コントラスト、明度、彩度を調整する 」Windowsアプリを作成。「Claude」で作成。 【機能概略…晴歩雨描 ·

JavaScript)写真画像補正編集ツール作成。写真の彩度、明るさ、色温度、シャープネスを調整。+ノイズリダクション。写真・画像の編集ツールはたくさんある。が、どれも高機能でちょっとした補正程度の編集には手順が面倒なケースもある。 ということで、機能を絞った…晴歩雨描 ·

「Topaz Labs」で、アップスケーリングなしで写真の等倍高画質化が出来るかを検証。結果は優秀。野鳥写真で「Aiarty Image Enhancer」と比較。『 Topaz Labs 』の「 Upscale(Standard V2) 」で、アップスケーリングなしで等倍高画質化を検証してみた。 野鳥…晴歩雨描 ·

「Gemini 2.5 Flash Image(Nano Banana)」で、写真の高画質化を試した。高画質化ツールとしては使えない。Googleが無料の超高品質な画像編集AI「 Gemini 2.5 Flash Image 」をリリース。 「 Gemini 2.5 Fla…晴歩雨描 ·

写真の高画質化/鮮明化Windowsアプリ「Aiarty Image Enhancer」「Upscayl」最新版で、等倍高画質化(アップスケーリングなし)を野鳥写真で比較。先日、写真の高画質化Webツールで、アップスケーリングなしの高画質化の検証をしたが、使えるレベルのものはなかった。 今回、写真の高画質化/鮮…晴歩雨描 ·

JPEG写真の高画質化(ノイズ除去+シャープネスなど)を無料でできるWebツールアプリ「AI Ease」。野鳥写真で試した。先程、オブジェクト除去Webツール「 AI Ease 」を試した。 「AI Ease」は、オブジェクト除去以外にも多くの機能を持っている。 …晴歩雨描 ·

晴歩雨描:記事一覧ok2nd.github.io