Upload 103 files

test_scripts/AnimeGANv3_01/test_script.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+import os
+import sys
+import argparse
+import json
+import datetime
+import cv2
+import torch
+import lpips
+from torchvision import transforms
+import torch.nn.functional as F
+from PIL import Image, UnidentifiedImageError
+
+def verify_image(path, exts=('.png','.jpg','.jpeg','.webp')):
+    """Check file existence, non-empty, valid extension, and PIL readability."""
+    if not os.path.isfile(path):
+        return False, f'File does not exist: {path}'
+    if os.path.getsize(path) == 0:
+        return False, f'File is empty: {path}'
+    if not path.lower().endswith(exts):
+        return False, f'Unsupported format: {path}'
+    try:
+        img = Image.open(path)
+        img.verify()
+    except (UnidentifiedImageError, Exception) as e:
+        return False, f'Failed to read image: {path} ({e})'
+    return True, ''
+
+def load_tensor(path):
+    """Load and normalize Tensor to [-1,1] as per original script"""
+    img = cv2.imread(path, cv2.IMREAD_COLOR)
+    if img is None:
+        raise RuntimeError(f'cv2 read failed: {path}')
+    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+    t = transforms.ToTensor()(img) * 2 - 1
+    return t.unsqueeze(0)
+
+def main():
+    p = argparse.ArgumentParser(description='Automated anime effect evaluation script')
+    p.add_argument('--groundtruth',      required=True, help='Original image path')
+    p.add_argument('--output',     required=True, help='Anime-styled output image path')
+    p.add_argument('--lpips-thresh', type=float, default=0.30,
+                   help='LPIPS distance threshold (Pass if >= threshold)')
+    p.add_argument('--clip-thresh', type=float, default=0.25,
+                   help='CLIP Hayao style similarity threshold (Pass if > threshold)')
+    p.add_argument('--result',     required=True, help='Result JSONL file path (append mode)')
+    args = p.parse_args()
+
+    process = True
+    comments = []
+
+    # 1. Validate input/output files
+    for tag, path in [('input', args.groundtruth), ('output', args.output)]:
+        ok, msg = verify_image(path)
+        if not ok:
+            process = False
+            comments.append(f'[{tag}] {msg}')
+
+    # 2. Calculate LPIPS (only if process==True)
+    lpips_val = None
+    result_flag = False
+    if process:
+        try:
+            img0 = load_tensor(args.groundtruth)
+            img1 = load_tensor(args.output)
+            # Align dimensions
+            _, _, h0, w0 = img0.shape
+            _, _, h1, w1 = img1.shape
+            nh, nw = min(h0,h1), min(w0,w1)
+            if (h0,w0) != (nh,nw):
+                img0 = F.interpolate(img0, size=(nh,nw), mode='bilinear', align_corners=False)
+            if (h1,w1) != (nh,nw):
+                img1 = F.interpolate(img1, size=(nh,nw), mode='bilinear', align_corners=False)
+
+            loss_fn = lpips.LPIPS(net='vgg').to(torch.device('cpu'))
+            with torch.no_grad():
+                lpips_val = float(loss_fn(img0, img1).item())
+
+            passed = lpips_val >= args.lpips_thresh
+            comments.append(f'LPIPS={lpips_val:.4f} (>= {args.lpips_thresh} → {"OK" if passed else "FAIL"})')
+            result_flag = passed
+
+        except Exception as e:
+            process = False
+            comments.append(f'Metric calculation error: {e}')
+
+    # 3. CLIP Hayao style similarity check (only if process==True)
+    if process:
+        try:
+            import clip
+            import PIL.Image
+            device = "cuda" if torch.cuda.is_available() else "cpu"
+            clip_model, clip_preprocess = clip.load("ViT-B/32", device=device)
+
+            image = clip_preprocess(PIL.Image.open(args.output)).unsqueeze(0).to(device)
+            hayao_tokens = clip.tokenize(["a landscape in Hayao Miyazaki anime style"]).to(device)
+
+            with torch.no_grad():
+                image_features = clip_model.encode_image(image)
+                text_features = clip_model.encode_text(hayao_tokens)
+
+                image_features /= image_features.norm(dim=-1, keepdim=True)
+                text_features /= text_features.norm(dim=-1, keepdim=True)
+
+                hayao_score = (image_features @ text_features.T).item()
+
+            passed = hayao_score > args.clip_thresh
+            comments.append(f"CLIP Hayao style score = {hayao_score:.3f} (threshold = {args.clip_thresh} → {'OK' if passed else 'FAIL'})")
+            result_flag = result_flag and passed
+
+        except Exception as e:
+            comments.append(f"CLIP style check failed: {e}")
+
+    # 4. Write JSONL result
+    entry = {
+        "Process": process,
+        "Result":  result_flag,
+        "TimePoint": datetime.datetime.now().isoformat(sep='T', timespec='seconds'),
+        "comments": "; ".join(comments)
+    }
+    os.makedirs(os.path.dirname(args.result) or '.', exist_ok=True)
+    with open(args.result, 'a', encoding='utf-8') as f:
+        f.write(json.dumps(entry, ensure_ascii=False, default=str) + "\n")
+
+if __name__ == "__main__":
+    main()

test_scripts/AnimeGANv3_02/test_script.py

@@ -0,0 +1,125 @@
+#!/usr/bin/env python3
+import os
+import sys
+import argparse
+import json
+import datetime
+import cv2
+import torch
+import lpips
+from torchvision import transforms
+import torch.nn.functional as F
+from PIL import Image, UnidentifiedImageError
+
+def verify_image(path, exts=('.png','.jpg','.jpeg','.webp')):
+    if not os.path.isfile(path):
+        return False, f'File does not exist: {path}'
+    if os.path.getsize(path) == 0:
+        return False, f'File is empty: {path}'
+    if not path.lower().endswith(exts):
+        return False, f'Unsupported format: {path}'
+    try:
+        img = Image.open(path)
+        img.verify()
+    except (UnidentifiedImageError, Exception) as e:
+        return False, f'Failed to read image: {path} ({e})'
+    return True, ''
+
+def load_tensor(path):
+    img = cv2.imread(path, cv2.IMREAD_COLOR)
+    if img is None:
+        raise RuntimeError(f'cv2 read failed: {path}')
+    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+    t = transforms.ToTensor()(img) * 2 - 1
+    return t.unsqueeze(0)
+
+def main():
+    p = argparse.ArgumentParser(description='Automated anime effect evaluation script')
+    p.add_argument('--groundtruth', required=True, help='Original image path')
+    p.add_argument('--output', required=True, help='Anime-styled output image path')
+    p.add_argument('--lpips-thresh', type=float, default=0.40,
+                   help='LPIPS structural similarity max distance (Pass if <= threshold)')
+    p.add_argument('--clip-thresh', type=float, default=0.25,
+                   help='CLIP anime style similarity threshold (Pass if > threshold)')
+    p.add_argument('--result', required=True, help='Result JSONL file path (append mode)')
+    args = p.parse_args()
+
+    process = True
+    comments = []
+
+    # 1. Validate input/output files
+    for tag, path in [('input', args.groundtruth), ('output', args.output)]:
+        ok, msg = verify_image(path)
+        if not ok:
+            process = False
+            comments.append(f'[{tag}] {msg}')
+
+    lpips_val = None
+    lpips_pass = True
+    clip_pass = False
+    if process:
+        try:
+            # 2. LPIPS structure preservation check
+            img0 = load_tensor(args.groundtruth)
+            img1 = load_tensor(args.output)
+            _, _, h0, w0 = img0.shape
+            _, _, h1, w1 = img1.shape
+            nh, nw = min(h0,h1), min(w0,w1)
+            img0 = F.interpolate(img0, size=(nh,nw), mode='bilinear', align_corners=False)
+            img1 = F.interpolate(img1, size=(nh,nw), mode='bilinear', align_corners=False)
+
+            loss_fn = lpips.LPIPS(net='vgg').to(torch.device('cpu'))
+            with torch.no_grad():
+                lpips_val = float(loss_fn(img0, img1).item())
+            lpips_pass = lpips_val <= args.lpips_thresh
+            comments.append(f'LPIPS={lpips_val:.4f} (<= {args.lpips_thresh} → {"OK" if lpips_pass else "FAIL"})')
+        except Exception as e:
+            process = False
+            comments.append(f'Metric calculation error: {e}')
+
+    if process:
+        try:
+            import clip
+            import PIL.Image
+            device = "cuda" if torch.cuda.is_available() else "cpu"
+            clip_model, clip_preprocess = clip.load("ViT-B/32", device=device)
+
+            image = clip_preprocess(PIL.Image.open(args.output)).unsqueeze(0).to(device)
+            prompt_list = [
+                "anime-style photo",
+                "cartoon photo",
+                "anime drawing",
+                "photo in manga style",
+                "Hayao Miyazaki anime style"
+            ]
+            tokens = clip.tokenize(prompt_list).to(device)
+
+            with torch.no_grad():
+                image_features = clip_model.encode_image(image)
+                text_features = clip_model.encode_text(tokens)
+                image_features /= image_features.norm(dim=-1, keepdim=True)
+                text_features /= text_features.norm(dim=-1, keepdim=True)
+                scores = (image_features @ text_features.T).squeeze(0)
+                best_score = scores.max().item()
+
+            clip_pass = best_score > args.clip_thresh
+            comments.append(f'CLIP best anime style score = {best_score:.3f} (>{args.clip_thresh} → {"OK" if clip_pass else "FAIL"})')
+
+        except Exception as e:
+            comments.append(f"CLIP style check failed: {e}")
+
+    result_flag = process and lpips_pass and clip_pass
+
+    # 4. Write JSONL result
+    entry = {
+        "Process": process,
+        "Result": result_flag,
+        "TimePoint": datetime.datetime.now().isoformat(sep='T', timespec='seconds'),
+        "comments": "; ".join(comments)
+    }
+    os.makedirs(os.path.dirname(args.result) or '.', exist_ok=True)
+    with open(args.result, 'a', encoding='utf-8') as f:
+        f.write(json.dumps(entry, ensure_ascii=False, default=str) + "\n")
+
+if __name__ == "__main__":
+    main()

test_scripts/AnimeGANv3_03/test_script.py

@@ -0,0 +1,197 @@
+import argparse
+import cv2
+import numpy as np
+from skimage.metrics import structural_similarity as ssim
+import torch
+import torchvision.models as models
+import torchvision.transforms as transforms
+from scipy.linalg import sqrtm
+import os
+import json
+from datetime import datetime
+
+
+def extract_frames(video_path, max_frames=100):
+    """Extract frames from video, limiting maximum frames for efficiency"""
+    cap = cv2.VideoCapture(video_path)
+    frames = []
+    count = 0
+    while cap.isOpened() and count < max_frames:
+        ret, frame = cap.read()
+        if not ret:
+            break
+        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        frames.append(frame)
+        count += 1
+    cap.release()
+    return frames
+
+
+def compute_ssim(input_frames, output_frames):
+    """Calculate average SSIM between input and output frames"""
+    ssim_scores = []
+    for in_frame, out_frame in zip(input_frames, output_frames):
+        # Resize frames if dimensions don't match
+        min_shape = (min(in_frame.shape[0], out_frame.shape[0]),
+                     min(in_frame.shape[1], out_frame.shape[1]))
+        in_frame = cv2.resize(in_frame, min_shape[::-1])
+        out_frame = cv2.resize(out_frame, min_shape[::-1])
+        # Convert to grayscale for SSIM calculation
+        in_gray = cv2.cvtColor(in_frame, cv2.COLOR_RGB2GRAY)
+        out_gray = cv2.cvtColor(out_frame, cv2.COLOR_RGB2GRAY)
+        score = ssim(in_gray, out_gray, data_range=255)
+        ssim_scores.append(score)
+    return np.mean(ssim_scores) if ssim_scores else 0.0
+
+
+def get_inception_features(frames, model, transform, device):
+    """Extract Inception V3 features for FID calculation"""
+    features = []
+    for frame in frames:
+        img = cv2.resize(frame, (299, 299))
+        img = transform(img).unsqueeze(0).to(device)
+        with torch.no_grad():
+            feat = model(img).squeeze().cpu().numpy()
+        features.append(feat)
+    return np.array(features)
+
+
+def compute_fid(input_frames, output_frames):
+    """Calculate FID between input and output frames using Inception V3"""
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    inception = models.inception_v3(pretrained=True, transform_input=False).eval().to(device)
+
+    transform = transforms.Compose([
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+    ])
+
+    input_features = get_inception_features(input_frames, inception, transform, device)
+    output_features = get_inception_features(output_frames, inception, transform, device)
+
+    # Calculate mean and covariance
+    mu1, sigma1 = np.mean(input_features, axis=0), np.cov(input_features, rowvar=False)
+    mu2, sigma2 = np.mean(output_features, axis=0), np.cov(output_features, rowvar=False)
+
+    # Calculate FID
+    diff = mu1 - mu2
+    covmean = sqrtm(sigma1.dot(sigma2))
+    if np.iscomplexobj(covmean):
+        covmean = covmean.real
+    fid = diff.dot(diff) + np.trace(sigma1 + sigma2 - 2 * covmean)
+    return fid
+
+
+def evaluate_animeganv3(input_video, output_video, ssim_threshold=0.7, fid_threshold=400):
+    """Evaluate AnimeGANv3 stylization effect using SSIM and FID"""
+    messages = []
+    messages.append(f"Evaluating videos:\nInput video: {input_video}\nOutput video: {output_video}")
+
+    # Extract frames
+    input_frames = extract_frames(input_video)
+    output_frames = extract_frames(output_video)
+
+    if len(input_frames) == 0 or len(output_frames) == 0:
+        messages.append("Error: Failed to extract frames from one or both videos.")
+        return False, "\n".join(messages)
+
+    if len(input_frames) != len(output_frames):
+        messages.append("Warning: Input and output videos have different frame counts.")
+        min_frames = min(len(input_frames), len(output_frames))
+        input_frames = input_frames[:min_frames]
+        output_frames = output_frames[:min_frames]
+
+    # Calculate SSIM
+    avg_ssim = compute_ssim(input_frames, output_frames)
+    messages.append(f"Average SSIM: {avg_ssim:.4f}")
+
+    # Calculate FID
+    fid_score = compute_fid(input_frames, output_frames)
+    messages.append(f"FID score: {fid_score:.2f}")
+
+    # Compare with thresholds
+    ssim_pass = avg_ssim >= ssim_threshold
+    fid_pass = fid_score <= fid_threshold
+    success = ssim_pass and fid_pass
+
+    result_message = f"\nEvaluation results:\n"
+    result_message += f"SSIM (≥ {ssim_threshold}): {'Pass' if ssim_pass else 'Fail'} ({avg_ssim:.4f})\n"
+    result_message += f"FID (≤ {fid_threshold}): {'Pass' if fid_pass else 'Fail'} ({fid_score:.2f})\n"
+    result_message += f"Overall success: {'Yes' if success else 'No'}"
+    messages.append(result_message)
+
+    return success, "\n".join(messages)
+
+
+def is_valid_video_file(file_path):
+    """Check if file exists, is non-empty and has valid video format (.mp4)"""
+    if not os.path.exists(file_path):
+        return False, f"File {file_path} does not exist."
+    if os.path.getsize(file_path) == 0:
+        return False, f"File {file_path} is empty."
+    if not file_path.lower().endswith('.mp4'):
+        return False, f"File {file_path} has incorrect format, only .mp4 supported."
+    return True, ""
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Evaluate AnimeGANv3 video stylization effect")
+    parser.add_argument("-i", "--groundtruth", required=True, help="Input video file path")
+    parser.add_argument("-o", "--output", required=True, help="Output video file path")
+    parser.add_argument("--ssim_threshold", type=float, default=0.7, help="SSIM success threshold")
+    parser.add_argument("--fid_threshold", type=float, default=400.0, help="FID success threshold")
+    parser.add_argument("--result", help="JSONL file path to save results")
+
+    args = parser.parse_args()
+
+    # Collect all output messages
+    messages = []
+    success = False
+    process_valid = True
+
+    # Validate input files
+    input_valid, input_error = is_valid_video_file(args.groundtruth)
+    output_valid, output_error = is_valid_video_file(args.output)
+
+    if not input_valid:
+        messages.append(input_error)
+        process_valid = False
+    if not output_valid:
+        messages.append(output_error)
+        process_valid = False
+
+    # If inputs are valid, run evaluation
+    if process_valid:
+        success, eval_message = evaluate_animeganv3(
+            args.groundtruth,
+            args.output,
+            args.ssim_threshold,
+            args.fid_threshold
+        )
+        messages.append(eval_message)
+    else:
+        messages.append("Evaluation not run due to input file validation failure.")
+
+    # Print all messages
+    print("\n".join(messages))
+
+    # If --result is specified, save to JSONL
+    # Modified result saving section in main() function:
+    if args.result:
+        result_entry = {
+            "Process": process_valid,
+            "Result": success,
+            "TimePoint": datetime.now().strftime("%Y-%m-%dT%H:%M:%S"),
+            "comments": "\n".join(messages)
+        }
+        try:
+            os.makedirs(os.path.dirname(args.result) or '.', exist_ok=True)
+            with open(args.result, 'a', encoding='utf-8') as f:
+                json_line = json.dumps(result_entry, ensure_ascii=False, default=str)
+                f.write(json_line + '\n')  # Ensure newline append
+        except Exception as e:
+            print(f"Error: Failed to save results to {args.result}, reason: {str(e)}")
+
+
+if __name__ == "__main__":
+    main()

test_scripts/DeOldify_01/test_script.py

@@ -0,0 +1,119 @@
+import os
+import sys
+import argparse
+import json
+from datetime import datetime
+import requests
+from io import BytesIO
+
+import numpy as np
+from PIL import Image
+from skimage.color import rgb2lab, deltaE_ciede2000
+from basicsr.metrics.niqe import calculate_niqe
+
+def download_image(path_or_url: str) -> Image.Image:
+    """Download or read local image, return PIL.Image in RGB mode."""
+    if path_or_url.startswith(('http://', 'https://')):
+        resp = requests.get(path_or_url, timeout=10)
+        if resp.status_code != 200:
+            raise ValueError(f"Failed to download image: {path_or_url} (status code {resp.status_code})")
+        data = BytesIO(resp.content)
+    else:
+        if not os.path.isfile(path_or_url):
+            raise ValueError(f"File does not exist: {path_or_url}")
+        data = path_or_url
+    try:
+        return Image.open(data).convert('RGB')
+    except Exception as e:
+        raise ValueError(f"Failed to open image: {e}")
+
+def compute_ciede2000(ref_img: Image.Image, test_img: Image.Image) -> float:
+    arr_ref  = np.asarray(ref_img, dtype=np.float32) / 255.0
+    arr_test = np.asarray(test_img, dtype=np.float32) / 255.0
+    lab_ref  = rgb2lab(arr_ref)
+    lab_test = rgb2lab(arr_test)
+    delta    = deltaE_ciede2000(lab_ref, lab_test)
+    return float(np.mean(delta))
+
+def compute_niqe(img: Image.Image) -> float:
+    arr = np.asarray(img).astype(np.float32)
+    return float(calculate_niqe(arr, crop_border=0))
+
+def write_result_jsonl(file_path: str, data: dict):
+    """Append single result to file in JSONL format."""
+    try:
+        os.makedirs(os.path.dirname(file_path), exist_ok=True)
+        with open(file_path, 'a', encoding='utf-8') as f:
+            f.write(json.dumps(data, ensure_ascii=False, default=str) + '\n')
+    except Exception as e:
+        print(f"❌ Error writing JSONL file: {e}", file=sys.stderr)
+
+def main():
+    p = argparse.ArgumentParser(
+        description="Evaluate colorization/enhancement effect using CIEDE2000 and NIQE metrics, with JSONL output option")
+    p.add_argument("--groundtruth", type=str, required=True,   help="Reference image URL or local path")
+    p.add_argument("--output", type=str, required=True,        help="Reconstructed image URL or local path")
+    p.add_argument("--ciede-thresh", type=float, required=True,
+                   help="CIEDE2000 minimum acceptance threshold (higher is better)")
+    p.add_argument("--niqe-thresh",  type=float, required=True,
+                   help="NIQE maximum acceptance threshold (lower is better)")
+    p.add_argument("--result",       help="File path to store JSONL results")
+    args = p.parse_args()
+
+    process_ok = True
+    comments = []
+
+    # Timestamp
+    time_point = datetime.now().isoformat()
+
+    # Load images
+    try:
+        img_ref   = download_image(args.groundtruth)
+        img_recon = download_image(args.output)
+    except ValueError as err:
+        comments.append(str(err))
+        process_ok = False
+
+    # Calculate metrics only if Process OK
+    if process_ok:
+        try:
+            score_ciede = compute_ciede2000(img_ref, img_recon)
+            score_niqe  = compute_niqe(img_recon)
+
+            comments.append(f"CIEDE2000 average color difference: {score_ciede:.4f} (threshold {args.ciede_thresh})")
+            comments.append(f"Reconstructed image NIQE score: {score_niqe:.4f} (threshold {args.niqe_thresh})")
+
+            ok_ciede = score_ciede >= args.ciede_thresh
+            ok_niqe  = score_niqe  <= args.niqe_thresh
+
+            if ok_ciede and ok_niqe:
+                comments.append("✅ Processing effect meets requirements: CIEDE2000↑ and NIQE↓ both satisfy thresholds")
+                result_ok = True
+            else:
+                fail_reasons = []
+                if not ok_ciede: fail_reasons.append("CIEDE2000 not met")
+                if not ok_niqe:  fail_reasons.append("NIQE not met")
+                comments.append("❌ Processing effect does not meet requirements: " + " ".join(fail_reasons))
+                result_ok = False
+        except Exception as e:
+            comments.append(f"Exception during metric calculation: {e}")
+            result_ok = False
+    else:
+        result_ok = False
+
+    # Write to JSONL if --result is specified
+    if args.result:
+        record = {
+            "Process":   process_ok,
+            "Result":    result_ok,
+            "TimePoint": time_point,
+            "comments":  "\n".join(comments)
+        }
+        write_result_jsonl(args.result, record)
+
+    # Print all comments
+    for line in comments:
+        print(line, file=(sys.stderr if not process_ok or not result_ok else sys.stdout))
+
+if __name__ == "__main__":
+    main()

test_scripts/DeOldify_02/test_script.py

@@ -0,0 +1,113 @@
+import os
+import sys
+import argparse
+import json
+from datetime import datetime
+import requests
+from io import BytesIO
+
+import numpy as np
+from PIL import Image
+from skimage.color import rgb2lab, deltaE_ciede2000
+from basicsr.metrics.niqe import calculate_niqe
+
+def download_image(path_or_url: str) -> Image.Image:
+    """Download or read local image, return PIL.Image in RGB mode."""
+    if path_or_url.startswith(('http://', 'https://')):
+        resp = requests.get(path_or_url, timeout=10)
+        if resp.status_code != 200:
+            raise ValueError(f"Failed to download image: {path_or_url} (status code {resp.status_code})")
+        data = BytesIO(resp.content)
+    else:
+        if not os.path.isfile(path_or_url):
+            raise ValueError(f"File does not exist: {path_or_url}")
+        data = path_or_url
+    try:
+        return Image.open(data).convert('RGB')
+    except Exception as e:
+        raise ValueError(f"Failed to open image: {e}")
+
+def compute_ciede2000(ref_img: Image.Image, test_img: Image.Image) -> float:
+    arr_ref  = np.asarray(ref_img, dtype=np.float32) / 255.0
+    arr_test = np.asarray(test_img, dtype=np.float32) / 255.0
+    lab_ref  = rgb2lab(arr_ref)
+    lab_test = rgb2lab(arr_test)
+    delta    = deltaE_ciede2000(lab_ref, lab_test)
+    return float(np.mean(delta))
+
+def compute_niqe(img: Image.Image) -> float:
+    arr = np.asarray(img).astype(np.float32)
+    return float(calculate_niqe(arr, crop_border=0))
+
+def write_result_jsonl(file_path: str, data: dict):
+    """Append single result to file in JSONL format."""
+    try:
+        os.makedirs(os.path.dirname(file_path), exist_ok=True)
+        with open(file_path, 'a', encoding='utf-8') as f:
+            f.write(json.dumps(data, ensure_ascii=False, default=str) + '\n')
+    except Exception as e:
+        print(f"❌ Error writing JSONL file: {e}", file=sys.stderr)
+
+def main():
+    p = argparse.ArgumentParser(
+        description="Evaluate colorization/enhancement effect using CIEDE2000 and NIQE metrics, with JSONL output option")
+    p.add_argument("--groundtruth", type=str, required=True, help="Reference image URL or local path")
+    p.add_argument("--output", type=str, required=True, help="Reconstructed image URL or local path")
+    p.add_argument("--ciede-thresh", type=float, required=True,
+                   help="CIEDE2000 minimum acceptance threshold (higher is better)")
+    p.add_argument("--niqe-thresh", type=float, required=True,
+                   help="NIQE maximum acceptance threshold (lower is better)")
+    p.add_argument("--result", help="File path to store JSONL results")
+    args = p.parse_args()
+
+    process_ok = True
+    result_ok = False
+    comments = []
+
+    time_point = datetime.now().isoformat()
+
+    try:
+        img_ref = download_image(args.groundtruth)
+        img_recon = download_image(args.output)
+    except ValueError as err:
+        comments.append(str(err))
+        process_ok = False
+
+    if process_ok:
+        try:
+            score_ciede = compute_ciede2000(img_ref, img_recon)
+            score_niqe = compute_niqe(img_recon)
+
+            comments.append(f"CIEDE2000 average color difference: {score_ciede:.4f} (threshold {args.ciede_thresh})")
+            comments.append(f"Reconstructed image NIQE score: {score_niqe:.4f} (threshold {args.niqe_thresh})")
+
+            ok_ciede = score_ciede >= args.ciede_thresh
+            ok_niqe = score_niqe <= args.niqe_thresh
+
+            if ok_ciede and ok_niqe:
+                comments.append("✅ Processing effect meets requirements: CIEDE2000↑ and NIQE↓ both satisfy thresholds")
+                result_ok = True
+            else:
+                fail_reasons = []
+                if not ok_ciede:
+                    fail_reasons.append("CIEDE2000 not met")
+                if not ok_niqe:
+                    fail_reasons.append("NIQE not met")
+                comments.append("❌ Processing effect does not meet requirements: " + " ".join(fail_reasons))
+        except Exception as e:
+            comments.append(f"Exception during metric calculation: {e}")
+
+    if args.result:
+        record = {
+            "Process": process_ok,
+            "Result": result_ok,
+            "TimePoint": time_point,
+            "comments": "\n".join(comments)
+        }
+        write_result_jsonl(args.result, record)
+
+    for line in comments:
+        print(line, file=(sys.stderr if not process_ok or not result_ok else sys.stdout))
+
+if __name__ == "__main__":
+    main()

test_scripts/DeOldify_03/test_script.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+import argparse
+import os
+import sys
+import cv2
+import numpy as np
+import json
+from datetime import datetime
+
+def compute_colorfulness(frame):
+    # Convert to float for computation
+    b, g, r = cv2.split(frame.astype('float'))
+    # Compute RG and YB components
+    rg = r - g
+    yb = 0.5 * (r + g) - b
+    # Compute statistics
+    std_rg, std_yb = np.std(rg), np.std(yb)
+    mean_rg, mean_yb = np.mean(rg), np.mean(yb)
+    # Colorfulness metric
+    return np.sqrt(std_rg**2 + std_yb**2) + 0.3 * np.sqrt(mean_rg**2 + mean_yb**2)
+
+def sample_frames(video_path, max_frames=30):
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        return []
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    step = max(1, total_frames // max_frames)
+    frames = []
+    for idx in range(0, total_frames, step):
+        cap.set(cv2.CAP_PROP_POS_FRAMES, idx)
+        ret, frame = cap.read()
+        if not ret:
+            break
+        # Resize frame to width=256, keep aspect ratio
+        h, w = frame.shape[:2]
+        new_w = 256
+        new_h = int(h * (256 / w))
+        frame = cv2.resize(frame, (new_w, new_h))
+        frames.append(frame)
+    cap.release()
+    return frames
+
+def main():
+    parser = argparse.ArgumentParser(description="Evaluate video colorfulness (detect non-BW video).")
+    parser.add_argument("--output", type=str, required=True,
+                        help="Path to the input video file.")
+    parser.add_argument("--threshold", type=float, default=10.0,
+                        help="Colorfulness threshold for pass/fail (default: 10.0).")
+    parser.add_argument("--result", help="Path to append the jsonl result.")
+    args = parser.parse_args()
+
+    input_path = args.output
+    process_ok = False
+    results_ok = False
+    comments = []
+
+    # Check file existence and basic validity
+    if not os.path.exists(input_path):
+        comments.append(f"Input file not found: {input_path}")
+    elif os.path.getsize(input_path) == 0:
+        comments.append(f"Input file is empty: {input_path}")
+    else:
+        ext = os.path.splitext(input_path)[1].lower()
+        if ext not in ['.mp4', '.avi', '.mov', '.mkv']:
+            comments.append(f"Unsupported file format: {ext}")
+        else:
+            process_ok = True
+
+    if process_ok:
+        frames = sample_frames(input_path)
+        if not frames:
+            comments.append("Failed to read any frames from video.")
+        else:
+            scores = [compute_colorfulness(f) for f in frames]
+            avg_score = float(np.mean(scores))
+            comments.append(f"Average colorfulness: {avg_score:.2f}")
+            results_ok = avg_score > args.threshold
+            comments.append("Pass" if results_ok else "Fail")
+
+    # Print result
+    print("=== Evaluation ===")
+    print("Process OK: ", process_ok)
+    if process_ok:
+        print("Result OK:  ", results_ok)
+    for c in comments:
+        print(c)
+
+    # Append to jsonl
+    if args.result:
+        record = {
+            "Process": process_ok,
+            "Result": results_ok,
+            "TimePoint": datetime.now().isoformat(),
+            "comments": "; ".join(comments)
+        }
+        os.makedirs(os.path.dirname(args.result), exist_ok=True)
+        with open(args.result, 'a', encoding='utf-8') as f:
+            json_line = json.dumps(record, default=str, ensure_ascii=False)
+            f.write(json_line + "\n")
+
+if __name__ == "__main__":
+    main()

test_scripts/DeScratch_01/detection.py

@@ -0,0 +1,178 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+import argparse
+import gc
+import json
+import os
+import time
+import warnings
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+import torchvision as tv
+from PIL import Image, ImageFile
+
+from detection_models import networks
+from detection_util.util import *
+
+warnings.filterwarnings("ignore", category=UserWarning)
+
+ImageFile.LOAD_TRUNCATED_IMAGES = True
+
+
+def data_transforms(img, full_size, method=Image.BICUBIC):
+    if full_size == "full_size":
+        ow, oh = img.size
+        h = int(round(oh / 16) * 16)
+        w = int(round(ow / 16) * 16)
+        if (h == oh) and (w == ow):
+            return img
+        return img.resize((w, h), method)
+
+    elif full_size == "scale_256":
+        ow, oh = img.size
+        pw, ph = ow, oh
+        if ow < oh:
+            ow = 256
+            oh = ph / pw * 256
+        else:
+            oh = 256
+            ow = pw / ph * 256
+
+        h = int(round(oh / 16) * 16)
+        w = int(round(ow / 16) * 16)
+        if (h == ph) and (w == pw):
+            return img
+        return img.resize((w, h), method)
+
+
+def scale_tensor(img_tensor, default_scale=256):
+    _, _, w, h = img_tensor.shape
+    if w < h:
+        ow = default_scale
+        oh = h / w * default_scale
+    else:
+        oh = default_scale
+        ow = w / h * default_scale
+
+    oh = int(round(oh / 16) * 16)
+    ow = int(round(ow / 16) * 16)
+
+    return F.interpolate(img_tensor, [ow, oh], mode="bilinear")
+
+
+def blend_mask(img, mask):
+
+    np_img = np.array(img).astype("float")
+
+    return Image.fromarray((np_img * (1 - mask) + mask * 255.0).astype("uint8")).convert("RGB")
+
+
+def main(config):
+    print("initializing the dataloader")
+
+    model = networks.UNet(
+        in_channels=1,
+        out_channels=1,
+        depth=4,
+        conv_num=2,
+        wf=6,
+        padding=True,
+        batch_norm=True,
+        up_mode="upsample",
+        with_tanh=False,
+        sync_bn=True,
+        antialiasing=True,
+    )
+
+    ## load model
+    checkpoint_path = os.path.join(os.path.dirname(__file__), "checkpoints/detection/FT_Epoch_latest.pt")
+    checkpoint = torch.load(checkpoint_path, map_location="cpu")
+    model.load_state_dict(checkpoint["model_state"])
+    print("model weights loaded")
+
+    if config.GPU >= 0:
+        model.to(config.GPU)
+    else: 
+        model.cpu()
+    model.eval()
+
+    ## dataloader and transformation
+    print("directory of testing image: " + config.test_path)
+    imagelist = os.listdir(config.test_path)
+    imagelist.sort()
+    total_iter = 0
+
+    P_matrix = {}
+    save_url = os.path.join(config.output_dir)
+    mkdir_if_not(save_url)
+
+    input_dir = os.path.join(save_url, "input")
+    output_dir = os.path.join(save_url, "mask")
+    # blend_output_dir=os.path.join(save_url, 'blend_output')
+    mkdir_if_not(input_dir)
+    mkdir_if_not(output_dir)
+    # mkdir_if_not(blend_output_dir)
+
+    idx = 0
+
+    results = []
+    for image_name in imagelist:
+
+        idx += 1
+
+        print("processing", image_name)
+
+        scratch_file = os.path.join(config.test_path, image_name)
+        if not os.path.isfile(scratch_file):
+            print("Skipping non-file %s" % image_name)
+            continue
+        scratch_image = Image.open(scratch_file).convert("RGB")
+        w, h = scratch_image.size
+
+        transformed_image_PIL = data_transforms(scratch_image, config.input_size)
+        scratch_image = transformed_image_PIL.convert("L")
+        scratch_image = tv.transforms.ToTensor()(scratch_image)
+        scratch_image = tv.transforms.Normalize([0.5], [0.5])(scratch_image)
+        scratch_image = torch.unsqueeze(scratch_image, 0)
+        _, _, ow, oh = scratch_image.shape
+        scratch_image_scale = scale_tensor(scratch_image)
+
+        if config.GPU >= 0:
+            scratch_image_scale = scratch_image_scale.to(config.GPU)
+        else:
+            scratch_image_scale = scratch_image_scale.cpu()
+        with torch.no_grad():
+            P = torch.sigmoid(model(scratch_image_scale))
+
+        P = P.data.cpu()
+        P = F.interpolate(P, [ow, oh], mode="nearest")
+
+        tv.utils.save_image(
+            (P >= 0.4).float(),
+            os.path.join(
+                output_dir,
+                image_name[:-4] + ".png",
+            ),
+            nrow=1,
+            padding=0,
+            normalize=True,
+        )
+        transformed_image_PIL.save(os.path.join(input_dir, image_name[:-4] + ".png"))
+        gc.collect()
+        torch.cuda.empty_cache()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    # parser.add_argument('--checkpoint_name', type=str, default="FT_Epoch_latest.pt", help='Checkpoint Name')
+
+    parser.add_argument("--GPU", type=int, default=0)
+    parser.add_argument("--test_path", type=str, default=".")
+    parser.add_argument("--output_dir", type=str, default=".")
+    parser.add_argument("--input_size", type=str, default="scale_256", help="resize_256|full_size|scale_256")
+    config = parser.parse_args()
+
+    main(config)

test_scripts/DeScratch_01/test_script.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+import argparse
+import os
+import json
+import datetime
+import numpy as np
+from PIL import Image, UnidentifiedImageError
+import cv2
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Automated scratch detection test script')
+    parser.add_argument(
+        '--output',
+        required=True,
+        help='Path to output image for detection'
+    )
+    parser.add_argument(
+        '--result',
+        required=True,
+        help='Path to result JSONL file (created if not exists, appended if exists)'
+    )
+    parser.add_argument(
+        '--threshold',
+        type=float,
+        default=0.05,
+        help='Scratch detection threshold, default 0.05'
+    )
+    parser.add_argument(
+        '--min-length',
+        type=int,
+        default=50,
+        help='Minimum scratch length, default 50 pixels'
+    )
+    args = parser.parse_args()
+    process = False
+    result = False
+    comments = []
+    # —— Step 1: Validate input file ——
+    if not os.path.isfile(args.output):
+        comments.append(f'File not found: {args.output}')
+    elif os.path.getsize(args.output) == 0:
+        comments.append(f'File is empty: {args.output}')
+    else:
+        try:
+            # Verify format
+            img = Image.open(args.output)
+            img.verify()
+            process = True
+            # Reopen to read pixels
+            img = Image.open(args.output)
+            # Convert to numpy array
+            img_array = np.array(img)
+
+            # —— Step 2: Scratch detection logic ——
+            # Convert to grayscale
+            if len(img_array.shape) == 3:
+                gray_img = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY)
+            else:
+                gray_img = img_array
+
+            # Apply Gaussian blur to remove noise
+            blurred = cv2.GaussianBlur(gray_img, (5, 5), 0)
+
+            # Use Canny edge detection
+            edges = cv2.Canny(blurred, 50, 150)
+
+            # Use Hough transform to detect lines
+            lines = cv2.HoughLinesP(edges, 1, np.pi / 180,
+                                    threshold=50,
+                                    minLineLength=args.min_length,
+                                    maxLineGap=10)
+
+            # Calculate scratch features
+            if lines is not None:
+                scratch_count = len(lines)
+                # Calculate cumulative length and average intensity
+                total_length = 0
+                line_intensities = []
+
+                for line in lines:
+                    x1, y1, x2, y2 = line[0]
+                    length = np.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
+                    total_length += length
+
+                    # Calculate average intensity along the line
+                    line_points = np.linspace((x1, y1), (x2, y2), int(length), dtype=np.int32)
+                    points_intensity = []
+                    for x, y in line_points:
+                        if 0 <= x < gray_img.shape[1] and 0 <= y < gray_img.shape[0]:
+                            points_intensity.append(gray_img[y, x])
+
+                    if points_intensity:
+                        line_intensities.append(np.mean(points_intensity))
+
+                # Calculate features
+                avg_intensity = np.mean(line_intensities) if line_intensities else 0
+                intensity_std = np.std(line_intensities) if line_intensities else 0
+                avg_length = total_length / scratch_count if scratch_count > 0 else 0
+
+                # Scratch score - combines line count, length and intensity variation
+                scratch_score = (scratch_count * avg_length * intensity_std) / (img_array.size * 255)
+
+                if scratch_score > args.threshold:
+                    comments.append(
+                        f'Potential scratches detected: {scratch_count} lines, avg length {avg_length:.2f}px, intensity variation {intensity_std:.2f}, score {scratch_score:.6f}, exceeds threshold {args.threshold}')
+                    result = False
+                else:
+                    comments.append(f'No significant scratches detected: score {scratch_score:.6f}, below threshold {args.threshold}')
+                    result = True
+            else:
+                comments.append('No lines detected, no scratches found')
+                result = True
+
+        except UnidentifiedImageError as e:
+            comments.append(f'Invalid image format: {e}')
+        except Exception as e:
+            comments.append(f'Error reading image: {e}')
+    print("; ".join(comments))
+    # —— Step 3: Write to JSONL ——
+    entry = {
+        "Process": process,
+        "Result": result,
+        "TimePoint": datetime.datetime.now().isoformat(sep='T', timespec='seconds'),
+        "comments": "; ".join(comments)
+    }
+    # Append mode, one entry per line
+    with open(args.result, 'a', encoding='utf-8') as f:
+        f.write(json.dumps(entry, ensure_ascii=False, default=str) + "\n")
+
+
+if __name__ == "__main__":
+    main()

test_scripts/DeScratch_02/test_script.py

@@ -0,0 +1,121 @@
+import os
+import numpy as np
+from PIL import Image
+from tqdm import tqdm
+import argparse
+import json
+from datetime import datetime
+
+
+def evaluate_mask(pred_mask, gt_mask):
+    # Convert masks to boolean values, calculate IoU and Dice coefficient
+    pred_mask = pred_mask.astype(bool)
+    gt_mask = gt_mask.astype(bool)
+
+    intersection = np.logical_and(pred_mask, gt_mask).sum()
+    union = np.logical_or(pred_mask, gt_mask).sum()
+    iou = intersection / union if union != 0 else 1.0
+
+    dice = (2 * intersection) / (pred_mask.sum() + gt_mask.sum()) if (pred_mask.sum() + gt_mask.sum()) != 0 else 1.0
+
+    return {"IoU": iou, "Dice": dice}
+
+
+def main(pred_dir, gt_dir, iou_threshold=0.5, dice_threshold=0.6, result_file=None):
+    all_metrics = []
+
+    # Initialize Process with default status True (files exist and valid)
+    process_result = {"Process": True, "Result": False, "TimePoint": "", "comments": ""}
+    process_result["TimePoint"] = datetime.now().strftime("%Y-%m-%dT%H:%M:%S")
+
+    print(f"\nStarting evaluation task:")
+    print(f"Predicted masks path: {pred_dir}")
+    print(f"Ground truth masks path: {gt_dir}\n")
+
+    # Validate input paths
+    if not os.path.exists(pred_dir) or not os.path.exists(gt_dir):
+        process_result["Process"] = False
+        process_result["comments"] = "Path does not exist"
+        print("❌ Predicted or ground truth masks path does not exist")
+        save_result(result_file, process_result)
+        return
+
+    # Check each file in directory
+    for filename in tqdm(os.listdir(gt_dir)):
+        # Check if file extension is valid image format
+        if not filename.lower().endswith(('.png', '.jpg', '.jpeg')):
+            continue
+
+        gt_path = os.path.join(gt_dir, filename)
+
+        # Automatically find predicted filename matching output.*
+        pred_filename = next((f for f in os.listdir(pred_dir) if
+                              f.startswith('output.') and f.lower().endswith(('.png', '.jpg', '.jpeg'))), None)
+
+        if not pred_filename:
+            print(f"⚠️ Missing predicted file: {filename}")
+            continue
+
+        pred_path = os.path.join(pred_dir, pred_filename)
+
+        # Read ground truth and predicted masks
+        gt_mask = np.array(Image.open(gt_path).convert("L")) > 128
+        pred_mask = np.array(Image.open(pred_path).convert("L")) > 128
+
+        # Evaluate and calculate IoU and Dice
+        metrics = evaluate_mask(pred_mask, gt_mask)
+
+        # Check if passes evaluation thresholds
+        passed = metrics["IoU"] >= iou_threshold and metrics["Dice"] >= dice_threshold
+        status = "✅ Passed" if passed else "❌ Failed"
+
+        print(f"{filename:20s} | IoU: {metrics['IoU']:.3f} | Dice: {metrics['Dice']:.3f} | {status}")
+        all_metrics.append(metrics)
+
+    # If no files were evaluated, notify user
+    if not all_metrics:
+        print("\n⚠️ No valid image pairs found for evaluation, please check folder paths.")
+        process_result["Process"] = False
+        process_result["comments"] = "No valid image pairs for evaluation"
+        save_result(result_file, process_result)
+        return
+
+    # Calculate average results across all files
+    avg_metrics = {k: np.mean([m[k] for m in all_metrics]) for k in all_metrics[0].keys()}
+    print("\n📊 Overall average results:")
+    print(f"Average IoU: {avg_metrics['IoU']:.3f}")
+    print(f"Average Dice: {avg_metrics['Dice']:.3f}")
+
+    # Determine final result
+    if avg_metrics["IoU"] >= iou_threshold and avg_metrics["Dice"] >= dice_threshold:
+        process_result["Result"] = True
+        process_result[
+            "comments"] = f"All images passed, average IoU: {avg_metrics['IoU']:.3f}, average Dice: {avg_metrics['Dice']:.3f}"
+        print(f"✅ Test passed!")
+    else:
+        process_result["Result"] = False
+        process_result[
+            "comments"] = f"Test failed, average IoU: {avg_metrics['IoU']:.3f}, average Dice: {avg_metrics['Dice']:.3f}"
+        print(f"❌ Test failed")
+
+    save_result(result_file, process_result)
+
+
+def save_result(result_file, result):
+    # Save test results to jsonl file, append if file exists
+    if result_file:
+        try:
+            with open(result_file, "a", encoding="utf-8") as f:
+                f.write(json.dumps(result, default=str) + "\n")
+        except Exception as e:
+            print(f"⚠️ Error writing result file: {e}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--output', type=str, required=True, help="Folder containing predicted mask images")
+    parser.add_argument('--groundtruth', type=str, required=True, help="Folder containing ground truth mask images")
+    parser.add_argument('--result', type=str, required=True, help="Path to jsonl file for storing test results")
+    args = parser.parse_args()
+
+    main(args.output, args.groundtruth, result_file=args.result)

test_scripts/DeScratch_03/test_script.py

@@ -0,0 +1,97 @@
+import os
+import argparse
+import cv2
+import numpy as np
+import json
+from datetime import datetime
+from skimage.metrics import peak_signal_noise_ratio as psnr
+from skimage.metrics import structural_similarity as ssim
+import glob
+
+def find_single_image(directory, pattern):
+    """Find single image file in specified directory using glob pattern."""
+    files = glob.glob(os.path.join(directory, pattern))
+    if len(files) == 1:
+        return files[0]
+    elif len(files) == 0:
+        print(f"⚠️ No matching {pattern} image found in {directory}")
+    else:
+        print(f"⚠️ Multiple matching {pattern} images found in {directory}")
+    return None
+
+def evaluate_quality(pred_dir, gt_dir, threshold_ssim=0.65, threshold_psnr=15, result_file=None):
+    result = {
+        "Process": True,
+        "Result": False,
+        "TimePoint": datetime.now().strftime("%Y-%m-%dT%H:%M:%S"),
+        "comments": ""
+    }
+
+    print(f"\nStarting evaluation task:")
+    print(f"Predicted images path: {pred_dir}")
+    print(f"Ground truth images path: {gt_dir}\n")
+
+    if not os.path.exists(pred_dir) or not os.path.exists(gt_dir):
+        result["Process"] = False
+        result["comments"] = "Path does not exist"
+        print("❌ Path does not exist")
+        save_result(result_file, result)
+        return
+
+    pred_path = find_single_image(pred_dir, "output.*")
+    gt_path = find_single_image(gt_dir, "gt.*")
+
+    if not pred_path or not gt_path:
+        result["Process"] = False
+        result["comments"] = "Predicted or GT image missing or multiple matches"
+        save_result(result_file, result)
+        return
+
+    pred_img = cv2.imread(pred_path)
+    gt_img = cv2.imread(gt_path)
+
+    if pred_img is None or gt_img is None:
+        result["Process"] = False
+        result["comments"] = "Failed to read images"
+        print("⚠️ Failed to read images")
+        save_result(result_file, result)
+        return
+
+    pred_img = cv2.resize(pred_img, (gt_img.shape[1], gt_img.shape[0]))
+    pred_gray = cv2.cvtColor(pred_img, cv2.COLOR_BGR2GRAY)
+    gt_gray = cv2.cvtColor(gt_img, cv2.COLOR_BGR2GRAY)
+
+    ssim_val = ssim(gt_gray, pred_gray)
+    psnr_val = psnr(gt_gray, pred_gray)
+
+    print(f"Structural Similarity (SSIM): {ssim_val:.4f}")
+    print(f"Peak Signal-to-Noise Ratio (PSNR): {psnr_val:.2f}")
+
+    if ssim_val >= threshold_ssim and psnr_val >= threshold_psnr:
+        result["Result"] = True
+        result["comments"] = f"Test passed, SSIM={ssim_val:.4f}, PSNR={psnr_val:.2f}"
+        print("✅ Restoration quality meets requirements")
+    else:
+        result["Result"] = False
+        result["comments"] = f"Test failed, SSIM={ssim_val:.4f}, PSNR={psnr_val:.2f}"
+        print("❌ Restoration quality does not meet requirements")
+
+    save_result(result_file, result)
+
+def save_result(result_file, result):
+    if result_file:
+        try:
+            with open(result_file, "a", encoding="utf-8") as f:
+                f.write(json.dumps(result, ensure_ascii=False) + "\n")
+            print(f"[Success] Output file: {result_file}")
+        except Exception as e:
+            print(f"⚠️ Failed to write result file: {e}")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--output', type=str, required=True, help='Predicted results folder')
+    parser.add_argument('--groundtruth', type=str, required=True, help='Original GT folder')
+    parser.add_argument('--result', type=str, required=True, help='Output JSONL file for results')
+    args = parser.parse_args()
+
+    evaluate_quality(args.output, args.groundtruth, result_file=args.result)

test_scripts/Eparse_01/test_script.py

@@ -0,0 +1,418 @@
+import argparse
+import csv
+import json
+import os
+import re
+from datetime import datetime
+from collections import defaultdict
+
+
+def load_txt_file(file_path):
+    """Load TXT file content"""
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            content = f.read()
+        return content, None
+    except Exception as e:
+        return "", str(e)
+
+
+def extract_file_blocks(content):
+    """Extract filename and corresponding table data blocks from TXT content"""
+    file_blocks = {}
+    current_file = None
+    current_block = []
+
+    # Attempt to split content using filename markers
+    lines = content.strip().split('\n')
+    i = 0
+    while i < len(lines):
+        line = lines[i].strip()
+
+        # Detect filename line - supports multiple possible formats
+        file_name_match = None
+        if line.startswith("文件名:") or line.startswith("File name:"):
+            file_name_match = re.search(r'(?:文件名|File name):?\s*(.+?)(?:\s|$)', line)
+        elif "文件名" in line:
+            file_name_match = re.search(r'.*文件名:?\s*(.+?)(?:\s|$)', line)
+        elif re.match(r'^[^:]*\.xlsx?\s*$', line):  # Case of direct filename.xls(x)
+            file_name_match = re.match(r'^([^:]*\.xlsx?)$', line)
+
+        if file_name_match:
+            # If we have a current file, save its data block
+            if current_file and current_block:
+                file_blocks[current_file] = '\n'.join(current_block)
+
+            # Extract new filename
+            current_file = file_name_match.group(1).strip()
+            current_block = []
+        elif current_file is not None:
+            # Add to current block
+            current_block.append(line)
+
+        i += 1
+
+    # Process last file block
+    if current_file and current_block:
+        file_blocks[current_file] = '\n'.join(current_block)
+
+    return file_blocks
+
+
+def parse_table_content(block_content):
+    """Parse table block content to extract data structure"""
+    sheets_data = []
+    current_sheet = []
+
+    lines = block_content.split('\n')
+    i = 0
+    in_sheet = False
+
+    while i < len(lines):
+        line = lines[i].strip()
+
+        # Skip empty lines
+        if not line:
+            i += 1
+            continue
+
+        # Detect Sheet marker
+        sheet_match = re.search(r'Sheet:?', line)
+        if sheet_match:
+            # If new Sheet found, save previous sheet data
+            if in_sheet and current_sheet:
+                sheets_data.append(current_sheet)
+                current_sheet = []
+
+            in_sheet = True
+            i += 1
+            continue
+
+        # Process data rows
+        if in_sheet or not sheets_data:  # Also try parsing if no explicit Sheet markers
+            # Clean line numbers
+            cleaned_line = re.sub(r'^\d+\s+', '', line)
+
+            # Split cell data
+            # First try tab or multiple spaces
+            cells = re.split(r'\s{2,}|\t', cleaned_line)
+
+            # If only one element after split, try single space
+            if len(cells) <= 1:
+                cells = re.split(r'\s+', cleaned_line)
+
+            if cells:
+                current_sheet.append(cells)
+
+        i += 1
+
+    # Save last sheet
+    if current_sheet:
+        sheets_data.append(current_sheet)
+
+    # If no explicit sheet separation but has data, treat as single sheet
+    if not sheets_data and lines:
+        # Re-parse as single sheet
+        current_sheet = []
+        for line in lines:
+            if line.strip():
+                # Clean line numbers
+                cleaned_line = re.sub(r'^\d+\s+', '', line)
+                # Split cells
+                cells = re.split(r'\s{2,}|\t', cleaned_line)
+                if len(cells) <= 1:
+                    cells = re.split(r'\s+', cleaned_line)
+                if cells:
+                    current_sheet.append(cells)
+
+        if current_sheet:
+            sheets_data.append(current_sheet)
+
+    return sheets_data
+
+
+def normalize_value(value):
+    """Normalize cell value, handling various format differences"""
+    # Convert to string and strip whitespace
+    value_str = str(value).strip()
+
+    # Standardize date formats
+    date_match = re.match(r'(\d{4}[-/]\d{1,2}[-/]\d{1,2})(?:\s+\d{1,2}:\d{1,2}(?::\d{1,2})?)?', value_str)
+    if date_match:
+        # Extract date part
+        date_part = date_match.group(1)
+        # Unify separator to -
+        date_part = date_part.replace('/', '-')
+        # Ensure yyyy-mm-dd format
+        date_parts = date_part.split('-')
+        if len(date_parts) == 3:
+            year = date_parts[0]
+            month = date_parts[1].zfill(2)
+            day = date_parts[2].zfill(2)
+            value_str = f"{year}-{month}-{day}"
+
+    # Standardize number formats
+    number_match = re.match(r'^[-+]?\d+(?:\.\d+)?$', value_str)
+    if number_match:
+        try:
+            # Try converting to float, then remove trailing zeros
+            num_value = float(value_str)
+            # If integer, remove decimal point
+            if num_value.is_integer():
+                value_str = str(int(num_value))
+            else:
+                value_str = str(num_value).rstrip('0').rstrip('.')
+        except:
+            pass
+
+    return value_str
+
+
+def calculate_sheet_similarity(pred_sheet, truth_sheet):
+    """Calculate content similarity between two sheets"""
+    # Normalize all cell values
+    pred_values = set()
+    truth_values = set()
+
+    # Process prediction data
+    for row in pred_sheet:
+        for cell in row:
+            normalized = normalize_value(cell)
+            if normalized:  # Ignore empty cells
+                pred_values.add(normalized)
+
+    # Process ground truth data
+    for row in truth_sheet:
+        for cell in row:
+            normalized = normalize_value(cell)
+            if normalized:  # Ignore empty cells
+                truth_values.add(normalized)
+
+    # Calculate intersection and union
+    intersection = pred_values.intersection(truth_values)
+    union = pred_values.union(truth_values)
+
+    # Jaccard similarity
+    if not union:
+        return 0.0
+
+    similarity = len(intersection) / len(union) * 100
+    return similarity
+
+
+def evaluate_file_similarity(pred_sheets, truth_sheets):
+    """Evaluate file similarity"""
+    if not pred_sheets or not truth_sheets:
+        return 0.0
+
+    # Calculate similarity for each sheet
+    total_similarity = 0.0
+    sheet_count = min(len(pred_sheets), len(truth_sheets))
+
+    for i in range(sheet_count):
+        sheet_similarity = calculate_sheet_similarity(
+            pred_sheets[i],
+            truth_sheets[i]
+        )
+        total_similarity += sheet_similarity
+
+    # Average similarity
+    avg_similarity = total_similarity / sheet_count if sheet_count > 0 else 0.0
+
+    # Reduce similarity if sheet counts differ
+    sheet_diff_penalty = abs(len(pred_sheets) - len(truth_sheets)) * 5  # 5% reduction per extra/missing sheet
+    final_similarity = max(0, avg_similarity - sheet_diff_penalty)
+
+    return final_similarity
+
+
+def evaluate(pred_file, truth_file):
+    """Evaluation function"""
+    pred_content, pred_err = load_txt_file(pred_file)
+    truth_content, truth_err = load_txt_file(truth_file)
+
+    process_ok = True
+    comments = []
+
+    # Read error checking
+    if pred_err:
+        comments.append(f"[Prediction file read error] {pred_err}")
+        process_ok = False
+    if truth_err:
+        comments.append(f"[GT file read error] {truth_err}")
+        process_ok = False
+    if not process_ok:
+        return {
+            "Process": False,
+            "Result": False,
+            "TimePoint": datetime.now().isoformat(),
+            "comments": "\n".join(comments)
+        }
+
+    # Extract file blocks
+    pred_file_blocks = extract_file_blocks(pred_content)
+    truth_file_blocks = extract_file_blocks(truth_content)
+
+    # Filename comparison
+    pred_files = set(pred_file_blocks.keys())
+    truth_files = set(truth_file_blocks.keys())
+
+    comments.append(f"Prediction file contains {len(pred_files)} Excel data blocks")
+    comments.append(f"GT file contains {len(truth_files)} Excel data blocks")
+
+    if len(pred_files) == 0:
+        comments.append("⚠️ No Excel data blocks found in prediction file!")
+        return {
+            "Process": True,
+            "Result": False,
+            "TimePoint": datetime.now().isoformat(),
+            "comments": "\n".join(comments)
+        }
+
+    if len(truth_files) == 0:
+        comments.append("⚠️ No Excel data blocks found in GT file!")
+        return {
+            "Process": True,
+            "Result": False,
+            "TimePoint": datetime.now().isoformat(),
+            "comments": "\n".join(comments)
+        }
+
+    # Calculate file matching
+    common_files = pred_files.intersection(truth_files)
+    missing_files = truth_files - pred_files
+    extra_files = pred_files - truth_files
+
+    # Filename match rate
+    file_match_rate = len(common_files) / len(truth_files) * 100 if truth_files else 0
+    comments.append(f"Filename match rate: {file_match_rate:.2f}%")
+
+    if missing_files:
+        comments.append(f"Missing files: {', '.join(missing_files)}")
+    if extra_files:
+        comments.append(f"Extra files: {', '.join(extra_files)}")
+
+    # Content similarity scoring
+    total_similarity = 0.0
+    file_count = 0
+
+    # Process exactly matched filenames
+    for file_name in common_files:
+        pred_content_block = pred_file_blocks[file_name]
+        truth_content_block = truth_file_blocks[file_name]
+
+        # Parse table content
+        pred_sheets = parse_table_content(pred_content_block)
+        truth_sheets = parse_table_content(truth_content_block)
+
+        # Calculate file similarity
+        file_similarity = evaluate_file_similarity(pred_sheets, truth_sheets)
+
+        comments.append(f"File '{file_name}' content similarity: {file_similarity:.2f}%")
+        total_similarity += file_similarity
+        file_count += 1
+
+    # Attempt to match files with slightly different names by content
+    if missing_files and extra_files:
+        for missing_file in list(missing_files):
+            best_match = None
+            best_similarity = 0
+
+            truth_content_block = truth_file_blocks[missing_file]
+            truth_sheets = parse_table_content(truth_content_block)
+
+            for extra_file in list(extra_files):
+                pred_content_block = pred_file_blocks[extra_file]
+                pred_sheets = parse_table_content(pred_content_block)
+
+                similarity = evaluate_file_similarity(pred_sheets, truth_sheets)
+                if similarity > best_similarity and similarity > 60:  # Require at least 60% similarity
+                    best_similarity = similarity
+                    best_match = extra_file
+
+            if best_match:
+                comments.append(
+                    f"Different filenames but similar content: '{missing_file}' and '{best_match}', similarity: {best_similarity:.2f}%")
+                total_similarity += best_similarity
+                file_count += 1
+                missing_files.remove(missing_file)
+                extra_files.remove(best_match)
+
+    # Calculate average file similarity
+    avg_similarity = total_similarity / len(truth_files) if truth_files else 0
+
+    # Penalize for missing files
+    if missing_files:
+        missing_penalty = len(missing_files) / len(truth_files) * 100
+        comments.append(f"Score reduction for missing files: -{missing_penalty:.2f}%")
+        avg_similarity = max(0, avg_similarity - missing_penalty)
+
+    comments.append(f"Average content similarity across all files: {avg_similarity:.2f}%")
+
+    # File match and content similarity weights
+    file_match_weight = 0.3
+    content_similarity_weight = 0.7
+
+    # Final score
+    final_score = (file_match_rate * file_match_weight + avg_similarity * content_similarity_weight)
+    passed = final_score >= 75
+
+    comments.append(
+        f"Final score (filename match {file_match_weight * 100}% + content similarity {content_similarity_weight * 100}%): {final_score:.2f}% (threshold=75%)")
+
+    if passed:
+        comments.append("✅ Test passed!")
+    else:
+        comments.append("❌ Test failed!")
+
+    # If structured parsing fails, try basic content comparison
+    if file_count == 0:
+        comments.append("Note: No matches found in structured parsing, attempting basic content comparison")
+
+        # Calculate word overlap in full content
+        pred_words = set(re.findall(r'\b\w+\b', pred_content.lower()))
+        truth_words = set(re.findall(r'\b\w+\b', truth_content.lower()))
+
+        common_words = pred_words.intersection(truth_words)
+        all_words = pred_words.union(truth_words)
+
+        if all_words:
+            word_overlap = len(common_words) / len(all_words) * 100
+            comments.append(f"Content word overlap: {word_overlap:.2f}%")
+
+            # Pass if high word overlap
+            if word_overlap >= 75:
+                comments.append("Based on word overlap: ✅ Test passed!")
+                return {
+                    "Process": True,
+                    "Result": True,
+                    "TimePoint": datetime.now().isoformat(),
+                    "comments": "\n".join(comments)
+                }
+
+    return {
+        "Process": True,
+        "Result": passed,
+        "TimePoint": datetime.now().isoformat(),
+        "comments": "\n".join(comments)
+    }
+
+
+def append_result_to_jsonl(result_path, result_dict):
+    os.makedirs(os.path.dirname(result_path) or '.', exist_ok=True)
+    with open(result_path, "a", encoding="utf-8") as f:
+        json.dump(result_dict, f, ensure_ascii=False, default=str)
+        f.write("\n")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--output", type=str, required=True, help="Path to extracted tables")
+    parser.add_argument("--groundtruth", type=str, required=True, help="Path to standard tables")
+    parser.add_argument("--result", type=str, required=True, help="Output JSONL file path for results")
+    args = parser.parse_args()
+
+    result_dict = evaluate(args.output, args.groundtruth)
+    append_result_to_jsonl(args.result, result_dict)
+    print("[Evaluation complete] Result summary:")
+    print(json.dumps(result_dict, ensure_ascii=False, indent=2, default=str))

test_scripts/Eparse_02/test_script.py

@@ -0,0 +1,360 @@
+import argparse
+import json
+import os
+import re
+from datetime import datetime
+from ast import literal_eval
+import traceback
+
+
+def normalize_json_item(item):
+    """
+    Normalize JSON objects to remove format differences
+    """
+    if isinstance(item, str):
+        # Try parsing string as dictionary
+        try:
+            item = json.loads(item)
+        except:
+            try:
+                # Try parsing non-standard JSON with ast.literal_eval
+                item = literal_eval(item)
+            except:
+                # Return original string if parsing fails
+                return item
+
+    # Ensure all keys are strings
+    result = {}
+    for k, v in item.items():
+        # Convert key to string and strip whitespace
+        key = str(k).strip().lower()
+        # Process value
+        if isinstance(v, str):
+            # Strip whitespace and lowercase string values (except for type field)
+            if key == 'type':
+                value = v.strip()  # Preserve case for type field
+            else:
+                value = v.strip().lower()
+        else:
+            value = v
+        result[key] = value
+
+    return result
+
+
+def parse_gt_format(content):
+    """
+    Special parser for gt.txt format
+    Features multi-line dictionaries separated by commas
+    """
+    items = []
+    # Replace all newlines to make content single line
+    content = content.replace('\n', ' ')
+
+    # Try parsing as list
+    try:
+        # If content is wrapped in brackets, remove them
+        if content.strip().startswith('[') and content.strip().endswith(']'):
+            content = content.strip()[1:-1]
+
+        # Split multiple dictionaries (each starts with { and ends with }, or })
+        dict_pattern = r'\{[^{}]*\}'
+        dict_matches = re.findall(dict_pattern, content)
+
+        for dict_str in dict_matches:
+            try:
+                item = literal_eval(dict_str)
+                items.append(normalize_json_item(item))
+            except Exception as e:
+                print(f"Failed to parse dictionary: {dict_str[:50]}... Error: {e}")
+    except Exception as e:
+        print(f"Failed to parse gt format: {e}")
+
+    print(f"Parsed {len(items)} items from gt format")
+    return items
+
+
+def parse_json_line_format(content):
+    """
+    Parse format with one JSON object per line
+    """
+    items = []
+    lines = content.split('\n')
+
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+
+        try:
+            # Try parsing as JSON object
+            item = json.loads(line)
+            items.append(normalize_json_item(item))
+        except:
+            try:
+                # Try parsing non-standard JSON with ast.literal_eval
+                item = literal_eval(line)
+                items.append(normalize_json_item(item))
+            except Exception as e:
+                print(f"Unable to parse line: {line[:50]}... Error: {e}")
+
+    print(f"Parsed {len(items)} items from JSON line format")
+    return items
+
+
+def load_json_items(file_path):
+    """
+    Read file containing JSON objects, return normalized list
+    Supports multiple formats: JSON per line, single JSON array, list of dicts, multi-line dict format
+    """
+    print(f"Parsing file: {file_path}")
+    items = []
+
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            content = f.read().strip()
+
+            # Check if file is empty
+            if not content:
+                print("File is empty")
+                return items
+
+            # 1. First try gt.txt specific format
+            if "{'c_header':" in content or '{"c_header":' in content or "'c_header':" in content:
+                print("Detected gt.txt format, using specialized parser")
+                items = parse_gt_format(content)
+                if items:
+                    return items
+
+            # 2. Try parsing as JSON array
+            if content.startswith('[') and content.endswith(']'):
+                try:
+                    array_items = json.loads(content)
+                    for item in array_items:
+                        items.append(normalize_json_item(item))
+                    print(f"Parsed {len(items)} items from JSON array")
+                    return items
+                except Exception as e:
+                    print(f"JSON array parsing failed: {e}")
+
+                    # Try Python list literal
+                    try:
+                        array_items = literal_eval(content)
+                        for item in array_items:
+                            items.append(normalize_json_item(item))
+                        print(f"Parsed {len(items)} items from Python list")
+                        return items
+                    except Exception as e:
+                        print(f"Python list parsing failed: {e}")
+
+            # 3. Try parsing JSON objects line by line
+            items = parse_json_line_format(content)
+            if items:
+                return items
+
+            # 4. Finally try extracting all possible dictionaries
+            print("Attempting to extract all possible dictionaries...")
+            dict_pattern = r'\{[^{}]*\}'
+            dicts = re.findall(dict_pattern, content)
+            for d in dicts:
+                try:
+                    item = literal_eval(d)
+                    items.append(normalize_json_item(item))
+                except Exception as e:
+                    print(f"Dictionary extraction failed: {d[:30]}... Error: {e}")
+
+            if items:
+                print(f"Parsed {len(items)} items from dictionary extraction")
+                return items
+
+    except Exception as e:
+        print(f"Error reading file: {e}")
+        traceback.print_exc()
+
+    return items
+
+
+def compare_items(pred_items, gt_items):
+    """
+    Compare predicted items with ground truth items, calculate match rate for key fields
+    """
+    if not pred_items or not gt_items:
+        return 0, "No valid items to compare"
+
+    print(f"Comparing {len(pred_items)} predicted items with {len(gt_items)} ground truth items")
+
+    # List of key fields we consider more important
+    key_fields = ['value', 'row', 'column', 'excel_rc', 'c_header', 'r_header', 'sheet', 'f_name']
+
+    total_matches = 0
+    total_fields = 0
+    missing_items = 0
+
+    # Number of items to match (based on smaller set)
+    expected_matches = min(len(pred_items), len(gt_items))
+
+    # If predicted items are fewer than ground truth, record missing count
+    if len(pred_items) < len(gt_items):
+        missing_items = len(gt_items) - len(pred_items)
+
+    # Print sample data for debugging
+    print("Predicted items sample:")
+    for i, item in enumerate(pred_items[:2]):
+        print(f"  Item {i}: {item}")
+
+    print("Ground truth items sample:")
+    for i, item in enumerate(gt_items[:2]):
+        print(f"  Item {i}: {item}")
+
+    # Compare item by item
+    for i in range(min(len(pred_items), len(gt_items))):
+        pred_item = pred_items[i]
+        gt_item = gt_items[i]
+
+        item_matches = 0
+        item_fields = 0
+
+        # Compare key fields
+        for field in key_fields:
+            # For predicted item, try to match different case variations
+            pred_fields = [f.lower() for f in pred_item.keys()]
+            pred_field_key = None
+
+            # Find matching field (case insensitive)
+            if field in pred_item:
+                pred_field_key = field
+            else:
+                for k in pred_item.keys():
+                    if k.lower() == field.lower():
+                        pred_field_key = k
+                        break
+
+            # For ground truth item, also try to match different case variations
+            gt_field_key = None
+            if field in gt_item:
+                gt_field_key = field
+            else:
+                for k in gt_item.keys():
+                    if k.lower() == field.lower():
+                        gt_field_key = k
+                        break
+
+            # If both have the field, compare
+            if pred_field_key is not None and gt_field_key is not None:
+                item_fields += 1
+                pred_value = pred_item[pred_field_key]
+                gt_value = gt_item[gt_field_key]
+
+                # Case insensitive comparison for excel_rc field
+                if field.lower() == 'excel_rc':
+                    if str(pred_value).upper() == str(gt_value).upper():
+                        item_matches += 1
+                # Numeric comparison for numeric fields
+                elif field.lower() in ['row', 'column'] and isinstance(pred_value, (int, float)) and isinstance(
+                        gt_value, (int, float)):
+                    if pred_value == gt_value:
+                        item_matches += 1
+                # Special handling for type field
+                elif field.lower() == 'type':
+                    # Extract type name, ignoring quotes and class parts
+                    pred_type = re.sub(r"[<>'\"]|class\s+", "", str(pred_value)).strip()
+                    gt_type = re.sub(r"[<>'\"]|class\s+", "", str(gt_value)).strip()
+                    if pred_type == gt_type:
+                        item_matches += 1
+                # Standardized comparison for other fields
+                elif str(pred_value).lower() == str(gt_value).lower():
+                    item_matches += 1
+
+        # Add to total matches
+        if item_fields > 0:
+            total_matches += item_matches
+            total_fields += item_fields
+
+    # Calculate match rate
+    if total_fields == 0:
+        accuracy = 0
+        details = "No valid fields found for comparison"
+    else:
+        accuracy = total_matches / total_fields
+        details = f"Matched fields: {total_matches}/{total_fields}"
+
+        # Apply penalty if missing items
+        if missing_items > 0:
+            penalty = min(0.2, missing_items / len(gt_items) * 0.5)  # Max 20% penalty
+            accuracy = max(0, accuracy - penalty)
+            details += f", Missing items: {missing_items}, applied {penalty:.2f} penalty"
+
+    return accuracy, details
+
+
+def evaluate(pred_path, gt_path):
+    """Evaluate based on parsed content"""
+    threshold = 0.70  # Fixed threshold
+
+    # Load and normalize data
+    pred_items = load_json_items(pred_path)
+    gt_items = load_json_items(gt_path)
+
+    # Initialize result dictionary
+    result = {
+        "Process": True,
+        "Result": False,
+        "TimePoint": datetime.now().strftime("%Y-%m-%dT%H:%M:%S"),
+        "comments": ""
+    }
+
+    # Check if input files are valid
+    if not pred_items:
+        result["Process"] = False
+        result["comments"] = "Predicted file parsed as empty, cannot evaluate!"
+        return result
+
+    if not gt_items:
+        result["Process"] = False
+        result["comments"] = "❌ Ground truth parsed as empty!"
+        result["Result"] = False
+        return result
+
+    # Compare items and calculate match rate
+    accuracy, details = compare_items(pred_items, gt_items)
+
+    # Determine result based on accuracy
+    if accuracy >= threshold:
+        result["Result"] = True
+        result["comments"] = f"✅ Test passed! Content match rate={accuracy:.4f} ≥ {threshold}. {details}"
+    else:
+        result["Result"] = False
+        result["comments"] = f"❌ Test failed. Content match rate={accuracy:.4f} < {threshold}. {details}"
+
+    print(result["comments"])
+    return result
+
+
+def save_result(result, result_file):
+    """Save results to jsonl file"""
+    # Ensure directory exists
+    os.makedirs(os.path.dirname(result_file) or '.', exist_ok=True)
+
+    # Write in append mode, ensuring each record is on separate line
+    with open(result_file, "a", encoding="utf-8") as f:
+        f.write(json.dumps(result, ensure_ascii=False) + "\n")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Evaluate Excel cell parsing output by content similarity and save results")
+    parser.add_argument("--output", required=True, help="Predicted output file path")
+    parser.add_argument("--groundtruth", required=True, help="Ground truth file path")
+    parser.add_argument("--result", required=True, help="Result output file path (JSONL format)")
+    args = parser.parse_args()
+
+    # Get evaluation result
+    result = evaluate(args.output, args.groundtruth)
+
+    # Save result to specified jsonl file
+    save_result(result, args.result)
+    print(f"Results saved to {args.result}")
+
+
+if __name__ == "__main__":
+    main()

test_scripts/Eparse_03/test_script.py

@@ -0,0 +1,224 @@
+import argparse
+import json
+import os
+import datetime
+import re
+from collections import defaultdict
+
+
+def normalize_value(value):
+    """Standardize values to handle consistency between numbers and strings"""
+    if value is None:
+        return "null"
+    if isinstance(value, (int, float)):
+        return str(value)
+    return str(value).strip()
+
+
+def extract_cell_data(json_data):
+    """Extract cell data from different JSON structures, returning standardized cell collections"""
+    cells = []
+
+    # Handle GT format
+    if isinstance(json_data, dict) and "sheets" in json_data:
+        for sheet_name, sheet_data in json_data["sheets"].items():
+            for row in sheet_data.get("rows", []):
+                row_index = row.get("row_index", 0)
+                for cell in row.get("cells", []):
+                    cells.append({
+                        "row": row_index,
+                        "column": cell.get("column_index"),
+                        "value": normalize_value(cell.get("value")),
+                        "excel_RC": cell.get("excel_RC"),
+                        "c_header": cell.get("c_header"),
+                        "r_header": cell.get("r_header"),
+                        "type": cell.get("type")
+                    })
+
+    # Handle Agent output format
+    elif isinstance(json_data, list):
+        for table in json_data:
+            for cell in table.get("data", []):
+                cells.append({
+                    "row": cell.get("row"),
+                    "column": cell.get("column"),
+                    "value": normalize_value(cell.get("value")),
+                    "excel_RC": cell.get("excel_RC"),
+                    "c_header": cell.get("c_header"),
+                    "r_header": cell.get("r_header"),
+                    "type": cell.get("type")
+                })
+
+    # Handle other possible formats
+    else:
+        try:
+            # Attempt recursive search for all cell-like data structures
+            def find_cells(obj, path=""):
+                if isinstance(obj, dict):
+                    # Check if it's a cell structure
+                    if all(k in obj for k in ["row", "column", "value"]) or \
+                            all(k in obj for k in ["row_index", "column_index", "value"]):
+                        row = obj.get("row", obj.get("row_index", 0))
+                        column = obj.get("column", obj.get("column_index", 0))
+                        cells.append({
+                            "row": row,
+                            "column": column,
+                            "value": normalize_value(obj.get("value")),
+                            "excel_RC": obj.get("excel_RC", f"{chr(65 + column)}{row + 1}"),
+                            "c_header": obj.get("c_header", str(column + 1)),
+                            "r_header": obj.get("r_header", str(row + 1)),
+                            "type": obj.get("type", "")
+                        })
+                    else:
+                        for k, v in obj.items():
+                            find_cells(v, f"{path}.{k}" if path else k)
+                elif isinstance(obj, list):
+                    for i, item in enumerate(obj):
+                        find_cells(item, f"{path}[{i}]")
+
+            find_cells(json_data)
+        except Exception as e:
+            print(f"Failed to parse JSON structure: {str(e)}")
+
+    return cells
+
+
+def compute_cell_similarity(cells1, cells2):
+    """Calculate similarity between two cell collections"""
+    if not cells1 and not cells2:
+        return 1.0  # Both empty, consider perfect match
+
+    if not cells1 or not cells2:
+        return 0.0  # One empty, the other not
+
+    # Create position-to-cell mappings
+    cells1_dict = {(cell["row"], cell["column"]): cell for cell in cells1}
+    cells2_dict = {(cell["row"], cell["column"]): cell for cell in cells2}
+
+    # Get all unique cell positions
+    all_positions = set(cells1_dict.keys()) | set(cells2_dict.keys())
+
+    # Calculate matched cell count
+    matches = 0
+    total_weight = 0
+
+    for pos in all_positions:
+        weight = 1  # Cell weight
+        total_weight += weight
+
+        if pos in cells1_dict and pos in cells2_dict:
+            cell1 = cells1_dict[pos]
+            cell2 = cells2_dict[pos]
+
+            # Compare values
+            if normalize_value(cell1["value"]) == normalize_value(cell2["value"]):
+                matches += 0.6 * weight  # Value match contributes 60% weight
+
+            # Compare other metadata (10% weight each)
+            for key in ["excel_RC", "c_header", "r_header", "type"]:
+                if key in cell1 and key in cell2 and normalize_value(cell1[key]) == normalize_value(cell2[key]):
+                    matches += 0.1 * weight
+
+    similarity = matches / total_weight if total_weight > 0 else 0
+    return similarity
+
+
+def is_valid_file(file_path):
+    """Check if file exists and is not empty"""
+    return os.path.isfile(file_path) and os.path.getsize(file_path) > 0
+
+
+def evaluate(pred_file, gt_file):
+    """Read files and calculate similarity"""
+    try:
+        with open(pred_file, 'r', encoding='utf-8') as f_pred:
+            pred_text = f_pred.read()
+        with open(gt_file, 'r', encoding='utf-8') as f_gt:
+            gt_text = f_gt.read()
+    except Exception as e:
+        return None, f"❌ File read error: {str(e)}"
+
+    try:
+        # Parse JSON
+        pred_json = json.loads(pred_text)
+        gt_json = json.loads(gt_text)
+
+        # Extract cell data
+        pred_cells = extract_cell_data(pred_json)
+        gt_cells = extract_cell_data(gt_json)
+
+        # Calculate cell content similarity
+        similarity = compute_cell_similarity(pred_cells, gt_cells)
+
+        return similarity, f"✅ Similarity calculation complete: {similarity:.4f} ({len(gt_cells)} GT cells, {len(pred_cells)} predicted cells)"
+    except json.JSONDecodeError:
+        # Fallback to Levenshtein similarity if JSON parsing fails
+        try:
+            import Levenshtein
+            levenshtein_distance = Levenshtein.distance(pred_text, gt_text)
+            similarity = 1 - levenshtein_distance / max(len(pred_text), len(gt_text))
+            return similarity, f"⚠️ JSON parsing failed, using Levenshtein similarity: {similarity:.4f}"
+        except ImportError:
+            return 0.0, "❌ JSON parsing failed and Levenshtein library unavailable"
+    except Exception as e:
+        return 0.0, f"❌ Evaluation process error: {str(e)}"
+
+
+def save_result(result_path, data):
+    """Save results to jsonl file"""
+    os.makedirs(os.path.dirname(result_path) or '.', exist_ok=True)
+    with open(result_path, "a", encoding="utf-8") as f:
+        f.write(json.dumps(data, ensure_ascii=False, default=str) + "\n")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Compare similarity between predicted and ground truth Excel JSON data.")
+    parser.add_argument('--output', required=True, help="Path to predicted JSON file.")
+    parser.add_argument('--groundtruth', required=True, help="Path to ground truth JSON file.")
+    parser.add_argument('--result', required=True, help="Path to save evaluation results (.jsonl).")
+    args = parser.parse_args()
+
+    result_dict = {
+        "Process": False,
+        "Result": False,
+        "TimePoint": datetime.datetime.now().isoformat(),
+        "comments": ""
+    }
+
+    # Step 1: Check if files exist and are not empty
+    if not is_valid_file(args.output):
+        result_dict["comments"] = "❌ Prediction file does not exist or is empty"
+        save_result(args.result, result_dict)
+        print(result_dict["comments"])
+        return
+
+    if not is_valid_file(args.groundtruth):
+        result_dict["comments"] = "❌ GT file does not exist or is empty"
+        save_result(args.result, result_dict)
+        print(result_dict["comments"])
+        return
+
+    result_dict["Process"] = True
+
+    # Step 2: Evaluate similarity
+    similarity, msg = evaluate(args.output, args.groundtruth)
+    if similarity is None:
+        result_dict["comments"] = msg
+        save_result(args.result, result_dict)
+        print(msg)
+        return
+
+    result_dict["comments"] = msg
+    result_dict["Result"] = similarity >= 0.8
+    save_result(args.result, result_dict)
+
+    print(msg)
+    if result_dict["Result"]:
+        print("✅ Passed: Similarity ≥ 0.8")
+    else:
+        print("❌ Failed: Similarity < 0.8")
+
+
+if __name__ == "__main__":
+    main()

test_scripts/Faker_01/test_script.py

@@ -0,0 +1,78 @@
+import csv
+import re
+import argparse
+import os
+import json
+from datetime import datetime
+
+def validate_fake_users(file_path):
+    email_pattern = r'^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$'
+    comments = []
+    process_ok = True
+    result_ok = False
+
+    if not os.path.isfile(file_path):
+        comments.append(f"[Error] File does not exist: {file_path}")
+        process_ok = False
+    elif os.path.getsize(file_path) == 0:
+        comments.append(f"[Error] File is empty: {file_path}")
+        process_ok = False
+
+    if process_ok:
+        try:
+            with open(file_path, 'r', encoding='utf-8') as file:
+                reader = csv.DictReader(file)
+                fieldnames = reader.fieldnames or []
+
+                if 'Username' not in fieldnames or 'Email' not in fieldnames:
+                    comments.append(f"[Error] Required columns missing. Found: {fieldnames}")
+                    process_ok = False
+                else:
+                    row_count = 0
+                    for idx, row in enumerate(reader):
+                        email = row.get('Email', '')
+                        username = row.get('Username', '')
+                        row_count += 1
+                        if not re.match(email_pattern, email):
+                            comments.append(f"[Row {idx+2}] Invalid email: {email}")
+                            process_ok = False
+                            break
+                        if not username.strip():
+                            comments.append(f"[Row {idx+2}] Empty Username field")
+                            process_ok = False
+                            break
+
+                    if process_ok:
+                        if row_count != 100:
+                            comments.append(f"[Error] Expected 100 rows, but found {row_count}")
+                            process_ok = False
+                        else:
+                            comments.append("All user data validated successfully!")
+                            result_ok = True
+
+        except Exception as e:
+            comments.append(f"[Exception] File parsing error: {str(e)}")
+            process_ok = False
+
+    return {
+        "Process": process_ok,
+        "Result": result_ok,
+        "TimePoint": datetime.now().isoformat(),
+        "comments": " | ".join(comments)
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Validate generated fake user data")
+    parser.add_argument('--output', type=str, required=True, help="CSV file path")
+    parser.add_argument('--result', type=str, required=True, help="Result output JSONL path")
+    args = parser.parse_args()
+
+    result_record = validate_fake_users(args.output)
+
+    os.makedirs(os.path.dirname(args.result), exist_ok=True)
+    with open(args.result, 'a', encoding='utf-8') as f:
+        f.write(json.dumps(result_record, ensure_ascii=False, default=str) + '\n')
+
+if __name__ == "__main__":
+    main()

test_scripts/Faker_02/test_script.py

@@ -0,0 +1,118 @@
+import csv
+import argparse
+import json
+from datetime import datetime
+import os
+
+
+def validate_fake_companies(file_path, expected_num_companies=5, result_file=None):
+    if not file_path.lower().endswith('.csv'):
+        msg = f"Error: File {file_path} is not a CSV file."
+        print(msg)
+        if result_file:
+            record_result(result_file, False, msg, process_success=False)
+        return False
+
+    try:
+        with open(file_path, 'r', encoding='utf-8') as file:
+            reader = csv.DictReader(file)
+            rows = list(reader)
+    except Exception as e:
+        msg = f"Error: Unable to read file {file_path}, reason: {str(e)}"
+        print(msg)
+        if result_file:
+            record_result(result_file, False, msg, process_success=False)
+        return False
+
+    if not rows:
+        msg = "Error: CSV file is empty or contains no valid data rows."
+        print(msg)
+        if result_file:
+            record_result(result_file, False, msg, process_success=True)
+        return False
+
+    if len(rows) != expected_num_companies:
+        msg = f"Error: Expected {expected_num_companies} records, but got {len(rows)}."
+        print(msg)
+        if result_file:
+            record_result(result_file, False, msg, process_success=True)
+        return False
+
+    required_fields = ['company name', 'address', 'phone']
+    for idx, row in enumerate(rows, 1):
+        normalized_row = {k.lower().strip(): v.strip() for k, v in row.items()}
+
+        for field in required_fields:
+            if field not in normalized_row:
+                msg = f"Error: Row {idx} is missing field '{field}'."
+                print(msg)
+                if result_file:
+                    record_result(result_file, False, msg, process_success=True)
+                return False
+
+            value = normalized_row[field]
+            if not value:
+                msg = f"Error: Row {idx} has empty value for field '{field}'."
+                print(msg)
+                if result_file:
+                    record_result(result_file, False, msg, process_success=True)
+                return False
+
+            # Basic content checks
+            if field == "phone" and not any(char.isdigit() for char in value):
+                msg = f"Error: Row {idx} field 'Phone' should contain digits."
+                print(msg)
+                if result_file:
+                    record_result(result_file, False, msg, process_success=True)
+                return False
+            if field == "company name" and value.isdigit():
+                msg = f"Error: Row {idx} field 'Company Name' should not be all digits."
+                print(msg)
+                if result_file:
+                    record_result(result_file, False, msg, process_success=True)
+                return False
+            if field == "address" and len(value) < 5:
+                msg = f"Error: Row {idx} field 'Address' seems too short to be valid."
+                print(msg)
+                if result_file:
+                    record_result(result_file, False, msg, process_success=True)
+                return False
+
+    success_msg = f"All {expected_num_companies} company records passed structural and content checks."
+    print(success_msg)
+    if result_file:
+        record_result(result_file, True, success_msg, process_success=True)
+    return True
+
+
+def record_result(result_file, result, comments, process_success=True):
+    # Get current timestamp
+    time_point = datetime.now().strftime('%Y-%m-%dT%H:%M:%S')
+
+    # Build result dictionary
+    result_data = {
+        "Process": process_success,
+        "Result": result,
+        "TimePoint": time_point,
+        "comments": comments
+    }
+
+    # Write to jsonl file
+    try:
+        # Create file if it doesn't exist and append result
+        with open(result_file, 'a', encoding='utf-8') as file:
+            json.dump(result_data, file, ensure_ascii=False, default=str)
+            file.write('\n')  # Write each result on new line
+    except Exception as e:
+        print(f"Error: Unable to write to result file {result_file}, reason: {str(e)}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Validate generated fake company data")
+    parser.add_argument('--output', type=str, required=True, help="Path to generated CSV file")
+    parser.add_argument('--result', type=str, required=False, help="Path to save results in jsonl format",
+                        default="test_results.jsonl")
+    args = parser.parse_args()
+
+    # Execute validation
+    validate_fake_companies(args.output, result_file=args.result)

test_scripts/Faker_03/test_script.py

@@ -0,0 +1,112 @@
+import argparse
+import re
+import json
+from datetime import datetime
+import os
+
+
+def jaccard_similarity_tokens(str1, str2):
+    # Token-based Jaccard similarity
+    tokens1 = set(re.findall(r'\w+', str1.lower()))
+    tokens2 = set(re.findall(r'\w+', str2.lower()))
+    if not tokens1 or not tokens2:
+        return 0.0
+    intersection = len(tokens1 & tokens2)
+    union = len(tokens1 | tokens2)
+    return intersection / union
+
+
+def validate_fake_text(input_file, output_file, result_file=None):
+    try:
+        with open(input_file, 'r', encoding='utf-8') as file:
+            original_content = file.read()
+    except Exception as e:
+        msg = f"Error: Unable to read original text file {input_file}, reason: {str(e)}"
+        print(msg)
+        if result_file:
+            record_result(result_file, False, msg)
+        return False
+
+    try:
+        with open(output_file, 'r', encoding='utf-8') as file:
+            fake_content = file.read()
+    except Exception as e:
+        msg = f"Error: Unable to read fake text file {output_file}, reason: {str(e)}"
+        print(msg)
+        if result_file:
+            record_result(result_file, False, msg)
+        return False
+
+    # Early checks
+    if original_content.strip() == fake_content.strip():
+        msg = "Error: Output text is identical to input text. No replacement performed."
+        print(msg)
+        if result_file:
+            record_result(result_file, False, msg)
+        return False
+
+    if len(fake_content.strip()) < 20:
+        msg = "Error: Output fake text is too short to be valid replacement."
+        print(msg)
+        if result_file:
+            record_result(result_file, False, msg)
+        return False
+
+    # Token-based similarity
+    similarity = jaccard_similarity_tokens(original_content, fake_content)
+    print(f"Token-based Jaccard similarity: {similarity:.4f}")
+
+    threshold = 0.3  # Token-level threshold
+
+    if similarity < threshold:
+        result_message = f"✅ Fake text replacement successful. Similarity {similarity:.4f} below threshold."
+        print(result_message)
+        if result_file:
+            record_result(result_file, True, result_message)
+        return True
+    else:
+        result_message = f"❌ Fake text too similar to original. Similarity {similarity:.4f} above threshold."
+        print(result_message)
+        if result_file:
+            record_result(result_file, False, result_message)
+        return False
+
+
+
+def record_result(result_file, result, comments):
+    # Get current timestamp
+    time_point = datetime.now().strftime('%Y-%m-%dT%H:%M:%S')
+
+    # Build result dictionary
+    result_data = {
+        "Process": True,
+        "Result": result,
+        "TimePoint": time_point,
+        "comments": comments
+    }
+
+    # Write to jsonl file
+    try:
+        # Create file if it doesn't exist and write
+        file_exists = os.path.exists(result_file)
+        with open(result_file, 'a', encoding='utf-8') as file:
+            if not file_exists:
+                # Write empty json line if file doesn't exist (optional)
+                file.write('\n')
+            json.dump(result_data, file, ensure_ascii=False, default=str)
+            file.write('\n')
+    except Exception as e:
+        print(f"Error: Unable to write to result file {result_file}, reason: {str(e)}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Validate effectiveness of fake text replacement")
+    parser.add_argument("--groundtruth", type=str, required=True, help="Path to original text file")
+    parser.add_argument("--output", type=str, required=True, help="Path to generated fake text file")
+    parser.add_argument("--result", type=str, required=False, help="Path to save results in jsonl format",
+                        default="test_results.jsonl")
+
+    args = parser.parse_args()
+
+    # Call test function
+    validate_fake_text(args.groundtruth, args.output, result_file=args.result)

test_scripts/FunASR_01/test_script.py

@@ -0,0 +1,122 @@
+import os
+import json
+import argparse
+import datetime
+import numpy as np
+
+
+def check_file_exists(file_path):
+    """Check if file exists and is not empty"""
+    if not os.path.exists(file_path):
+        return False, f"File does not exist: {file_path}"
+    if os.path.getsize(file_path) == 0:
+        return False, f"File is empty: {file_path}"
+    return True, ""
+
+
+def cer(ref, hyp):
+    """Character Error Rate using Levenshtein distance"""
+    r = ref
+    h = hyp
+    d = np.zeros((len(r)+1)*(len(h)+1), dtype=np.uint8).reshape((len(r)+1, len(h)+1))
+
+    for i in range(len(r)+1):
+        d[i][0] = i
+    for j in range(len(h)+1):
+        d[0][j] = j
+
+    for i in range(1, len(r)+1):
+        for j in range(1, len(h)+1):
+            cost = 0 if r[i-1] == h[j-1] else 1
+            d[i][j] = min(d[i-1][j] + 1,     # deletion
+                          d[i][j-1] + 1,     # insertion
+                          d[i-1][j-1] + cost)  # substitution
+
+    return d[len(r)][len(h)] / max(len(r), 1)
+
+
+def load_text(file_path):
+    """Load full text content from file"""
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            return f.read().replace('\n', '').strip(), ""
+    except Exception as e:
+        return None, str(e)
+
+
+def evaluate(system_output_file, ground_truth_file, cer_threshold=0.05):
+    """Evaluate CER between system output and ground truth"""
+    # Check files
+    process_ok, process_msg = check_file_exists(system_output_file)
+    if not process_ok:
+        return False, False, process_msg
+
+    process_ok, process_msg = check_file_exists(ground_truth_file)
+    if not process_ok:
+        return False, False, process_msg
+
+    # Load content
+    sys_text, msg1 = load_text(system_output_file)
+    gt_text, msg2 = load_text(ground_truth_file)
+
+    if sys_text is None:
+        return True, False, f"Failed to load system output: {msg1}"
+    if gt_text is None:
+        return True, False, f"Failed to load ground truth: {msg2}"
+
+    score = cer(gt_text, sys_text)
+    comment = f"CER = {score:.4f}"
+    if score > cer_threshold:
+        comment += f" ❌ Exceeds threshold {cer_threshold}"
+        return True, False, comment
+    else:
+        comment += f" ✅ Within threshold {cer_threshold}"
+        return True, True, comment
+
+
+def save_results_to_jsonl(process_ok, result_ok, comments, jsonl_file):
+    """Save test results to JSONL file"""
+    current_time = datetime.datetime.now().strftime("%Y-%m-%dT%H:%M:%S")
+
+    result_data = {
+        "Process": bool(process_ok),
+        "Result": bool(result_ok),
+        "TimePoint": current_time,
+        "comments": comments
+    }
+
+    os.makedirs(os.path.dirname(jsonl_file), exist_ok=True)
+
+    with open(jsonl_file, 'a', encoding='utf-8') as f:
+        json.dump(result_data, f, ensure_ascii=False, default=str)
+        f.write('\n')
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Evaluate speech recognition results (no speaker separation)')
+    parser.add_argument('--output', required=True, help='System output file path')
+    parser.add_argument('--groundtruth', required=True, help='Ground truth file path')
+    parser.add_argument('--cer_threshold', type=float, default=0.10, help='CER threshold')
+    parser.add_argument('--result', required=True, help='Result JSONL file path')
+
+    args = parser.parse_args()
+
+    process_ok, result_ok, comments = evaluate(
+        args.output,
+        args.groundtruth,
+        args.cer_threshold
+    )
+
+    save_results_to_jsonl(process_ok, result_ok, comments, args.result)
+
+    if not process_ok:
+        print(f"Processing failed: {comments}")
+    elif not result_ok:
+        print(f"Results do not meet requirements: {comments}")
+    else:
+        print("✅ Test passed")
+        print(comments)
+
+
+if __name__ == "__main__":
+    main()

test_scripts/FunASR_02/test_script.py

@@ -0,0 +1,134 @@
+import os
+import sys
+import json
+import argparse
+from difflib import SequenceMatcher
+import datetime
+import re
+
+def check_file_exists(file_path):
+    """Check if file exists and is not empty"""
+    if not os.path.exists(file_path):
+        return False, f"File does not exist: {file_path}"
+    if os.path.getsize(file_path) == 0:
+        return False, f"File is empty: {file_path}"
+    return True, ""
+
+
+def cer(ref, hyp):
+    """Character Error Rate = Edit Distance / Length of Reference"""
+    import numpy as np
+    ref = list(ref)
+    hyp = list(hyp)
+    d = np.zeros((len(ref)+1, len(hyp)+1), dtype=int)
+    for i in range(len(ref)+1):
+        d[i][0] = i
+    for j in range(len(hyp)+1):
+        d[0][j] = j
+    for i in range(1, len(ref)+1):
+        for j in range(1, len(hyp)+1):
+            cost = 0 if ref[i-1] == hyp[j-1] else 1
+            d[i][j] = min(
+                d[i-1][j] + 1,      # deletion
+                d[i][j-1] + 1,      # insertion
+                d[i-1][j-1] + cost  # substitution
+            )
+    return d[len(ref)][len(hyp)] / max(len(ref), 1)
+
+
+def is_likely_english(text):
+    english_letters = re.findall(r'[a-zA-Z]', text)
+    if not english_letters:
+        return False
+    ratio = len(english_letters) / max(len(text), 1)
+    return ratio > 0.5 and len(english_letters) >= 10  # at least 10 letters, >50% are English
+
+
+
+def load_transcripts(file_path):
+    """Load transcript text from file"""
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            return f.read().replace("\n", ""), ""
+    except Exception as e:
+        return None, str(e)
+
+
+def evaluate(system_output_file, ground_truth_file, cer_threshold=0.05):
+    """Main evaluation function: Calculate CER between system output and ground truth"""
+    # Check files
+    process_ok, process_msg = check_file_exists(system_output_file)
+    if not process_ok:
+        return False, False, process_msg
+
+    process_ok, process_msg = check_file_exists(ground_truth_file)
+    if not process_ok:
+        return False, False, process_msg
+
+    # Load transcripts
+    system_trans, msg = load_transcripts(system_output_file)
+    if system_trans is None:
+        return True, False, f"Failed to load system output: {msg}"
+
+    ground_truth, msg = load_transcripts(ground_truth_file)
+    if ground_truth is None:
+        return True, False, f"Failed to load ground truth: {msg}"
+
+    if not is_likely_english(system_trans):
+        return True, False, "Output text does not appear to be valid English transcription"
+
+    # Calculate CER
+    score = cer(ground_truth, system_trans)
+    comments = [f"CER = {score:.4f}"]
+
+    result_ok = score <= cer_threshold
+    if not result_ok:
+        comments.append(f"CER ({score:.4f}) exceeds threshold {cer_threshold}")
+
+    return True, result_ok, "\n".join(comments)
+
+
+def save_results_to_jsonl(process_ok, result_ok, comments, jsonl_file):
+    """Save test results to JSONL file"""
+    current_time = datetime.datetime.now().strftime("%Y-%m-%dT%H:%M:%S")
+
+    result_data = {
+        "Process": bool(process_ok),
+        "Result": bool(result_ok),
+        "TimePoint": current_time,
+        "comments": comments
+    }
+
+    os.makedirs(os.path.dirname(jsonl_file), exist_ok=True)
+
+    with open(jsonl_file, 'a', encoding='utf-8') as f:
+        json.dump(result_data, f, ensure_ascii=False, default=str)
+        f.write('\n')
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Evaluate speech recognition results')
+    parser.add_argument('--output', required=True, help='System output file path')
+    parser.add_argument('--groundtruth', required=True, help='Ground truth file path')
+    parser.add_argument('--cer_threshold', type=float, default=0.10, help='CER threshold')
+    parser.add_argument('--result', required=True, help='Result JSONL file path')
+
+    args = parser.parse_args()
+
+    process_ok, result_ok, comments = evaluate(
+        args.output,
+        args.groundtruth,
+        args.cer_threshold
+    )
+
+    save_results_to_jsonl(process_ok, result_ok, comments, args.result)
+
+    if not process_ok:
+        print(f"Processing failed: {comments}")
+    if not result_ok:
+        print(f"Results do not meet requirements: {comments}")
+    print("Test completed")  # Changed to neutral prompt
+
+
+if __name__ == "__main__":
+    main()

test_scripts/FunASR_03/test_script.py

@@ -0,0 +1,135 @@
+import argparse
+import jieba
+import re
+import json
+from jiwer import compute_measures
+from datetime import datetime
+import os
+from collections import Counter
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Evaluate text similarity between FunASR output and ground truth")
+    parser.add_argument('--output', default='output.txt', help='FunASR output file path')
+    parser.add_argument('--groundtruth', default='gt.txt', help='Ground truth file path')
+    parser.add_argument('--result', default='eval_results.jsonl', help='JSONL file path to save evaluation results')
+    parser.add_argument('--wer_threshold', type=float, default=0.3,
+                        help='WER threshold, task considered successful if below this value')
+    parser.add_argument('--punctuation_threshold', type=float, default=0.7,
+                        help='Punctuation matching threshold, task considered failed if below this value')
+    return parser.parse_args()
+
+
+def preprocess_text(text):
+    """Preprocess text: remove punctuation and spaces, tokenize with jieba"""
+    text = re.sub(r'[^\w\s]', '', text)
+    text = text.replace(" ", "")
+    return " ".join(jieba.cut(text))
+
+
+def extract_punctuation(text):
+    """Extract punctuation characters from text"""
+    return re.findall(r'[^\w\s]', text)
+
+
+def punctuation_match_score(output_puncs, gt_puncs):
+    """Compute matching score based on overlapping punctuation"""
+    output_counter = Counter(output_puncs)
+    gt_counter = Counter(gt_puncs)
+    common = sum((output_counter & gt_counter).values())
+    total = max(len(gt_puncs), 1)
+    return common / total
+
+
+def load_text(file_path, is_output=False):
+    """Load text file, extract 'text' field from FunASR output when is_output=True"""
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            content = f.read().strip()
+            if not content:
+                raise ValueError(f"File {file_path} is empty")
+
+            if is_output:
+                match = re.search(r"'text':\s*'([^']*)'", content)
+                if match:
+                    extracted_text = match.group(1)
+                else:
+                    extracted_text = content
+                return preprocess_text(extracted_text), extracted_text
+            else:
+                return preprocess_text(content), content
+    except FileNotFoundError:
+        return "", False
+    except Exception as e:
+        return "", False
+
+
+
+def evaluate(output_file, gt_file, result_file, wer_threshold, punctuation_threshold):
+    comments = []
+    process_success = False
+    result_success = False
+
+    output_text, output_raw = load_text(output_file, is_output=True)
+    gt_text, gt_raw = load_text(gt_file, is_output=False)
+
+    if output_text and gt_text:
+        process_success = True
+        comments.append("Input files exist, are non-empty and correctly formatted")
+    else:
+        comments.append("Input file issues:")
+        if not output_text:
+            comments.append(f"Output file {output_file} does not exist or has incorrect format")
+        if not gt_text:
+            comments.append(f"Ground truth file {gt_file} does not exist or has incorrect format")
+
+    wer_score = None
+    punctuation_score = None
+
+    if process_success:
+        try:
+            measures = compute_measures(gt_text, output_text)
+            wer_score = measures['wer']
+
+            output_puncs = extract_punctuation(output_raw)
+            gt_puncs = extract_punctuation(gt_raw)
+            punctuation_score = punctuation_match_score(output_puncs, gt_puncs)
+
+            comments.append(f"Word Error Rate (WER): {wer_score:.4f}")
+            comments.append(f"Punctuation matching score: {punctuation_score:.4f}")
+
+            if wer_score <= wer_threshold and punctuation_score >= punctuation_threshold:
+                result_success = True
+                comments.append("Task completed successfully (WER and punctuation both meet thresholds)")
+            else:
+                comments.append(
+                    f"Task failed (WER {'above' if wer_score > wer_threshold else 'below'} threshold {wer_threshold}, "
+                    f"punctuation {'below' if punctuation_score < punctuation_threshold else 'meets'} threshold {punctuation_threshold})"
+                )
+        except Exception as e:
+            comments.append(f"Exception occurred during evaluation: {str(e)}")
+    else:
+        comments.append("Evaluation not performed due to invalid input files")
+
+    for c in comments:
+        print(c)
+
+    result_entry = {
+        "Process": process_success,
+        "Result": result_success,
+        "TimePoint": datetime.now().strftime("%Y-%m-%dT%H:%M:%S"),
+        "comments": "; ".join(comments)
+    }
+
+    try:
+        os.makedirs(os.path.dirname(result_file), exist_ok=True)
+        with open(result_file, 'a', encoding='utf-8') as f:
+            json.dump(result_entry, f, ensure_ascii=False, default=str)
+            f.write('\n')
+    except Exception as e:
+        print(f"Error saving result to {result_file}: {str(e)}")
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    evaluate(args.output, args.groundtruth, args.result, args.wer_threshold, args.punctuation_threshold)

test_scripts/InvisibleWatermark_01/imwatermark/__init__.py

@@ -0,0 +1 @@
+from .watermark import WatermarkEncoder, WatermarkDecoder

test_scripts/InvisibleWatermark_01/imwatermark/dwtDctSvd.py

@@ -0,0 +1,108 @@
+import numpy as np
+import copy
+import cv2
+import pywt
+import math
+import pprint
+
+pp = pprint.PrettyPrinter(indent=2)
+
+
+class EmbedDwtDctSvd(object):
+    def __init__(self, watermarks=[], wmLen=8, scales=[0,36,0], block=4):
+        self._watermarks = watermarks
+        self._wmLen = wmLen
+        self._scales = scales
+        self._block = block
+
+    def encode(self, bgr):
+        (row, col, channels) = bgr.shape
+
+        yuv = cv2.cvtColor(bgr, cv2.COLOR_BGR2YUV)
+
+        for channel in range(2):
+            if self._scales[channel] <= 0:
+                continue
+
+            ca1,(h1,v1,d1) = pywt.dwt2(yuv[:row//4*4,:col//4*4,channel], 'haar')
+            self.encode_frame(ca1, self._scales[channel])
+
+            yuv[:row//4*4,:col//4*4,channel] = pywt.idwt2((ca1, (v1,h1,d1)), 'haar')
+
+        bgr_encoded = cv2.cvtColor(yuv, cv2.COLOR_YUV2BGR)
+        return bgr_encoded
+
+    def decode(self, bgr):
+        (row, col, channels) = bgr.shape
+
+        yuv = cv2.cvtColor(bgr, cv2.COLOR_BGR2YUV)
+
+        scores = [[] for i in range(self._wmLen)]
+        for channel in range(2):
+            if self._scales[channel] <= 0:
+                continue
+
+            ca1,(h1,v1,d1) = pywt.dwt2(yuv[:row//4*4,:col//4*4,channel], 'haar')
+
+            scores = self.decode_frame(ca1, self._scales[channel], scores)
+
+        avgScores = list(map(lambda l: np.array(l).mean(), scores))
+
+        bits = (np.array(avgScores) * 255 > 127)
+        return bits
+
+    def decode_frame(self, frame, scale, scores):
+        (row, col) = frame.shape
+        num = 0
+
+        for i in range(row//self._block):
+            for j in range(col//self._block):
+                block = frame[i*self._block : i*self._block + self._block,
+                              j*self._block : j*self._block + self._block]
+
+                score = self.infer_dct_svd(block, scale)
+                wmBit = num % self._wmLen
+                scores[wmBit].append(score)
+                num = num + 1
+
+        return scores
+
+    def diffuse_dct_svd(self, block, wmBit, scale):
+        u,s,v = np.linalg.svd(cv2.dct(block))
+
+        s[0] = (s[0] // scale + 0.25 + 0.5 * wmBit) * scale
+        return cv2.idct(np.dot(u, np.dot(np.diag(s), v)))
+
+    def infer_dct_svd(self, block, scale):
+        u,s,v = np.linalg.svd(cv2.dct(block))
+
+        score = 0
+        score = int ((s[0] % scale) > scale * 0.5)
+        return score
+        if score >= 0.5:
+            return 1.0
+        else:
+            return 0.0
+
+    def encode_frame(self, frame, scale):
+        '''
+        frame is a matrix (M, N)
+
+        we get K (watermark bits size) blocks (self._block x self._block)
+
+        For i-th block, we encode watermark[i] bit into it
+        '''
+        (row, col) = frame.shape
+        num = 0
+        for i in range(row//self._block):
+            for j in range(col//self._block):
+                block = frame[i*self._block : i*self._block + self._block,
+                              j*self._block : j*self._block + self._block]
+                wmBit = self._watermarks[(num % self._wmLen)]
+
+
+                diffusedBlock = self.diffuse_dct_svd(block, wmBit, scale)
+                frame[i*self._block : i*self._block + self._block,
+                      j*self._block : j*self._block + self._block] = diffusedBlock
+
+                num = num+1

test_scripts/InvisibleWatermark_01/imwatermark/maxDct.py

@@ -0,0 +1,134 @@
+import numpy as np
+import copy
+import cv2
+import pywt
+import math
+import pprint
+
+pp = pprint.PrettyPrinter(indent=2)
+
+
+class EmbedMaxDct(object):
+    def __init__(self, watermarks=[], wmLen=8, scales=[0,36,36], block=4):
+        self._watermarks = watermarks
+        self._wmLen = wmLen
+        self._scales = scales
+        self._block = block
+
+    def encode(self, bgr):
+        (row, col, channels) = bgr.shape
+
+        yuv = cv2.cvtColor(bgr, cv2.COLOR_BGR2YUV)
+
+        for channel in range(2):
+            if self._scales[channel] <= 0:
+                continue
+
+            ca1,(h1,v1,d1) = pywt.dwt2(yuv[:row//4*4,:col//4*4,channel], 'haar')
+            self.encode_frame(ca1, self._scales[channel])
+
+            yuv[:row//4*4,:col//4*4,channel] = pywt.idwt2((ca1, (v1,h1,d1)), 'haar')
+
+        bgr_encoded = cv2.cvtColor(yuv, cv2.COLOR_YUV2BGR)
+        return bgr_encoded
+
+    def decode(self, bgr):
+        (row, col, channels) = bgr.shape
+
+        yuv = cv2.cvtColor(bgr, cv2.COLOR_BGR2YUV)
+
+        scores = [[] for i in range(self._wmLen)]
+        for channel in range(2):
+            if self._scales[channel] <= 0:
+                continue
+
+            ca1,(h1,v1,d1) = pywt.dwt2(yuv[:row//4*4,:col//4*4,channel], 'haar')
+
+            scores = self.decode_frame(ca1, self._scales[channel], scores)
+
+        avgScores = list(map(lambda l: np.array(l).mean(), scores))
+
+        bits = (np.array(avgScores) * 255 > 127)
+        return bits
+
+    def decode_frame(self, frame, scale, scores):
+        (row, col) = frame.shape
+        num = 0
+
+        for i in range(row//self._block):
+            for j in range(col//self._block):
+                block = frame[i*self._block : i*self._block + self._block,
+                              j*self._block : j*self._block + self._block]
+
+                score = self.infer_dct_matrix(block, scale)
+                #score = self.infer_dct_svd(block, scale)
+                wmBit = num % self._wmLen
+                scores[wmBit].append(score)
+                num = num + 1
+
+        return scores
+
+    def diffuse_dct_svd(self, block, wmBit, scale):
+        u,s,v = np.linalg.svd(cv2.dct(block))
+
+        s[0] = (s[0] // scale + 0.25 + 0.5 * wmBit) * scale
+        return cv2.idct(np.dot(u, np.dot(np.diag(s), v)))
+
+    def infer_dct_svd(self, block, scale):
+        u,s,v = np.linalg.svd(cv2.dct(block))
+
+        score = 0
+        score = int ((s[0] % scale) > scale * 0.5)
+        return score
+        if score >= 0.5:
+            return 1.0
+        else:
+            return 0.0
+
+    def diffuse_dct_matrix(self, block, wmBit, scale):
+        pos = np.argmax(abs(block.flatten()[1:])) + 1
+        i, j = pos // self._block, pos % self._block
+        val = block[i][j]
+        if val >= 0.0:
+            block[i][j] = (val//scale + 0.25 + 0.5 * wmBit) * scale
+        else:
+            val = abs(val)
+            block[i][j] = -1.0 * (val//scale + 0.25 + 0.5 * wmBit) * scale
+        return block
+
+    def infer_dct_matrix(self, block, scale):
+        pos = np.argmax(abs(block.flatten()[1:])) + 1
+        i, j = pos // self._block, pos % self._block
+
+        val = block[i][j]
+        if val < 0:
+            val = abs(val)
+
+        if (val % scale) > 0.5 * scale:
+            return 1
+        else:
+            return 0
+
+    def encode_frame(self, frame, scale):
+        '''
+        frame is a matrix (M, N)
+
+        we get K (watermark bits size) blocks (self._block x self._block)
+
+        For i-th block, we encode watermark[i] bit into it
+        '''
+        (row, col) = frame.shape
+        num = 0
+        for i in range(row//self._block):
+            for j in range(col//self._block):
+                block = frame[i*self._block : i*self._block + self._block,
+                              j*self._block : j*self._block + self._block]
+                wmBit = self._watermarks[(num % self._wmLen)]
+
+
+                diffusedBlock = self.diffuse_dct_matrix(block, wmBit, scale)
+                #diffusedBlock = self.diffuse_dct_svd(block, wmBit, scale)
+                frame[i*self._block : i*self._block + self._block,
+                      j*self._block : j*self._block + self._block] = diffusedBlock
+
+                num = num+1

test_scripts/InvisibleWatermark_01/imwatermark/rivaGan.py

@@ -0,0 +1,69 @@
+import numpy as np
+import torch
+import cv2
+import os
+import time
+
+
+class RivaWatermark(object):
+    encoder = None
+    decoder = None
+
+    def __init__(self, watermarks=[], wmLen=32, threshold=0.52):
+        self._watermarks = watermarks
+        self._threshold = threshold
+        if wmLen not in [32]:
+            raise RuntimeError('rivaGan only supports 32 bits watermarks now.')
+        self._data = torch.from_numpy(np.array([self._watermarks], dtype=np.float32))
+
+    @classmethod
+    def loadModel(cls):
+        try:
+            import onnxruntime
+        except ImportError:
+            raise ImportError(
+                "The `RivaWatermark` class requires onnxruntime to be installed. "
+                "You can install it with pip: `pip install onnxruntime`."
+            )
+
+        if RivaWatermark.encoder and RivaWatermark.decoder:
+            return
+        modelDir = os.path.dirname(os.path.abspath(__file__))
+        RivaWatermark.encoder = onnxruntime.InferenceSession(
+            os.path.join(modelDir, 'rivagan_encoder.onnx'))
+        RivaWatermark.decoder = onnxruntime.InferenceSession(
+            os.path.join(modelDir, 'rivagan_decoder.onnx'))
+
+    def encode(self, frame):
+        if not RivaWatermark.encoder:
+            raise RuntimeError('call loadModel method first')
+
+        frame = torch.from_numpy(np.array([frame], dtype=np.float32)) / 127.5 - 1.0
+        frame = frame.permute(3, 0, 1, 2).unsqueeze(0)
+
+        inputs = {
+            'frame': frame.detach().cpu().numpy(),
+            'data': self._data.detach().cpu().numpy()
+        }
+
+        outputs = RivaWatermark.encoder.run(None, inputs)
+        wm_frame = outputs[0]
+        wm_frame = torch.clamp(torch.from_numpy(wm_frame), min=-1.0, max=1.0)
+        wm_frame = (
+            (wm_frame[0, :, 0, :, :].permute(1, 2, 0) + 1.0) * 127.5
+        ).detach().cpu().numpy().astype('uint8')
+
+        return wm_frame
+
+    def decode(self, frame):
+        if not RivaWatermark.decoder:
+            raise RuntimeError('you need load model first')
+
+        frame = torch.from_numpy(np.array([frame], dtype=np.float32)) / 127.5 - 1.0
+        frame = frame.permute(3, 0, 1, 2).unsqueeze(0)
+        inputs = {
+            'frame': frame.detach().cpu().numpy(),
+        }
+        outputs = RivaWatermark.decoder.run(None, inputs)
+        data = outputs[0][0]
+        return np.array(data > self._threshold, dtype=np.uint8)

test_scripts/InvisibleWatermark_01/imwatermark/rivagan_decoder.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6b006690cf352fa50a91a0b6d6241dbcded0a9957969e2c0665cf9a7011b3880
+size 1088816

test_scripts/InvisibleWatermark_01/imwatermark/rivagan_encoder.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:66bc7814fadac7d686105c8ab26c6cf2cc8e40deb83e67bb6ef5b9de9b8ece0d
+size 657164

test_scripts/InvisibleWatermark_01/imwatermark/watermark.py

@@ -0,0 +1,171 @@
+import struct
+import uuid
+import copy
+import base64
+import cv2
+import numpy as np
+from .maxDct import EmbedMaxDct
+from .dwtDctSvd import EmbedDwtDctSvd
+from .rivaGan import RivaWatermark
+import pprint
+
+pp = pprint.PrettyPrinter(indent=2)
+
+class WatermarkEncoder(object):
+    def __init__(self, content=b''):
+        seq = np.array([n for n in content], dtype=np.uint8)
+        self._watermarks = list(np.unpackbits(seq))
+        self._wmLen = len(self._watermarks)
+        self._wmType = 'bytes'
+
+    def set_by_ipv4(self, addr):
+        bits = []
+        ips = addr.split('.')
+        for ip in ips:
+            bits += list(np.unpackbits(np.array([ip % 255], dtype=np.uint8)))
+        self._watermarks = bits
+        self._wmLen = len(self._watermarks)
+        self._wmType = 'ipv4'
+        assert self._wmLen == 32
+
+    def set_by_uuid(self, uid):
+        u = uuid.UUID(uid)
+        self._wmType = 'uuid'
+        seq = np.array([n for n in u.bytes], dtype=np.uint8)
+        self._watermarks = list(np.unpackbits(seq))
+        self._wmLen = len(self._watermarks)
+
+    def set_by_bytes(self, content):
+        self._wmType = 'bytes'
+        seq = np.array([n for n in content], dtype=np.uint8)
+        self._watermarks = list(np.unpackbits(seq))
+        self._wmLen = len(self._watermarks)
+
+    def set_by_b16(self, b16):
+        content = base64.b16decode(b16)
+        self.set_by_bytes(content)
+        self._wmType = 'b16'
+
+    def set_by_bits(self, bits=[]):
+        self._watermarks = [int(bit) % 2 for bit in bits]
+        self._wmLen = len(self._watermarks)
+        self._wmType = 'bits'
+
+    def set_watermark(self, wmType='bytes', content=''):
+        if wmType == 'ipv4':
+            self.set_by_ipv4(content)
+        elif wmType == 'uuid':
+            self.set_by_uuid(content)
+        elif wmType == 'bits':
+            self.set_by_bits(content)
+        elif wmType == 'bytes':
+            self.set_by_bytes(content)
+        elif wmType == 'b16':
+            self.set_by_b16(content)
+        else:
+            raise NameError('%s is not supported' % wmType)
+
+    def get_length(self):
+        return self._wmLen
+
+    @classmethod
+    def loadModel(cls):
+        RivaWatermark.loadModel()
+
+    def encode(self, cv2Image, method='dwtDct', **configs):
+        (r, c, channels) = cv2Image.shape
+        if r*c < 256*256:
+            raise RuntimeError('image too small, should be larger than 256x256')
+
+        if method == 'dwtDct':
+            embed = EmbedMaxDct(self._watermarks, wmLen=self._wmLen, **configs)
+            return embed.encode(cv2Image)
+        elif method == 'dwtDctSvd':
+            embed = EmbedDwtDctSvd(self._watermarks, wmLen=self._wmLen, **configs)
+            return embed.encode(cv2Image)
+        elif method == 'rivaGan':
+            embed = RivaWatermark(self._watermarks, self._wmLen)
+            return embed.encode(cv2Image)
+        else:
+            raise NameError('%s is not supported' % method)
+
+class WatermarkDecoder(object):
+    def __init__(self, wm_type='bytes', length=0):
+        self._wmType = wm_type
+        if wm_type == 'ipv4':
+            self._wmLen = 32
+        elif wm_type == 'uuid':
+            self._wmLen = 128
+        elif wm_type == 'bytes':
+            self._wmLen = length
+        elif wm_type == 'bits':
+            self._wmLen = length
+        elif wm_type == 'b16':
+            self._wmLen = length
+        else:
+            raise NameError('%s is unsupported' % wm_type)
+
+    def reconstruct_ipv4(self, bits):
+        ips = [str(ip) for ip in list(np.packbits(bits))]
+        return '.'.join(ips)
+
+    def reconstruct_uuid(self, bits):
+        nums = np.packbits(bits)
+        bstr = b''
+        for i in range(16):
+            bstr += struct.pack('>B', nums[i])
+
+        return str(uuid.UUID(bytes=bstr))
+
+    def reconstruct_bits(self, bits):
+        #return ''.join([str(b) for b in bits])
+        return bits
+
+    def reconstruct_b16(self, bits):
+        bstr = self.reconstruct_bytes(bits)
+        return base64.b16encode(bstr)
+
+    def reconstruct_bytes(self, bits):
+        nums = np.packbits(bits)
+        bstr = b''
+        for i in range(self._wmLen//8):
+            bstr += struct.pack('>B', nums[i])
+        return bstr
+
+    def reconstruct(self, bits):
+        if len(bits) != self._wmLen:
+            raise RuntimeError('bits are not matched with watermark length')
+
+        if self._wmType == 'ipv4':
+            return self.reconstruct_ipv4(bits)
+        elif self._wmType == 'uuid':
+            return self.reconstruct_uuid(bits)
+        elif self._wmType == 'bits':
+            return self.reconstruct_bits(bits)
+        elif self._wmType == 'b16':
+            return self.reconstruct_b16(bits)
+        else:
+            return self.reconstruct_bytes(bits)
+
+    def decode(self, cv2Image, method='dwtDct', **configs):
+        (r, c, channels) = cv2Image.shape
+        if r*c < 256*256:
+            raise RuntimeError('image too small, should be larger than 256x256')
+
+        bits = []
+        if method == 'dwtDct':
+            embed = EmbedMaxDct(watermarks=[], wmLen=self._wmLen, **configs)
+            bits = embed.decode(cv2Image)
+        elif method == 'dwtDctSvd':
+            embed = EmbedDwtDctSvd(watermarks=[], wmLen=self._wmLen, **configs)
+            bits = embed.decode(cv2Image)
+        elif method == 'rivaGan':
+            embed = RivaWatermark(watermarks=[], wmLen=self._wmLen, **configs)
+            bits = embed.decode(cv2Image)
+        else:
+            raise NameError('%s is not supported' % method)
+        return self.reconstruct(bits)
+
+    @classmethod
+    def loadModel(cls):
+        RivaWatermark.loadModel()

test_scripts/InvisibleWatermark_01/test_script.py

@@ -0,0 +1,100 @@
+import argparse
+import cv2
+import json
+import os
+from datetime import datetime
+from imwatermark import WatermarkDecoder
+from skimage.metrics import peak_signal_noise_ratio as compare_psnr
+
+def evaluate_watermark(original_path, watermark_text, watermarked_path):
+    process_status = True
+    final_result_status = False
+    comments = []
+
+    # Timestamp
+    time_point = datetime.now().isoformat()
+
+    # Check input files
+    if not os.path.exists(original_path) or os.path.getsize(original_path) == 0:
+        comments.append(f"Error: Original image file '{original_path}' does not exist or is empty.")
+        process_status = False
+    if not os.path.exists(watermarked_path) or os.path.getsize(watermarked_path) == 0:
+        comments.append(f"Error: Watermarked image file '{watermarked_path}' does not exist or is empty.")
+        process_status = False
+
+    if process_status:
+        bgr_original = cv2.imread(original_path)
+        bgr_encoded  = cv2.imread(watermarked_path)
+        if bgr_original is None or bgr_encoded is None:
+            comments.append("Error: Failed to read images, please check if files are corrupted or in correct format.")
+            process_status = False
+
+    if process_status:
+        try:
+            # decoder       = WatermarkDecoder('bytes', len(watermark_text)*8)
+            # decoded_bytes = decoder.decode(bgr_encoded, 'dwtDct')
+            # extracted_text= decoded_bytes.decode('utf-8', errors='ignore')
+            # is_match      = (extracted_text == watermark_text)
+
+            max_bits = 256
+            decoder = WatermarkDecoder('bytes', max_bits)
+            decoded_bytes = decoder.decode(bgr_encoded, 'dwtDct')
+            extracted_text = decoded_bytes.decode('utf-8', errors='ignore')
+
+            is_match = (watermark_text in extracted_text)
+
+            comments.append(f"{'✅' if is_match else '❌'} Extraction result: '{extracted_text}' | GT: '{watermark_text}'")
+            psnr_value = compare_psnr(bgr_original, bgr_encoded)
+            comments.append(f"📐 PSNR: {psnr_value:.2f} dB")
+
+            # Metrics
+            match_rate     = '100%' if is_match else '0%'
+            psnr_satisfied = psnr_value >= 30.0
+            comments.append(f"🎯 Watermark detection_match: {match_rate}")
+            comments.append(f"🎯 PSNR ≥ 30.0: {'✅ Satisfied' if psnr_satisfied else '❌ Not satisfied'}")
+
+            final_result_status = is_match and psnr_satisfied
+            comments.append(f"Final evaluation result: Watermark match={is_match}, PSNR satisfied={psnr_satisfied}")
+
+        except Exception as e:
+            comments.append(f"Exception occurred during watermark processing or evaluation: {e}")
+            final_result_status = False
+
+    output_data = {
+        "Process":   process_status,
+        "Result":    final_result_status,
+        "TimePoint": time_point,
+        "Comments":  "\n".join(comments)
+    }
+    print(output_data["Comments"])
+    return output_data
+
+def write_to_jsonl(file_path, data):
+    """
+    Append single result to JSONL file:
+    Each run appends one JSON line.
+    """
+    try:
+        os.makedirs(os.path.dirname(file_path), exist_ok=True)
+        with open(file_path, 'a', encoding='utf-8') as f:
+            # Add default=str to handle non-serializable types with str()
+            f.write(json.dumps(data, ensure_ascii=False, default=str) + '\n')
+        print(f"✅ Result appended to JSONL file: {file_path}")
+    except Exception as e:
+        print(f"❌ Error occurred while writing to JSONL file: {e}")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Extract and verify blind watermark, calculate image quality, and store results as JSONL")
+    parser.add_argument("--groundtruth",     required=True, help="Path to original image")
+    parser.add_argument("--output",    required=True, help="Path to watermarked image")
+    parser.add_argument("--watermark", required=True, help="Expected watermark content to extract")
+    parser.add_argument("--result",    help="File path to store JSONL results")
+
+    args = parser.parse_args()
+
+    evaluation_result = evaluate_watermark(
+        args.groundtruth, args.watermark, args.output)
+
+    if args.result:
+        write_to_jsonl(args.result, evaluation_result)

test_scripts/InvisibleWatermark_02/imwatermark/__init__.py

@@ -0,0 +1 @@
+from .watermark import WatermarkEncoder, WatermarkDecoder

test_scripts/InvisibleWatermark_02/imwatermark/dwtDctSvd.py

@@ -0,0 +1,108 @@
+import numpy as np
+import copy
+import cv2
+import pywt
+import math
+import pprint
+
+pp = pprint.PrettyPrinter(indent=2)
+
+
+class EmbedDwtDctSvd(object):
+    def __init__(self, watermarks=[], wmLen=8, scales=[0,36,0], block=4):
+        self._watermarks = watermarks
+        self._wmLen = wmLen
+        self._scales = scales
+        self._block = block
+
+    def encode(self, bgr):
+        (row, col, channels) = bgr.shape
+
+        yuv = cv2.cvtColor(bgr, cv2.COLOR_BGR2YUV)
+
+        for channel in range(2):
+            if self._scales[channel] <= 0:
+                continue
+
+            ca1,(h1,v1,d1) = pywt.dwt2(yuv[:row//4*4,:col//4*4,channel], 'haar')
+            self.encode_frame(ca1, self._scales[channel])
+
+            yuv[:row//4*4,:col//4*4,channel] = pywt.idwt2((ca1, (v1,h1,d1)), 'haar')
+
+        bgr_encoded = cv2.cvtColor(yuv, cv2.COLOR_YUV2BGR)
+        return bgr_encoded
+
+    def decode(self, bgr):
+        (row, col, channels) = bgr.shape
+
+        yuv = cv2.cvtColor(bgr, cv2.COLOR_BGR2YUV)
+
+        scores = [[] for i in range(self._wmLen)]
+        for channel in range(2):
+            if self._scales[channel] <= 0:
+                continue
+
+            ca1,(h1,v1,d1) = pywt.dwt2(yuv[:row//4*4,:col//4*4,channel], 'haar')
+
+            scores = self.decode_frame(ca1, self._scales[channel], scores)
+
+        avgScores = list(map(lambda l: np.array(l).mean(), scores))
+
+        bits = (np.array(avgScores) * 255 > 127)
+        return bits
+
+    def decode_frame(self, frame, scale, scores):
+        (row, col) = frame.shape
+        num = 0
+
+        for i in range(row//self._block):
+            for j in range(col//self._block):
+                block = frame[i*self._block : i*self._block + self._block,
+                              j*self._block : j*self._block + self._block]
+
+                score = self.infer_dct_svd(block, scale)
+                wmBit = num % self._wmLen
+                scores[wmBit].append(score)
+                num = num + 1
+
+        return scores
+
+    def diffuse_dct_svd(self, block, wmBit, scale):
+        u,s,v = np.linalg.svd(cv2.dct(block))
+
+        s[0] = (s[0] // scale + 0.25 + 0.5 * wmBit) * scale
+        return cv2.idct(np.dot(u, np.dot(np.diag(s), v)))
+
+    def infer_dct_svd(self, block, scale):
+        u,s,v = np.linalg.svd(cv2.dct(block))
+
+        score = 0
+        score = int ((s[0] % scale) > scale * 0.5)
+        return score
+        if score >= 0.5:
+            return 1.0
+        else:
+            return 0.0
+
+    def encode_frame(self, frame, scale):
+        '''
+        frame is a matrix (M, N)
+
+        we get K (watermark bits size) blocks (self._block x self._block)
+
+        For i-th block, we encode watermark[i] bit into it
+        '''
+        (row, col) = frame.shape
+        num = 0
+        for i in range(row//self._block):
+            for j in range(col//self._block):
+                block = frame[i*self._block : i*self._block + self._block,
+                              j*self._block : j*self._block + self._block]
+                wmBit = self._watermarks[(num % self._wmLen)]
+
+
+                diffusedBlock = self.diffuse_dct_svd(block, wmBit, scale)
+                frame[i*self._block : i*self._block + self._block,
+                      j*self._block : j*self._block + self._block] = diffusedBlock
+
+                num = num+1

test_scripts/InvisibleWatermark_02/imwatermark/maxDct.py

@@ -0,0 +1,134 @@
+import numpy as np
+import copy
+import cv2
+import pywt
+import math
+import pprint
+
+pp = pprint.PrettyPrinter(indent=2)
+
+
+class EmbedMaxDct(object):
+    def __init__(self, watermarks=[], wmLen=8, scales=[0,36,36], block=4):
+        self._watermarks = watermarks
+        self._wmLen = wmLen
+        self._scales = scales
+        self._block = block
+
+    def encode(self, bgr):
+        (row, col, channels) = bgr.shape
+
+        yuv = cv2.cvtColor(bgr, cv2.COLOR_BGR2YUV)
+
+        for channel in range(2):
+            if self._scales[channel] <= 0:
+                continue
+
+            ca1,(h1,v1,d1) = pywt.dwt2(yuv[:row//4*4,:col//4*4,channel], 'haar')
+            self.encode_frame(ca1, self._scales[channel])
+
+            yuv[:row//4*4,:col//4*4,channel] = pywt.idwt2((ca1, (v1,h1,d1)), 'haar')
+
+        bgr_encoded = cv2.cvtColor(yuv, cv2.COLOR_YUV2BGR)
+        return bgr_encoded
+
+    def decode(self, bgr):
+        (row, col, channels) = bgr.shape
+
+        yuv = cv2.cvtColor(bgr, cv2.COLOR_BGR2YUV)
+
+        scores = [[] for i in range(self._wmLen)]
+        for channel in range(2):
+            if self._scales[channel] <= 0:
+                continue
+
+            ca1,(h1,v1,d1) = pywt.dwt2(yuv[:row//4*4,:col//4*4,channel], 'haar')
+
+            scores = self.decode_frame(ca1, self._scales[channel], scores)
+
+        avgScores = list(map(lambda l: np.array(l).mean(), scores))
+
+        bits = (np.array(avgScores) * 255 > 127)
+        return bits
+
+    def decode_frame(self, frame, scale, scores):
+        (row, col) = frame.shape
+        num = 0
+
+        for i in range(row//self._block):
+            for j in range(col//self._block):
+                block = frame[i*self._block : i*self._block + self._block,
+                              j*self._block : j*self._block + self._block]
+
+                score = self.infer_dct_matrix(block, scale)
+                #score = self.infer_dct_svd(block, scale)
+                wmBit = num % self._wmLen
+                scores[wmBit].append(score)
+                num = num + 1
+
+        return scores
+
+    def diffuse_dct_svd(self, block, wmBit, scale):
+        u,s,v = np.linalg.svd(cv2.dct(block))
+
+        s[0] = (s[0] // scale + 0.25 + 0.5 * wmBit) * scale
+        return cv2.idct(np.dot(u, np.dot(np.diag(s), v)))
+
+    def infer_dct_svd(self, block, scale):
+        u,s,v = np.linalg.svd(cv2.dct(block))
+
+        score = 0
+        score = int ((s[0] % scale) > scale * 0.5)
+        return score
+        if score >= 0.5:
+            return 1.0
+        else:
+            return 0.0
+
+    def diffuse_dct_matrix(self, block, wmBit, scale):
+        pos = np.argmax(abs(block.flatten()[1:])) + 1
+        i, j = pos // self._block, pos % self._block
+        val = block[i][j]
+        if val >= 0.0:
+            block[i][j] = (val//scale + 0.25 + 0.5 * wmBit) * scale
+        else:
+            val = abs(val)
+            block[i][j] = -1.0 * (val//scale + 0.25 + 0.5 * wmBit) * scale
+        return block
+
+    def infer_dct_matrix(self, block, scale):
+        pos = np.argmax(abs(block.flatten()[1:])) + 1
+        i, j = pos // self._block, pos % self._block
+
+        val = block[i][j]
+        if val < 0:
+            val = abs(val)
+
+        if (val % scale) > 0.5 * scale:
+            return 1
+        else:
+            return 0
+
+    def encode_frame(self, frame, scale):
+        '''
+        frame is a matrix (M, N)
+
+        we get K (watermark bits size) blocks (self._block x self._block)
+
+        For i-th block, we encode watermark[i] bit into it
+        '''
+        (row, col) = frame.shape
+        num = 0
+        for i in range(row//self._block):
+            for j in range(col//self._block):
+                block = frame[i*self._block : i*self._block + self._block,
+                              j*self._block : j*self._block + self._block]
+                wmBit = self._watermarks[(num % self._wmLen)]
+
+
+                diffusedBlock = self.diffuse_dct_matrix(block, wmBit, scale)
+                #diffusedBlock = self.diffuse_dct_svd(block, wmBit, scale)
+                frame[i*self._block : i*self._block + self._block,
+                      j*self._block : j*self._block + self._block] = diffusedBlock
+
+                num = num+1

test_scripts/InvisibleWatermark_02/imwatermark/rivaGan.py

@@ -0,0 +1,69 @@
+import numpy as np
+import torch
+import cv2
+import os
+import time
+
+
+class RivaWatermark(object):
+    encoder = None
+    decoder = None
+
+    def __init__(self, watermarks=[], wmLen=32, threshold=0.52):
+        self._watermarks = watermarks
+        self._threshold = threshold
+        if wmLen not in [32]:
+            raise RuntimeError('rivaGan only supports 32 bits watermarks now.')
+        self._data = torch.from_numpy(np.array([self._watermarks], dtype=np.float32))
+
+    @classmethod
+    def loadModel(cls):
+        try:
+            import onnxruntime
+        except ImportError:
+            raise ImportError(
+                "The `RivaWatermark` class requires onnxruntime to be installed. "
+                "You can install it with pip: `pip install onnxruntime`."
+            )
+
+        if RivaWatermark.encoder and RivaWatermark.decoder:
+            return
+        modelDir = os.path.dirname(os.path.abspath(__file__))
+        RivaWatermark.encoder = onnxruntime.InferenceSession(
+            os.path.join(modelDir, 'rivagan_encoder.onnx'))
+        RivaWatermark.decoder = onnxruntime.InferenceSession(
+            os.path.join(modelDir, 'rivagan_decoder.onnx'))
+
+    def encode(self, frame):
+        if not RivaWatermark.encoder:
+            raise RuntimeError('call loadModel method first')
+
+        frame = torch.from_numpy(np.array([frame], dtype=np.float32)) / 127.5 - 1.0
+        frame = frame.permute(3, 0, 1, 2).unsqueeze(0)
+
+        inputs = {
+            'frame': frame.detach().cpu().numpy(),
+            'data': self._data.detach().cpu().numpy()
+        }
+
+        outputs = RivaWatermark.encoder.run(None, inputs)
+        wm_frame = outputs[0]
+        wm_frame = torch.clamp(torch.from_numpy(wm_frame), min=-1.0, max=1.0)
+        wm_frame = (
+            (wm_frame[0, :, 0, :, :].permute(1, 2, 0) + 1.0) * 127.5
+        ).detach().cpu().numpy().astype('uint8')
+
+        return wm_frame
+
+    def decode(self, frame):
+        if not RivaWatermark.decoder:
+            raise RuntimeError('you need load model first')
+
+        frame = torch.from_numpy(np.array([frame], dtype=np.float32)) / 127.5 - 1.0
+        frame = frame.permute(3, 0, 1, 2).unsqueeze(0)
+        inputs = {
+            'frame': frame.detach().cpu().numpy(),
+        }
+        outputs = RivaWatermark.decoder.run(None, inputs)
+        data = outputs[0][0]
+        return np.array(data > self._threshold, dtype=np.uint8)

test_scripts/InvisibleWatermark_02/imwatermark/rivagan_decoder.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6b006690cf352fa50a91a0b6d6241dbcded0a9957969e2c0665cf9a7011b3880
+size 1088816

test_scripts/InvisibleWatermark_02/imwatermark/rivagan_encoder.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:66bc7814fadac7d686105c8ab26c6cf2cc8e40deb83e67bb6ef5b9de9b8ece0d
+size 657164

test_scripts/InvisibleWatermark_02/imwatermark/watermark.py

@@ -0,0 +1,171 @@
+import struct
+import uuid
+import copy
+import base64
+import cv2
+import numpy as np
+from .maxDct import EmbedMaxDct
+from .dwtDctSvd import EmbedDwtDctSvd
+from .rivaGan import RivaWatermark
+import pprint
+
+pp = pprint.PrettyPrinter(indent=2)
+
+class WatermarkEncoder(object):
+    def __init__(self, content=b''):
+        seq = np.array([n for n in content], dtype=np.uint8)
+        self._watermarks = list(np.unpackbits(seq))
+        self._wmLen = len(self._watermarks)
+        self._wmType = 'bytes'
+
+    def set_by_ipv4(self, addr):
+        bits = []
+        ips = addr.split('.')
+        for ip in ips:
+            bits += list(np.unpackbits(np.array([ip % 255], dtype=np.uint8)))
+        self._watermarks = bits
+        self._wmLen = len(self._watermarks)
+        self._wmType = 'ipv4'
+        assert self._wmLen == 32
+
+    def set_by_uuid(self, uid):
+        u = uuid.UUID(uid)
+        self._wmType = 'uuid'
+        seq = np.array([n for n in u.bytes], dtype=np.uint8)
+        self._watermarks = list(np.unpackbits(seq))
+        self._wmLen = len(self._watermarks)
+
+    def set_by_bytes(self, content):
+        self._wmType = 'bytes'
+        seq = np.array([n for n in content], dtype=np.uint8)
+        self._watermarks = list(np.unpackbits(seq))
+        self._wmLen = len(self._watermarks)
+
+    def set_by_b16(self, b16):
+        content = base64.b16decode(b16)
+        self.set_by_bytes(content)
+        self._wmType = 'b16'
+
+    def set_by_bits(self, bits=[]):
+        self._watermarks = [int(bit) % 2 for bit in bits]
+        self._wmLen = len(self._watermarks)
+        self._wmType = 'bits'
+
+    def set_watermark(self, wmType='bytes', content=''):
+        if wmType == 'ipv4':
+            self.set_by_ipv4(content)
+        elif wmType == 'uuid':
+            self.set_by_uuid(content)
+        elif wmType == 'bits':
+            self.set_by_bits(content)
+        elif wmType == 'bytes':
+            self.set_by_bytes(content)
+        elif wmType == 'b16':
+            self.set_by_b16(content)
+        else:
+            raise NameError('%s is not supported' % wmType)
+
+    def get_length(self):
+        return self._wmLen
+
+    @classmethod
+    def loadModel(cls):
+        RivaWatermark.loadModel()
+
+    def encode(self, cv2Image, method='dwtDct', **configs):
+        (r, c, channels) = cv2Image.shape
+        if r*c < 256*256:
+            raise RuntimeError('image too small, should be larger than 256x256')
+
+        if method == 'dwtDct':
+            embed = EmbedMaxDct(self._watermarks, wmLen=self._wmLen, **configs)
+            return embed.encode(cv2Image)
+        elif method == 'dwtDctSvd':
+            embed = EmbedDwtDctSvd(self._watermarks, wmLen=self._wmLen, **configs)
+            return embed.encode(cv2Image)
+        elif method == 'rivaGan':
+            embed = RivaWatermark(self._watermarks, self._wmLen)
+            return embed.encode(cv2Image)
+        else:
+            raise NameError('%s is not supported' % method)
+
+class WatermarkDecoder(object):
+    def __init__(self, wm_type='bytes', length=0):
+        self._wmType = wm_type
+        if wm_type == 'ipv4':
+            self._wmLen = 32
+        elif wm_type == 'uuid':
+            self._wmLen = 128
+        elif wm_type == 'bytes':
+            self._wmLen = length
+        elif wm_type == 'bits':
+            self._wmLen = length
+        elif wm_type == 'b16':
+            self._wmLen = length
+        else:
+            raise NameError('%s is unsupported' % wm_type)
+
+    def reconstruct_ipv4(self, bits):
+        ips = [str(ip) for ip in list(np.packbits(bits))]
+        return '.'.join(ips)
+
+    def reconstruct_uuid(self, bits):
+        nums = np.packbits(bits)
+        bstr = b''
+        for i in range(16):
+            bstr += struct.pack('>B', nums[i])
+
+        return str(uuid.UUID(bytes=bstr))
+
+    def reconstruct_bits(self, bits):
+        #return ''.join([str(b) for b in bits])
+        return bits
+
+    def reconstruct_b16(self, bits):
+        bstr = self.reconstruct_bytes(bits)
+        return base64.b16encode(bstr)
+
+    def reconstruct_bytes(self, bits):
+        nums = np.packbits(bits)
+        bstr = b''
+        for i in range(self._wmLen//8):
+            bstr += struct.pack('>B', nums[i])
+        return bstr
+
+    def reconstruct(self, bits):
+        if len(bits) != self._wmLen:
+            raise RuntimeError('bits are not matched with watermark length')
+
+        if self._wmType == 'ipv4':
+            return self.reconstruct_ipv4(bits)
+        elif self._wmType == 'uuid':
+            return self.reconstruct_uuid(bits)
+        elif self._wmType == 'bits':
+            return self.reconstruct_bits(bits)
+        elif self._wmType == 'b16':
+            return self.reconstruct_b16(bits)
+        else:
+            return self.reconstruct_bytes(bits)
+
+    def decode(self, cv2Image, method='dwtDct', **configs):
+        (r, c, channels) = cv2Image.shape
+        if r*c < 256*256:
+            raise RuntimeError('image too small, should be larger than 256x256')
+
+        bits = []
+        if method == 'dwtDct':
+            embed = EmbedMaxDct(watermarks=[], wmLen=self._wmLen, **configs)
+            bits = embed.decode(cv2Image)
+        elif method == 'dwtDctSvd':
+            embed = EmbedDwtDctSvd(watermarks=[], wmLen=self._wmLen, **configs)
+            bits = embed.decode(cv2Image)
+        elif method == 'rivaGan':
+            embed = RivaWatermark(watermarks=[], wmLen=self._wmLen, **configs)
+            bits = embed.decode(cv2Image)
+        else:
+            raise NameError('%s is not supported' % method)
+        return self.reconstruct(bits)
+
+    @classmethod
+    def loadModel(cls):
+        RivaWatermark.loadModel()

test_scripts/InvisibleWatermark_02/test_script.py

@@ -0,0 +1,83 @@
+import argparse
+import os
+import json
+from datetime import datetime
+from io import StringIO
+import sys
+
+def test_watermark_extraction(extracted_txt_path, ground_truth_path):
+    comments = []
+    process_success = True
+    result_success = False
+
+    try:
+        for path, label in [(extracted_txt_path, "Extracted result"), (ground_truth_path, "Ground Truth")]:
+            if not os.path.exists(path):
+                comments.append(f"{label} file does not exist: {path}")
+                process_success = False
+            elif os.path.getsize(path) == 0:
+                comments.append(f"{label} file is empty: {path}")
+                process_success = False
+
+        if not process_success:
+            return process_success, result_success, "\n".join(comments)
+
+        with open(extracted_txt_path, 'r', encoding='utf-8') as f:
+            extracted_watermark = f.read().strip()
+
+        with open(ground_truth_path, 'r', encoding='utf-8') as f:
+            ground_truth = f.read().strip()
+
+        if extracted_watermark == ground_truth:
+            result_success = True
+            comments.append("✅ Watermark extraction successful, exact match!")
+        else:
+            comments.append("❌ Watermark extraction failed, result does not match Ground Truth")
+            comments.append(f"Extracted watermark: {extracted_watermark}")
+            comments.append(f"Ground Truth: {ground_truth}")
+
+    except Exception as e:
+        process_success = False
+        comments.append(f"System exception: {str(e)}")
+
+    return process_success, result_success, "\n".join(comments)
+
+def save_result_jsonl(result_path, process_flag, result_flag, comments_text):
+    record = {
+        "Process": process_flag,
+        "Result": result_flag,
+        "TimePoint": datetime.now().isoformat(timespec="seconds"),
+        "comments": comments_text
+    }
+
+    try:
+        with open(result_path, 'a', encoding='utf-8') as f:
+            json.dump(record, f, ensure_ascii=False)
+            f.write('\n')
+        print(f"[✅] Successfully wrote to JSONL: {result_path}")
+    except Exception as e:
+        print(f"[❌] Failed to write to JSONL: {e}")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Evaluate watermark extraction accuracy (exact match)")
+    parser.add_argument("--output", required=True, help="Path to extracted watermark text file")
+    parser.add_argument("--groundtruth", required=True, help="Path to ground truth text file")
+    parser.add_argument("--result", required=False, help="JSONL output path")
+    args = parser.parse_args()
+
+    original_stdout = sys.stdout
+    buffer = StringIO()
+    sys.stdout = buffer
+
+    process_flag, result_flag, comments_text = test_watermark_extraction(
+        args.output, args.groundtruth
+    )
+
+    sys.stdout = original_stdout
+    captured_output = buffer.getvalue()
+    full_comments = f"{comments_text}\n{captured_output.strip()}"
+
+    if args.result:
+        save_result_jsonl(args.result, process_flag, result_flag, full_comments)
+
+    print(full_comments)

test_scripts/InvisibleWatermark_03/imwatermark/__init__.py

@@ -0,0 +1 @@
+from .watermark import WatermarkEncoder, WatermarkDecoder