test_scripts/SuperResolution_02/test_script.py

import argparse
import numpy as np
from PIL import Image
import json
import os
from datetime import datetime
from scipy.ndimage import sobel
from skimage.metrics import structural_similarity as ssim
from skimage.metrics import peak_signal_noise_ratio as psnr


def compute_edge_intensity(img_array):
    """
    Calculate edge intensity (Sobel gradient) of an image.

    Args:
        img_array (np.ndarray): Input image (RGB or grayscale)

    Returns:
        np.ndarray: Edge intensity map
    """
    # Convert to grayscale
    if len(img_array.shape) == 3:
        gray = np.mean(img_array, axis=2).astype(np.float32)
    else:
        gray = img_array.astype(np.float32)

    # Calculate Sobel gradient
    grad_x = sobel(gray, axis=1)
    grad_y = sobel(gray, axis=0)
    edge_intensity = np.sqrt(grad_x ** 2 + grad_y ** 2)
    return edge_intensity


def evaluate_super_resolution(input_path, output_path):
    """
    Evaluate super-resolution quality without pretrained model.

    Args:
        input_path (str): Path to input low-resolution image
        output_path (str): Path to output super-resolution image

    Returns:
        dict: Evaluation results containing PSNR, ESI, SSIM and success status
    """
    # Load images
    input_img = Image.open(input_path).convert('RGB')
    output_img = Image.open(output_path).convert('RGB')

    # Convert to numpy arrays
    input_array = np.array(input_img)
    output_array = np.array(output_img)

    # Check resolution (expect output to be 2x input)
    input_h, input_w = input_array.shape[:2]
    output_h, output_w = output_array.shape[:2]
    if output_h != 2 * input_h or output_w != 2 * input_w:
        return {
            'PSNR': 0.0,
            'PSNR Threshold': 20.0,
            'ESI (Edge Strength Improvement)': 0.0,
            'ESI Threshold': 1.2,
            'SSIM': 0.0,
            'SSIM Threshold': 0.8,
            'Success': False,
            'Error': f"Output resolution ({output_w}x{output_h}) is not 2x input ({input_w}x{input_h})"
        }

    # Upsample input image to output resolution (bilinear interpolation) as pseudo-reference
    upsampled_img = input_img.resize((output_w, output_h), Image.BILINEAR)
    upsampled_array = np.array(upsampled_img)

    # Calculate PSNR
    psnr_value = psnr(upsampled_array, output_array, data_range=255)

    # Calculate edge intensity
    input_edge = compute_edge_intensity(upsampled_array)
    output_edge = compute_edge_intensity(output_array)

    # Save edge intensity maps for debugging
    input_edge_img = Image.fromarray((input_edge / input_edge.max() * 255).astype(np.uint8))
    output_edge_img = Image.fromarray((output_edge / output_edge.max() * 255).astype(np.uint8))
    input_edge_img.save('input_edge.png')
    output_edge_img.save('output_edge.png')

    # Calculate ESI (Edge Strength Improvement)
    input_edge_mean = np.mean(input_edge)
    output_edge_mean = np.mean(output_edge)
    esi = output_edge_mean / (input_edge_mean + 1e-10)  # Avoid division by zero

    # —— Modified SSIM calculation section start ——
    h, w = output_array.shape[:2]
    min_side = min(h, w)
    win = min(7, min_side)
    if win % 2 == 0:
        win -= 1
    win = max(win, 3)
    try:
        ssim_value = ssim(
            upsampled_array,
            output_array,
            data_range=255,
            win_size=win,
            channel_axis=-1
        )
    except ValueError:
        ssim_value = ssim(
            upsampled_array,
            output_array,
            data_range=255,
            channel_axis=-1
        )
    # —— Modified SSIM calculation section end ——

    # Determine task success
    psnr_threshold = 18.0  # PSNR threshold
    esi_threshold = 1.2  # ESI threshold (20% edge strength improvement)
    ssim_threshold = 0.8  # SSIM threshold
    success = psnr_value >= psnr_threshold and esi >= esi_threshold and ssim_value >= ssim_threshold

    # Return results
    return {
        'PSNR': psnr_value,
        'PSNR Threshold': psnr_threshold,
        'ESI (Edge Strength Improvement)': esi,
        'ESI Threshold': esi_threshold,
        'SSIM': ssim_value,
        'SSIM Threshold': ssim_threshold,
        'Success': success
    }


def validate_inputs(input_path, output_path):
    """
    Validate input files exist, are non-empty, and have correct format.

    Returns:
        tuple: (bool, str) - (is valid, error message or empty string)
    """
    try:
        # Check file existence
        if not os.path.exists(input_path):
            return False, f"Input file {input_path} does not exist."
        if not os.path.exists(output_path):
            return False, f"Output file {output_path} does not exist."

        # Check files are non-empty
        if os.path.getsize(input_path) == 0:
            return False, f"Input file {input_path} is empty."
        if os.path.getsize(output_path) == 0:
            return False, f"Output file {output_path} is empty."

        # Check file format (try to open images)
        try:
            with Image.open(input_path) as img:
                img.verify()  # Verify image format
            with Image.open(output_path) as img:
                img.verify()
        except Exception as e:
            return False, f"Invalid image format: {str(e)}"

        return True, ""
    except Exception as e:
        return False, f"Validation error: {str(e)}"


def save_result_to_jsonl(result_path, process, result, comments):
    """
    Save results to JSONL file.

    Args:
        result_path (str): JSONL file path
        process (bool/numpy.bool_): Whether input parameters are valid
        result (bool/numpy.bool_): Whether evaluation succeeded
        comments (str): Additional information
    """
    time_point = datetime.now().strftime("%Y-%m-%dT%H:%M:%S")

    record = {
        "Process": bool(process),  # Convert to Python bool
        "Result": bool(result),  # Convert to Python bool
        "TimePoint": time_point,
        "comments": comments
    }

    try:
        with open(result_path, 'a', encoding='utf-8') as f:
            json_line = json.dumps(record, ensure_ascii=False)
            f.write(json_line + '\n')
    except Exception as e:
        print(f"Failed to save result to {result_path}: {str(e)}")


def main():
    parser = argparse.ArgumentParser(description='Evaluate super-resolution quality without pretrained model.')
    parser.add_argument('--groundtruth', type=str, required=True, help='Path to input low-resolution image')
    parser.add_argument('--output', type=str, required=True, help='Path to output super-resolution image')
    parser.add_argument('--result', type=str, help='Path to JSONL file to save results')

    args = parser.parse_args()

    # Validate input parameters
    process, comments = validate_inputs(args.groundtruth, args.output)

    # Initialize results
    result_dict = {}
    success = False

    # Run evaluation if inputs are valid
    if process:
        try:
            result_dict = evaluate_super_resolution(args.groundtruth, args.output)
            success = result_dict.get('Success', False)
            if 'Error' in result_dict:
                comments = result_dict['Error']
                success = False
            else:
                comments = (
                    f"PSNR: {result_dict['PSNR']:.3f} "
                    f"(Threshold: {result_dict['PSNR Threshold']}), "
                    f"ESI: {result_dict['ESI (Edge Strength Improvement)']:.3f} "
                    f"(Threshold: {result_dict['ESI Threshold']}), "
                    f"SSIM: {result_dict['SSIM']:.3f} "
                    f"(Threshold: {result_dict['SSIM Threshold']}), "
                    f"Success: {success}"
                )
                if not success:
                    comments += ". Possible issues: Low PSNR (poor pixel similarity), low ESI (insufficient edge enhancement), or low SSIM (structural distortion)."
        except Exception as e:
            process = False
            success = False
            comments = f"Evaluation failed: {str(e)}"
    else:
        success = False

    # Print results
    print('Evaluation Results:')
    if process and 'Error' not in result_dict:
        for key, value in result_dict.items():
            if key != 'Error':
                print(f'{key}: {value}')
    else:
        print(f'Error: {comments}')

    # Save results to JSONL (if --result provided)
    if args.result:
        save_result_to_jsonl(args.result, process, success, comments)


if __name__ == '__main__':
    main()