compute L2

import argparse
import glob
import os
import cv2
import numpy as np


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('--pred_path', default="")
    parser.add_argument('--real_path', default="")
    args = parser.parse_args()
    
    pred_path = args.pred_path
    real_path = args.real_path
    
    pred_img_lists = sorted(glob.glob(os.path.join(pred_path,"*.png")))
    real_img_lists = sorted(glob.glob(os.path.join(real_path,"*.png")))
    
    # l2 = np.sum(np.power((actual_value-predicted_value),2))
    # print(l2)
    
    assert len(pred_img_lists)==len(real_img_lists)
    
    l2_rgb = 0
    l2_g = 0
    
    for i,img in enumerate(pred_img_lists):
        pred = cv2.imread(img)
        gray_pred = cv2.cvtColor(pred, cv2.COLOR_BGR2GRAY)
        
        gt = cv2.imread(real_img_lists[i])
        gt = cv2.resize(gt,(256,256))
        gt_gray = cv2.cvtColor(gt, cv2.COLOR_BGR2GRAY)
        gt_gray = cv2.resize(gt_gray,(256,256))
        
        # l2 = np.sum(np.power((gt-pred),2))
        l2 = np.sum((gt-pred)**2)
        # print(l2,l2.shape)
        
        # l2_gray = np.sum(np.power((gt_gray-gray_pred),2))
        l2_gray = np.sum((gt_gray-gray_pred)**2)
        # print(l2_gray,l2.shape)
        l2_rgb += l2
        l2_g += l2_gray
        
    print(l2/(i+1))
    print(l2_g/(i+1))

if __name__=='__main__':
    main()

import argparse
import glob
import os
import cv2
import numpy as np

def is_grayscale(image):
    """检查图像是否为灰度图像"""
    if len(image.shape) == 2:  # 没有第三个通道说明是灰度图
        return True
    elif len(image.shape) == 3 and image.shape[2] == 1:  # 单通道图像
        return True
    return False

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('--pred_path', default="")
    parser.add_argument('--real_path', default="")
    args = parser.parse_args()
    
    pred_path = args.pred_path
    real_path = args.real_path
    
    pred_img_lists = sorted(glob.glob(os.path.join(pred_path, "*.png")))
    real_img_lists = sorted(glob.glob(os.path.join(real_path, "*.png")))
    
    assert len(pred_img_lists) == len(real_img_lists)
    
    l2_rgb = 0
    l2_g = 0
    
    for i, img_path in enumerate(pred_img_lists):
        pred = cv2.imread(img_path)
        gt = cv2.imread(real_img_lists[i])
        
        pred_resized = cv2.resize(pred, (256, 256))
        gt_resized = cv2.resize(gt, (256, 256))

        # 检查并处理预测图像
        if is_grayscale(pred_resized):
            # 如果是灰度图像，转为 RGB 进行计算
            pred_rgb = cv2.cvtColor(pred_resized, cv2.COLOR_GRAY2BGR)
            pred_gray = pred_resized
        else:
            # 如果是 RGB 图像，转为灰度图像
            pred_rgb = pred_resized
            pred_gray = cv2.cvtColor(pred_resized, cv2.COLOR_BGR2GRAY)

        # 检查并处理真实图像
        if is_grayscale(gt_resized):
            # 如果是真实图像是灰度图像，转为 RGB 进行计算
            gt_rgb = cv2.cvtColor(gt_resized, cv2.COLOR_GRAY2BGR)
            gt_gray = gt_resized
        else:
            # 如果是真实图像是 RGB 图像，转为灰度图像
            gt_rgb = gt_resized
            gt_gray = cv2.cvtColor(gt_resized, cv2.COLOR_BGR2GRAY)

        # 计算 RGB L2 范数
        l2_rgb_val = np.sum((gt_rgb - pred_rgb) ** 2)
        l2_rgb += l2_rgb_val

        # 计算灰度 L2 范数
        l2_gray_val = np.sum((gt_gray - pred_gray) ** 2)
        l2_g += l2_gray_val

    # 计算并输出平均 L2 范数
    print(f"Average L2 (RGB): {l2_rgb / (i + 1)}")
    print(f"Average L2 (Grayscale): {l2_g / (i + 1)}")

if __name__ == '__main__':
    main()