first commit

.gitattributes

@@ -33,3 +33,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.axmodel filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.JPG filter=lfs diff=lfs merge=lfs -text

AOD-Net/model_convert/AOD-Net.json

@@ -0,0 +1,39 @@
+{
+  "input": "./aodnet_1x3x480x640.onnx",
+  "output_dir": "./aodnet",
+  "output_name": "aodnet.axmodel",
+  "model_type": "ONNX",
+  "target_hardware": "AX650",
+  "npu_mode": "NPU3",
+  "quant": {
+    "input_configs": [
+      {
+        "tensor_name": "input",
+        "calibration_dataset": "./hazy.tar.gz",
+        "calibration_size": -1,
+        "calibration_mean": [127.5, 127.5, 127.5],
+        "calibration_std": [127.5, 127.5, 127.5]
+      }
+    ],
+    "calibration_method": "MinMax",
+    "precision_analysis": true,
+    "transformer_opt_level":1,
+    "precision_analysis_method": "EndToEnd",
+    "precision_analysis_mode": "NPUBackend", 
+  },
+  "input_processors": [
+    {
+      "tensor_name": "input",
+      "tensor_format": "RGB",
+      "tensor_layout": "NCHW",
+      "src_format": "BGR",
+      "src_dtype": "U8",
+      "src_layout": "NCHW",
+      "csc_mode": "NoCSC"
+    }
+  ],
+  "compiler": {
+    "check": 2
+  }
+}
+

AOD-Net/model_convert/axmodel/aodnet_1x3x480x640_sim.axmodel

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

AOD-Net/python/axmodel_infer.py

@@ -0,0 +1,67 @@
+import argparse
+
+import numpy as np
+import axengine as axe
+from PIL import Image, ImageDraw, ImageFont
+
+
+def draw_label(img, text):
+    draw = ImageDraw.Draw(img)
+    try:
+        font = ImageFont.truetype("DejaVuSans-Bold.ttf", max(18, img.height // 36))
+    except Exception:
+        font = ImageFont.load_default()
+    padding = 6
+    bbox = draw.textbbox((0, 0), text, font=font)
+    box_w = bbox[2] - bbox[0] + padding * 2
+    box_h = bbox[3] - bbox[1] + padding * 2
+    draw.rectangle([0, 0, box_w, box_h], fill=(0, 0, 0))
+    draw.text((padding, padding), text, fill=(255, 255, 255), font=font)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="axmodel single-image dehazing inference.")
+    parser.add_argument("--axmodel", default="aodnet_1x3x480x640_sim.axmodel", help="axmodel model path")
+    parser.add_argument("--input_image", default='./pic/canyon2.jpg', help="hazy image path")
+    parser.add_argument("--output", default="axmodel_compare.png", help="output comparison path (hazy | dehazed)")
+    parser.add_argument("--height", type=int, default=480, help="resize height (match axmodel input)")
+    parser.add_argument("--width", type=int, default=640, help="resize width (match axmodel input)")
+    parser.add_argument("--normalize", action="store_true", help="use (x-0.5)/0.5 normalization")
+    parser.add_argument("--no_label", action="store_true", help="do not draw hazy/dehazed labels")
+    args = parser.parse_args()
+
+    img = Image.open(args.input_image).convert("RGB")
+    orig_size = img.size
+    img_resized = img.resize((args.width, args.height), Image.BILINEAR)
+
+    arr = np.asarray(img_resized).astype(np.float32)
+    arr = arr.transpose(2, 0, 1)[None, :, :, :].astype(np.uint8)
+
+    sess = axe.InferenceSession(args.axmodel, providers=["AxEngineExecutionProvider"])
+    input_name = sess.get_inputs()[0].name
+    out = sess.run(None, {input_name: arr})[0]
+
+    out = out[0].transpose(1, 2, 0)
+    out = np.clip(out, 0.0, 1.0)
+    out_img = Image.fromarray((out * 255.0).round().astype(np.uint8))
+    # 还原到原图大小
+    if out_img.size != orig_size:
+        out_img = out_img.resize(orig_size, Image.BICUBIC)
+
+    hazy_labeled = img.copy()
+    dehazed_labeled = out_img.copy()
+    if not args.no_label:
+        draw_label(hazy_labeled, "hazy")
+        draw_label(dehazed_labeled, "dehazed")
+
+    compare = Image.new("RGB", (img.width + out_img.width, max(img.height, out_img.height)))
+    compare.paste(hazy_labeled, (0, 0))
+    compare.paste(dehazed_labeled, (img.width, 0))
+    compare.save(args.output)
+
+    print("Saved:", args.output)
+    print("Input: {:.0f}x{:.0f} -> axmodel: {}x{}".format(*orig_size, args.height, args.width))
+
+
+if __name__ == "__main__":
+    main()

AOD-Net/python/onnx_infer.py

@@ -0,0 +1,45 @@
+import argparse
+
+import numpy as np
+import onnxruntime as ort
+from PIL import Image
+
+
+def main():
+    parser = argparse.ArgumentParser(description="ONNX single-image dehazing inference.")
+    parser.add_argument("--onnx", default="aodnet_1x3x480x640_sim.onnx", help="ONNX model path")
+    parser.add_argument("--input_image", required=True, help="hazy image path")
+    parser.add_argument("--output", default="onnx_result.png", help="output path")
+    parser.add_argument("--height", type=int, default=480, help="resize height (match ONNX input)")
+    parser.add_argument("--width", type=int, default=640, help="resize width (match ONNX input)")
+    parser.add_argument("--normalize", action="store_true", help="use (x-0.5)/0.5 normalization")
+    args = parser.parse_args()
+
+    img = Image.open(args.input_image).convert("RGB")
+    orig_size = img.size
+    img = img.resize((args.width, args.height), Image.BILINEAR)
+
+    arr = np.asarray(img).astype(np.float32) / 255.0
+    if args.normalize:
+        arr = (arr - 0.5) / 0.5
+    arr = arr.transpose(2, 0, 1)[None, :, :, :].astype(np.float32)
+
+    sess = ort.InferenceSession(args.onnx, providers=["CPUExecutionProvider"])
+    input_name = sess.get_inputs()[0].name
+    out = sess.run(None, {input_name: arr})[0]
+
+    out = out[0].transpose(1, 2, 0)
+    out = np.clip(out, 0.0, 1.0)
+    out_img = Image.fromarray((out * 255.0).round().astype(np.uint8))
+
+    compare = Image.new("RGB", (img.width + out_img.width, max(img.height, out_img.height)))
+    compare.paste(img, (0, 0))
+    compare.paste(out_img, (img.width, 0))
+    compare.save(args.output)
+
+    print("Saved:", args.output)
+    print("Input: {:.0f}x{:.0f} -> ONNX: {}x{}".format(*orig_size, args.height, args.width))
+
+
+if __name__ == "__main__":
+    main()

DehazeFormer/model_convert/axmodel/dehazeformer-t-512-constant.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8f204bfa4061ac07ecaf6efb1e387edb81dd3a352c01d31dd690850f8778cc92
+size 7272273

DehazeFormer/model_convert/dehazeformer.json

@@ -0,0 +1,39 @@
+{
+  "input": "./dehazeformer-t-512-constant.onnx",
+  "output_dir": "./dehazeformer-t-512-constant",
+  "output_name": "dehazeformer-t-512-constant.axmodel",
+  "model_type": "ONNX",
+  "target_hardware": "AX650",
+  "npu_mode": "NPU3",
+  "quant": {
+    "input_configs": [
+      {
+        "tensor_name": "input",
+        "calibration_dataset": "./hazy.tar.gz",
+        "calibration_size": -1,
+        "calibration_mean": [127.5, 127.5, 127.5],
+        "calibration_std": [127.5, 127.5, 127.5]
+      }
+    ],
+    "calibration_method": "MinMax",
+    "precision_analysis": true,
+    "transformer_opt_level":1,
+    "precision_analysis_method": "EndToEnd",
+    "precision_analysis_mode": "NPUBackend", 
+  },
+  "input_processors": [
+    {
+      "tensor_name": "input",
+      "tensor_format": "RGB",
+      "tensor_layout": "NCHW",
+      "src_format": "BGR",
+      "src_dtype": "U8",
+      "src_layout": "NCHW",
+      "csc_mode": "NoCSC"
+    }
+  ],
+  "compiler": {
+    "check": 2
+  }
+}
+

DehazeFormer/python/axmodel_infer.py

@@ -0,0 +1,118 @@
+import argparse
+from pathlib import Path
+
+import cv2
+import numpy as np
+import axengine as axe
+
+def hwc_to_chw(img):
+    return np.transpose(img, axes=[2, 0, 1]).copy()
+
+
+def chw_to_hwc(img):
+    return np.transpose(img, axes=[1, 2, 0]).copy()
+
+
+def read_rgb_float(image_path, size=None):
+    img = cv2.imread(str(image_path))
+    img = img[:, :, ::-1]  # BGR -> RGB
+    img = cv2.resize(img, size, interpolation=cv2.INTER_AREA)
+    return img
+
+def preprocess(image_path, size=None):
+    img = read_rgb_float(image_path, size=size)
+    return hwc_to_chw(img).astype(np.uint8)[None, ...]
+
+
+def get_axmodel_input_size(session):
+    shape = session.get_inputs()[0].shape  # [N, C, H, W]
+    h, w = shape[2], shape[3]
+    if isinstance(h, int) and isinstance(w, int):
+        return w, h
+    return None
+
+
+def infer_axmodel(session, image_path, size=None):
+    tensor = preprocess(image_path, size=size)
+    input_name = session.get_inputs()[0].name
+    output_name = session.get_outputs()[0].name
+    out = session.run([output_name], {input_name: tensor})[0]
+    out = np.clip(out, -1, 1)
+    out = out * 0.5 + 0.5
+    return chw_to_hwc(out.squeeze(0))
+
+
+def load_session(axmodel_path):
+    providers = ['AxEngineExecutionProvider']
+    return axe.InferenceSession(str(axmodel_path), providers=providers)
+
+
+def save_comparison(hazy_path, dehazed, output_path, size=None):
+    """拼接原图(hazy)和去雾图(dehazed)，并标注标签"""
+    hazy = cv2.imread(str(hazy_path))
+    if hazy is None:
+        raise FileNotFoundError(f'Failed to read image: {hazy_path}')
+
+    h, w = dehazed.shape[:2]
+    if hazy.shape[:2] != (h, w):
+        hazy = cv2.resize(hazy, (w, h), interpolation=cv2.INTER_AREA)
+
+    # hazy 是 BGR，dehazed 是 RGB -> 转 BGR 再拼接
+    dehazed_bgr = cv2.cvtColor(
+        np.round(dehazed * 255).clip(0, 255).astype(np.uint8),
+        cv2.COLOR_RGB2BGR,
+    )
+
+    pad = 40
+    canvas = np.full((h + pad, w * 2, 3), 255, dtype=np.uint8)
+    canvas[pad:, :w] = hazy
+    canvas[pad:, w:] = dehazed_bgr
+
+    font = cv2.FONT_HERSHEY_SIMPLEX
+    cv2.putText(canvas, 'Hazy', (w // 2 - 40, pad - 8), font, 0.9, (0, 0, 0), 2, cv2.LINE_AA)
+    cv2.putText(canvas, 'Dehazed', (w + w // 2 - 60, pad - 8), font, 0.9, (0, 0, 0), 2, cv2.LINE_AA)
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    cv2.imwrite(str(output_path), canvas)
+
+
+def main(args):
+    axmodel_path = Path(args.axmodel)
+    if not axmodel_path.is_file():
+        raise FileNotFoundError(f'axmodel model not found: {axmodel_path}')
+
+    input_path = Path(args.input)
+    if not input_path.is_file():
+        raise FileNotFoundError(f'Input image not found: {input_path}')
+
+    output_path = Path(args.output)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    session = load_session(axmodel_path)
+
+    axmodel_size = get_axmodel_input_size(session)
+    if args.width > 0 and args.height > 0:
+        infer_size = (args.width, args.height)
+    elif axmodel_size is not None:
+        infer_size = axmodel_size
+    else:
+        infer_size = None
+
+    print(f'axmodel:    {axmodel_path}')
+    print(f'Input:   {input_path}')
+    print(f'Size:    {infer_size}')
+    print(f'Output:  {output_path}')
+
+    out_img = infer_axmodel(session, input_path, size=infer_size)
+    save_comparison(input_path, out_img, output_path)
+    print('Done.')
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Single-image axmodel inference for DehazeFormer.')
+    parser.add_argument('--input', default='./00000_0_0.1800.png', type=str, help='path to input image')
+    parser.add_argument('--axmodel', default='./dehazeformer-t-512-constant.axmodel', type=str, help='path to axmodel model')
+    parser.add_argument('--output', default='output.png', type=str, help='path to output image')
+    parser.add_argument('--width', default=-1, type=int, help='resize input width (-1 uses axmodel fixed size)')
+    parser.add_argument('--height', default=-1, type=int, help='resize input height (-1 uses axmodel fixed size)')
+    main(parser.parse_args())

DehazeFormer/python/onnx_infer.py

@@ -0,0 +1,126 @@
+import argparse
+from pathlib import Path
+
+import cv2
+import numpy as np
+import onnxruntime as ort
+
+def hwc_to_chw(img):
+    return np.transpose(img, axes=[2, 0, 1]).copy()
+
+
+def chw_to_hwc(img):
+    return np.transpose(img, axes=[1, 2, 0]).copy()
+
+
+def read_rgb_float(image_path, size=None):
+    img = cv2.imread(str(image_path))
+    if img is None:
+        raise FileNotFoundError(f'Failed to read image: {image_path}')
+    img = img[:, :, ::-1]  # BGR -> RGB
+    if size is not None:
+        img = cv2.resize(img, size, interpolation=cv2.INTER_AREA)
+    return img.astype(np.float32) / 255.0
+
+
+def preprocess(image_path, size=None):
+    img = read_rgb_float(image_path, size=size) * 2 - 1
+    return hwc_to_chw(img).astype(np.float32)[None, ...]
+
+
+def get_onnx_input_size(session):
+    shape = session.get_inputs()[0].shape  # [N, C, H, W]
+    h, w = shape[2], shape[3]
+    if isinstance(h, int) and isinstance(w, int):
+        return w, h
+    return None
+
+
+def infer_onnx(session, image_path, size=None):
+    tensor = preprocess(image_path, size=size)
+    input_name = session.get_inputs()[0].name
+    output_name = session.get_outputs()[0].name
+    out = session.run([output_name], {input_name: tensor})[0]
+    out = np.clip(out, -1, 1)
+    out = out * 0.5 + 0.5
+    return chw_to_hwc(out.squeeze(0))
+
+
+def load_session(onnx_path, use_cpu=False):
+    providers = []
+    if not use_cpu and 'CUDAExecutionProvider' in ort.get_available_providers():
+        providers.append('CUDAExecutionProvider')
+    providers.append('CPUExecutionProvider')
+    return ort.InferenceSession(str(onnx_path), providers=providers)
+
+
+def save_comparison(hazy_path, dehazed, output_path, size=None):
+    """拼接原图(hazy)和去雾图(dehazed)，并标注标签"""
+    hazy = cv2.imread(str(hazy_path))
+    if hazy is None:
+        raise FileNotFoundError(f'Failed to read image: {hazy_path}')
+
+    h, w = dehazed.shape[:2]
+    if hazy.shape[:2] != (h, w):
+        hazy = cv2.resize(hazy, (w, h), interpolation=cv2.INTER_AREA)
+
+    # hazy 是 BGR，dehazed 是 RGB -> 转 BGR 再拼接
+    dehazed_bgr = cv2.cvtColor(
+        np.round(dehazed * 255).clip(0, 255).astype(np.uint8),
+        cv2.COLOR_RGB2BGR,
+    )
+
+    pad = 40
+    canvas = np.full((h + pad, w * 2, 3), 255, dtype=np.uint8)
+    canvas[pad:, :w] = hazy
+    canvas[pad:, w:] = dehazed_bgr
+
+    font = cv2.FONT_HERSHEY_SIMPLEX
+    cv2.putText(canvas, 'Hazy', (w // 2 - 40, pad - 8), font, 0.9, (0, 0, 0), 2, cv2.LINE_AA)
+    cv2.putText(canvas, 'Dehazed', (w + w // 2 - 60, pad - 8), font, 0.9, (0, 0, 0), 2, cv2.LINE_AA)
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    cv2.imwrite(str(output_path), canvas)
+
+
+def main(args):
+    onnx_path = Path(args.onnx)
+    if not onnx_path.is_file():
+        raise FileNotFoundError(f'ONNX model not found: {onnx_path}')
+
+    input_path = Path(args.input)
+    if not input_path.is_file():
+        raise FileNotFoundError(f'Input image not found: {input_path}')
+
+    output_path = Path(args.output)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    session = load_session(onnx_path, args.cpu)
+
+    onnx_size = get_onnx_input_size(session)
+    if args.width > 0 and args.height > 0:
+        infer_size = (args.width, args.height)
+    elif onnx_size is not None:
+        infer_size = onnx_size
+    else:
+        infer_size = None
+
+    print(f'ONNX:    {onnx_path}')
+    print(f'Input:   {input_path}')
+    print(f'Size:    {infer_size}')
+    print(f'Output:  {output_path}')
+
+    out_img = infer_onnx(session, input_path, size=infer_size)
+    save_comparison(input_path, out_img, output_path)
+    print('Done.')
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Single-image ONNX inference for DehazeFormer.')
+    parser.add_argument('--input', required=True, type=str, help='path to input image')
+    parser.add_argument('--onnx', required=True, type=str, help='path to ONNX model')
+    parser.add_argument('--output', default='output.png', type=str, help='path to output image')
+    parser.add_argument('--width', default=-1, type=int, help='resize input width (-1 uses ONNX fixed size)')
+    parser.add_argument('--height', default=-1, type=int, help='resize input height (-1 uses ONNX fixed size)')
+    parser.add_argument('--cpu', action='store_true', help='force CPU inference')
+    main(parser.parse_args())

FFA-Net/model_convert/FFA-net.json

@@ -0,0 +1,58 @@
+{
+  "input": "./ffa_ots_512x512.onnx",
+  "output_dir": "./FFA-Net",
+  "output_name": "FFANet.axmodel",
+  "model_type": "ONNX",
+  "target_hardware": "AX650",
+  "npu_mode": "NPU3",
+  "quant": {
+    "input_configs": [
+      {
+        "tensor_name": "input",
+        "calibration_dataset": "./RESIDE.tar.gz",
+        "calibration_size": 1,
+        "calibration_mean": [163.2, 153, 147.9],
+        "calibration_std": [35.7, 38.25, 38.76]
+      }
+    ],
+    "calibration_method": "MinMax",
+    "precision_analysis": true,
+    "transformer_opt_level":1,
+    // "enable_smooth_quant": true,
+    "precision_analysis_method": "EndToEnd",
+    "precision_analysis_mode": "NPUBackend", 
+    "device": "cuda:1",
+    // "layer_configs": [
+    //   {
+    //     "start_tensor_names": ["DEFAULT"],
+    //     "end_tensor_names": ["DEFAULT"],
+    //     "data_type": "U16"
+    //   }
+    // ]
+  },
+  "input_processors": [
+    {
+      "tensor_name": "input",
+      "tensor_format": "RGB",
+      "tensor_layout": "NCHW",
+      "src_format": "BGR",
+      "src_dtype": "U8",
+      "src_layout": "NCHW",
+      "csc_mode": "NoCSC"
+    }
+    // {
+    //   "tensor_name": "input",
+    //   "tensor_format": "RGB",
+    //   "tensor_layout": "NCHW",
+    //   "src_format": "YUV420SP",
+    //   "src_layout": "NHWC",
+    //   "src_dtype": "U8",
+    //   "csc_mode": "FullRange",
+    //   "csc_mat": [1.164, 0, 1.596, -222.912, 1.164, -0.392, -0.813, 135.616, 1.164, 2.017, 0, -276.8]
+    // }
+  ],
+  "compiler": {
+    "check": 2
+  }
+}
+

FFA-Net/model_convert/axmodel/FFANet.axmodel

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

FFA-Net/python/axmodel_infer.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+"""Single-image FFA-Net axmodel inference."""
+
+import argparse
+import sys
+from pathlib import Path
+
+import numpy as np
+import axengine as axe
+from PIL import Image
+
+
+FILE = Path(__file__).resolve()
+NET_DIR = FILE.parent
+ROOT_DIR = NET_DIR.parent
+sys.path.insert(0, str(NET_DIR))
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="FFA-Net axmodel single-image inference.")
+    parser.add_argument("--axmodel", default='./FFANet.axmodel', help="axmodel model path.")
+    parser.add_argument("--input", default='outdoor_natural/nh(4).jpg', help="Path to input hazy image.")
+    parser.add_argument("--output", default="axmodel_result.png", help="Output image path.")
+    parser.add_argument("--height", type=int, default=512, help="axmodel input height.")
+    parser.add_argument("--width", type=int, default=512, help="axmodel input width.")
+    return parser.parse_args()
+
+# MEAN = np.array([0.64, 0.6, 0.58], dtype=np.float32).reshape(3, 1, 1)
+# STD = np.array([0.14, 0.15, 0.152], dtype=np.float32).reshape(3, 1, 1)
+
+def preprocess(image_path, height, width):
+    image = Image.open(image_path).convert("RGB")
+    image = image.resize((width, height), Image.BICUBIC)
+    arr = np.asarray(image).astype(np.float32)
+    arr = arr.transpose(2, 0, 1)
+    # arr = (arr - MEAN) / STD          # 训练同款归一化
+    return arr[None, ...].astype(np.uint8)
+
+
+def postprocess(output):
+    arr = np.squeeze(output, axis=0).transpose(1, 2, 0)
+    arr = np.clip(arr, 0.0, 1.0)
+    return Image.fromarray((arr * 255.0 + 0.5).astype(np.uint8))
+
+
+def main():
+    args = parse_args()
+
+    inp = preprocess(args.input, args.height, args.width)
+    session = axe.InferenceSession(args.axmodel, providers=["AxEngineExecutionProvider"])
+    input_name = session.get_inputs()[0].name
+    out = session.run(None, {input_name: inp})[0]
+
+    output_path = Path(args.output)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    result = postprocess(out)
+    result.save(str(output_path))
+    print(f"Saved: {output_path}")
+
+
+if __name__ == "__main__":
+    main()

FFA-Net/python/onnx_infer.py

@@ -0,0 +1,94 @@
+"""Single-image FFA-Net ONNX inference with side-by-side comparison output."""
+
+import argparse
+import sys
+from pathlib import Path
+
+import numpy as np
+import onnxruntime as ort
+from PIL import Image, ImageDraw, ImageFont
+
+
+FILE = Path(__file__).resolve()
+NET_DIR = FILE.parent
+ROOT_DIR = NET_DIR.parent
+sys.path.insert(0, str(NET_DIR))
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="FFA-Net ONNX single-image inference.")
+    parser.add_argument("--onnx", default='onnx/ffa_ots_512x512.onnx', help="ONNX model path.")
+    parser.add_argument("--input", default='outdoor_natural/nh(2).jpg', help="Path to input hazy image.")
+    parser.add_argument("--output", default="onnx_compare.png", help="Output comparison image path (hazy | dehazed).")
+    parser.add_argument("--height", type=int, default=512, help="ONNX input height.")
+    parser.add_argument("--width", type=int, default=512, help="ONNX input width.")
+    parser.add_argument("--no_label", action="store_true", help="Do not draw hazy/dehazed labels.")
+    return parser.parse_args()
+
+
+MEAN = np.array([0.64, 0.6, 0.58], dtype=np.float32).reshape(3, 1, 1)
+STD = np.array([0.14, 0.15, 0.152], dtype=np.float32).reshape(3, 1, 1)
+
+
+def preprocess(image_path, height, width):
+    image = Image.open(image_path).convert("RGB")
+    image = image.resize((width, height), Image.BICUBIC)
+    arr = np.asarray(image).astype(np.float32) / 255.0
+    arr = arr.transpose(2, 0, 1)
+    arr = (arr - MEAN) / STD          # 训练同款归一化
+    return arr[None, ...].astype(np.float32)
+
+
+def postprocess(output):
+    arr = np.squeeze(output, axis=0).transpose(1, 2, 0)
+    arr = np.clip(arr, 0.0, 1.0)
+    return Image.fromarray((arr * 255.0 + 0.5).astype(np.uint8))
+
+
+def draw_label(img, text):
+    draw = ImageDraw.Draw(img)
+    try:
+        font = ImageFont.truetype("DejaVuSans-Bold.ttf", max(16, img.height // 40))
+    except Exception:
+        font = ImageFont.load_default()
+    padding = max(5, img.height // 140)
+    bbox = draw.textbbox((0, 0), text, font=font)
+    box_w = bbox[2] - bbox[0] + padding * 2
+    box_h = bbox[3] - bbox[1] + padding * 2
+    draw.rectangle([0, 0, box_w, box_h], fill=(0, 0, 0))
+    draw.text((padding, padding), text, fill=(255, 255, 255), font=font)
+
+
+def make_compare(hazy, dehazed, with_label=True):
+    hazy = hazy.convert("RGB")
+    dehazed = dehazed.convert("RGB")
+    if with_label:
+        hazy = hazy.copy()
+        dehazed = dehazed.copy()
+        draw_label(hazy, "hazy")
+        draw_label(dehazed, "dehazed")
+    canvas = Image.new("RGB", (hazy.width + dehazed.width, hazy.height), color=(255, 255, 255))
+    canvas.paste(hazy, (0, 0))
+    canvas.paste(dehazed, (hazy.width, 0))
+    return canvas
+
+
+def main():
+    args = parse_args()
+
+    hazy_img = Image.open(args.input).convert("RGB").resize((args.width, args.height), Image.BICUBIC)
+    inp = preprocess(args.input, args.height, args.width)
+    session = ort.InferenceSession(args.onnx, providers=["CPUExecutionProvider"])
+    input_name = session.get_inputs()[0].name
+    out = session.run(None, {input_name: inp})[0]
+
+    output_path = Path(args.output)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    dehazed = postprocess(out)
+    compare = make_compare(hazy_img, dehazed, with_label=not args.no_label)
+    compare.save(str(output_path))
+    print(f"Saved: {output_path}")
+
+
+if __name__ == "__main__":
+    main()

GCANet/model_convert/GCANet.json

@@ -0,0 +1,50 @@
+{
+  "input": "./gcanet_dehaze_512x512_sim.onnx",
+  "output_dir": "./GCANet_fix",
+  "output_name": "GCANet_U16.axmodel",
+  "model_type": "ONNX",
+  "target_hardware": "AX650",
+  "npu_mode": "NPU3",
+  "quant": {
+    "input_configs": [
+      {
+        "tensor_name": "input",
+        "calibration_dataset": "./reside_quant_npy.tar.gz",
+        "calibration_format": "Numpy",
+        "calibration_size": 1,
+        "calibration_mean": [0,0,0,0],
+        "calibration_std": [1,1,1,1]
+      }
+    ],
+    "calibration_method": "MinMax",
+    "precision_analysis": true,
+    "transformer_opt_level":1,
+    "precision_analysis_method": "EndToEnd",
+    "precision_analysis_mode": "NPUBackend", 
+    "device": "cpu",
+    "layer_configs": [
+      {
+        "start_tensor_names": ["DEFAULT"],
+        "end_tensor_names": ["DEFAULT"],
+        "data_type": "U16"
+      }
+    ]
+  },
+  "input_processors": [
+    {
+      "tensor_name": "input",
+      "tensor_format": "AutoColorSpace",
+      "tensor_layout": "NCHW",
+      "src_format": "AutoColorSpace",
+      "src_dtype": "U8",
+      "src_layout": "NCHW",
+      "csc_mode": "NoCSC",
+      "mean": [128,128,128,128],
+      "std": [1,1,1,1]
+    }
+  ],
+  "compiler": {
+    "check": 2
+  }
+}
+

GCANet/model_convert/axmodel/GCANet_U16.axmodel

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

GCANet/python/axmodel_infer.py

@@ -0,0 +1,123 @@
+import argparse
+import os
+
+import numpy as np
+import axengine as axe
+from PIL import Image, ImageDraw, ImageFont
+
+
+HEIGHT = 512
+WIDTH = 512
+IMG_EXTENSIONS = ('.jpg', '.JPG', '.jpeg', '.JPEG', '.png', '.PNG', '.ppm', '.PPM', '.bmp', '.BMP')
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='Run GCANet axmodel inference with fixed 512x512 input.')
+    parser.add_argument('--task', default='dehaze', choices=['dehaze', 'derain'])
+    parser.add_argument('--axmodel', default='GCANet_u16.axmodel', help='Path to axmodel model.')
+    parser.add_argument('--indir', default='examples')
+    parser.add_argument('--outdir', default='axmodel_output')
+    parser.add_argument(
+        '--input-mode',
+        default='raw_u8',
+        choices=['compat_centered_u8', 'raw_u8'],
+        help='compat_centered_u8 keeps the historical centered input encoding for the current axmodel; raw_u8 follows the declared U8 input processor literally.',
+    )
+    return parser.parse_args()
+
+
+def make_dataset(image_dir):
+    images = []
+    assert os.path.isdir(image_dir), '%s is not a valid directory' % image_dir
+    for root, _, fnames in sorted(os.walk(image_dir)):
+        for fname in fnames:
+            if fname.endswith(IMG_EXTENSIONS):
+                images.append(os.path.join(root, fname))
+    return images
+
+
+def edge_compute_np(img_chw):
+    x_diffx = np.abs(img_chw[:, :, 1:] - img_chw[:, :, :-1])
+    x_diffy = np.abs(img_chw[:, 1:, :] - img_chw[:, :-1, :])
+
+    edge = np.zeros_like(img_chw, dtype=np.float32)
+    edge[:, :, 1:] += x_diffx
+    edge[:, :, :-1] += x_diffx
+    edge[:, 1:, :] += x_diffy
+    edge[:, :-1, :] += x_diffy
+    edge = np.sum(edge, axis=0, keepdims=True) / 3.0
+    edge = edge / 4.0
+    return edge.astype(np.float32)
+
+
+def preprocess(img_path, input_mode):
+    img = Image.open(img_path).convert('RGB')
+    img = img.resize((WIDTH, HEIGHT), Image.BICUBIC)
+    img_rgb = np.array(img).astype(np.float32)
+    img_rgb_chw = np.transpose(img_rgb, (2, 0, 1))
+    edge = edge_compute_np(img_rgb_chw)
+
+    # This 4-channel model is calibrated from RGB+edge NCHW tensors.
+    # The build config marks src_format=BGR/tensor_format=RGB, but with
+    # csc_mode=NoCSC there is no runtime color conversion, so feeding BGR here
+    # would silently swap channels and introduce artifacts.
+    model_input = np.concatenate((img_rgb_chw, edge), axis=0)[None, :, :, :]
+    if input_mode == 'compat_centered_u8':
+        # The original float model consumes (rgb+edge-128). The current axmodel
+        # was compiled as U8 input without explicit dequant params, so we keep
+        # the historical wraparound encoding here for compatibility.
+        model_input = np.mod(np.round(model_input - 128.0), 256.0).astype(np.uint8)
+    else:
+        model_input = np.clip(np.round(model_input), 0, 255).astype(np.uint8)
+    return img_rgb_chw, model_input
+
+
+def postprocess(pred, img_chw, only_residual):
+    out = pred[0].astype(np.float32)
+    if only_residual:
+        out = out + img_chw
+    out = np.round(out).clip(0, 255).astype(np.uint8)
+    out = np.transpose(out, (1, 2, 0))
+    return out
+
+
+def make_comparison_image(input_chw, output_hwc, task):
+    input_hwc = np.transpose(input_chw, (1, 2, 0)).clip(0, 255).astype(np.uint8)
+    input_img = Image.fromarray(input_hwc, mode='RGB')
+    output_img = Image.fromarray(output_hwc, mode='RGB')
+
+    title_height = 32
+    comparison = Image.new('RGB', (WIDTH * 2, HEIGHT + title_height), color='white')
+    comparison.paste(input_img, (0, title_height))
+    comparison.paste(output_img, (WIDTH, title_height))
+
+    draw = ImageDraw.Draw(comparison)
+    font = ImageFont.load_default()
+    right_label = 'dehaze' if task == 'dehaze' else task
+    draw.text((8, 8), 'hazy', fill='black', font=font)
+    draw.text((WIDTH + 8, 8), right_label, fill='black', font=font)
+    draw.line((WIDTH, 0, WIDTH, HEIGHT + title_height), fill='black', width=1)
+    return comparison
+
+
+def main():
+    args = parse_args()
+    axmodel_path = args.axmodel or os.path.join('onnx', 'gcanet_%s_512x512_sim.axmodel' % args.task)
+    only_residual = args.task == 'dehaze'
+    os.makedirs(args.outdir, exist_ok=True)
+
+    session = axe.InferenceSession(axmodel_path, providers=['AxEngineExecutionProvider'])
+    input_name = session.get_inputs()[0].name
+
+    for img_path in make_dataset(args.indir):
+        img_chw, model_input = preprocess(img_path, args.input_mode)
+        pred = session.run(None, {input_name: model_input})[0]
+        out_img = postprocess(pred, img_chw, only_residual)
+        comparison = make_comparison_image(img_chw, out_img, args.task)
+        save_name = os.path.splitext(os.path.basename(img_path))[0] + '_%s_compare.png' % args.task
+        comparison.save(os.path.join(args.outdir, save_name))
+        print('Saved:', os.path.join(args.outdir, save_name))
+
+
+if __name__ == '__main__':
+    main()

GCANet/python/onnx_infer.py

@@ -0,0 +1,85 @@
+import argparse
+import os
+
+import numpy as np
+import onnxruntime as ort
+from PIL import Image
+
+
+HEIGHT = 512
+WIDTH = 512
+IMG_EXTENSIONS = ('.jpg', '.JPG', '.jpeg', '.JPEG', '.png', '.PNG', '.ppm', '.PPM', '.bmp', '.BMP')
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='Run GCANet ONNX inference with fixed 512x512 input.')
+    parser.add_argument('--task', default='dehaze', choices=['dehaze', 'derain'])
+    parser.add_argument('--onnx', default=None, help='Path to ONNX model. Default: onnx/gcanet_{task}_512x512_sim.onnx')
+    parser.add_argument('--indir', default='examples')
+    parser.add_argument('--outdir', default='onnx_output')
+    return parser.parse_args()
+
+
+def make_dataset(image_dir):
+    images = []
+    assert os.path.isdir(image_dir), '%s is not a valid directory' % image_dir
+    for root, _, fnames in sorted(os.walk(image_dir)):
+        for fname in fnames:
+            if fname.endswith(IMG_EXTENSIONS):
+                images.append(os.path.join(root, fname))
+    return images
+
+
+def edge_compute_np(img_chw):
+    x_diffx = np.abs(img_chw[:, :, 1:] - img_chw[:, :, :-1])
+    x_diffy = np.abs(img_chw[:, 1:, :] - img_chw[:, :-1, :])
+
+    edge = np.zeros_like(img_chw, dtype=np.float32)
+    edge[:, :, 1:] += x_diffx
+    edge[:, :, :-1] += x_diffx
+    edge[:, 1:, :] += x_diffy
+    edge[:, :-1, :] += x_diffy
+    edge = np.sum(edge, axis=0, keepdims=True) / 3.0
+    edge = edge / 4.0
+    return edge.astype(np.float32)
+
+
+def preprocess(img_path):
+    img = Image.open(img_path).convert('RGB')
+    img = img.resize((WIDTH, HEIGHT), Image.BICUBIC)
+    img_np = np.array(img).astype(np.float32)
+    img_chw = np.transpose(img_np, (2, 0, 1))
+    edge = edge_compute_np(img_chw)
+    model_input = np.concatenate((img_chw, edge), axis=0)[None, :, :, :] - 128.0
+    return img_chw, model_input.astype(np.float32)
+
+
+def postprocess(pred, img_chw, only_residual):
+    out = pred[0]
+    if only_residual:
+        out = out + img_chw
+    out = np.round(out).clip(0, 255).astype(np.uint8)
+    out = np.transpose(out, (1, 2, 0))
+    return out
+
+
+def main():
+    args = parse_args()
+    onnx_path = args.onnx or os.path.join('onnx', 'gcanet_%s_512x512_sim.onnx' % args.task)
+    only_residual = args.task == 'dehaze'
+    os.makedirs(args.outdir, exist_ok=True)
+
+    session = ort.InferenceSession(onnx_path, providers=['CPUExecutionProvider'])
+    input_name = session.get_inputs()[0].name
+
+    for img_path in make_dataset(args.indir):
+        img_chw, model_input = preprocess(img_path)
+        pred = session.run(None, {input_name: model_input})[0]
+        out_img = postprocess(pred, img_chw, only_residual)
+        save_name = os.path.splitext(os.path.basename(img_path))[0] + '_%s_onnx.png' % args.task
+        Image.fromarray(out_img).save(os.path.join(args.outdir, save_name))
+        print('Saved:', os.path.join(args.outdir, save_name))
+
+
+if __name__ == '__main__':
+    main()

GridDehazeNet/model_convert/GridDehazeNet.json

@@ -0,0 +1,41 @@
+{
+  "input": "./griddehazenet_outdoor_1x3x480x640_npu_safe.onnx",
+  "output_dir": "./GridDehazeNet",
+  "output_name": "GridDehazeNet.axmodel",
+  "model_type": "ONNX",
+  "target_hardware": "AX650",
+  "npu_mode": "NPU3",
+  "quant": {
+    "input_configs": [
+      {
+        "tensor_name": "input",
+        "calibration_dataset": "./RESIDE.tar.gz",
+        "calibration_format": "Image",
+        "calibration_size": 32,
+        "calibration_mean": [127.5, 127.5, 127.5],
+        "calibration_std": [127.5, 127.5, 127.5]
+      }
+    ],
+    "calibration_method": "MinMax",
+    "precision_analysis": true,
+    "transformer_opt_level":1,
+    "precision_analysis_method": "EndToEnd",
+    "precision_analysis_mode": "NPUBackend", 
+    "device": "cuda:1",
+  },
+  "input_processors": [
+    {
+      "tensor_name": "input",
+      "tensor_format": "RGB",
+      "tensor_layout": "NCHW",
+      "src_format": "BGR",
+      "src_dtype": "U8",
+      "src_layout": "NCHW",
+      "csc_mode": "NoCSC"
+    }
+  ],
+  "compiler": {
+    "check": 2
+  }
+}
+

GridDehazeNet/model_convert/axmodel/GridDehazeNet.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:996e7c24541934f003860a9c60af7afddcdb3a4042ae1be31cd8d9f057815b47
+size 4680186

GridDehazeNet/python/axmodel_infer.py

@@ -0,0 +1,81 @@
+"""
+Run GridDehazeNet axmodel inference on a single image.
+Output: side-by-side image (Hazy | Dehazed), result resized to original size.
+"""
+import argparse
+import os
+
+import numpy as np
+import axengine as axe
+from PIL import Image, ImageDraw, ImageFont
+
+
+def _get_font(size):
+    for path in (
+        "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",
+        "/usr/share/fonts/truetype/liberation/LiberationSans-Bold.ttf",
+        "/usr/share/fonts/truetype/freefont/FreeSansBold.ttf",
+    ):
+        if os.path.exists(path):
+            return ImageFont.truetype(path, size)
+    return ImageFont.load_default()
+
+
+def _label_image(image, text, font):
+    draw = ImageDraw.Draw(image)
+    bbox = draw.textbbox((0, 0), text, font=font)
+    w, h = bbox[2] - bbox[0], bbox[3] - bbox[1]
+    pad = 6
+    draw.rectangle([(0, 0), (w + pad * 2, h + pad * 2)], fill=(0, 0, 0, 180))
+    draw.text((pad, pad), text, fill=(255, 255, 255), font=font)
+
+
+def _tensor_to_image(tensor):
+    arr = np.squeeze(tensor, axis=0).transpose(1, 2, 0)
+    arr = np.clip(arr, 0.0, 1.0)
+    return Image.fromarray((arr * 255.0 + 0.5).astype(np.uint8))
+
+
+def main():
+    parser = argparse.ArgumentParser(description="GridDehazeNet axmodel single-image inference")
+    parser.add_argument("-axmodel", default="GridDehazeNet.axmodel")
+    parser.add_argument("-input", default="./0001_0.8_0.2.jpg", help="image file")
+    parser.add_argument("-output", default="axmodel_result.png")
+    parser.add_argument("-height", type=int, default=480)
+    parser.add_argument("-width", type=int, default=640)
+    args = parser.parse_args()
+
+    font = _get_font(24)
+    session = axe.InferenceSession(args.axmodel, providers=["AxEngineExecutionProvider"])
+    input_name = session.get_inputs()[0].name
+    output_name = session.get_outputs()[0].name
+
+    original = Image.open(args.input).convert("RGB")
+    orig_w, orig_h = original.size
+
+    image = Image.open(args.input).convert("RGB")
+    if image.size != (args.width, args.height):
+        image = image.resize((args.width, args.height), Image.BICUBIC)
+    arr = np.asarray(image).astype(np.float32)
+    arr = arr.transpose(2, 0, 1)[None, ...]
+    arr = arr.astype(np.uint8)
+
+    out = session.run([output_name], {input_name: arr})[0]
+    dehazed = _tensor_to_image(out)
+    if dehazed.size != (orig_w, orig_h):
+        dehazed = dehazed.resize((orig_w, orig_h), Image.BICUBIC)
+
+    hazy_labeled = original.copy()
+    dehazed_labeled = dehazed.copy()
+    _label_image(hazy_labeled, "Hazy", font)
+    _label_image(dehazed_labeled, "Dehazed", font)
+
+    concat = Image.new("RGB", (orig_w * 2, orig_h))
+    concat.paste(hazy_labeled, (0, 0))
+    concat.paste(dehazed_labeled, (orig_w, 0))
+    concat.save(args.output)
+    print(args.output)
+
+
+if __name__ == "__main__":
+    main()

GridDehazeNet/python/onnx_infer.py

@@ -0,0 +1,81 @@
+"""
+Run GridDehazeNet ONNX inference on a single image.
+Output: side-by-side image (Hazy | Dehazed), result resized to original size.
+"""
+import argparse
+import os
+
+import numpy as np
+import onnxruntime as ort
+from PIL import Image, ImageDraw, ImageFont
+
+
+def _get_font(size):
+    for path in (
+        "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",
+        "/usr/share/fonts/truetype/liberation/LiberationSans-Bold.ttf",
+        "/usr/share/fonts/truetype/freefont/FreeSansBold.ttf",
+    ):
+        if os.path.exists(path):
+            return ImageFont.truetype(path, size)
+    return ImageFont.load_default()
+
+
+def _label_image(image, text, font):
+    draw = ImageDraw.Draw(image)
+    bbox = draw.textbbox((0, 0), text, font=font)
+    w, h = bbox[2] - bbox[0], bbox[3] - bbox[1]
+    pad = 6
+    draw.rectangle([(0, 0), (w + pad * 2, h + pad * 2)], fill=(0, 0, 0, 180))
+    draw.text((pad, pad), text, fill=(255, 255, 255), font=font)
+
+
+def _tensor_to_image(tensor):
+    arr = np.squeeze(tensor, axis=0).transpose(1, 2, 0)
+    arr = np.clip(arr, 0.0, 1.0)
+    return Image.fromarray((arr * 255.0 + 0.5).astype(np.uint8))
+
+
+def main():
+    parser = argparse.ArgumentParser(description="GridDehazeNet ONNX single-image inference")
+    parser.add_argument("-onnx", default="griddehazenet_outdoor_1x3x480x640_npu_safe.onnx")
+    parser.add_argument("-input", default="data/test/SOTS/outdoor/hazy/0001_0.8_0.2.jpg", help="image file")
+    parser.add_argument("-output", default="onnx_result_concat.png")
+    parser.add_argument("-height", type=int, default=480)
+    parser.add_argument("-width", type=int, default=640)
+    args = parser.parse_args()
+
+    font = _get_font(24)
+    session = ort.InferenceSession(args.onnx, providers=["CUDAExecutionProvider", "CPUExecutionProvider"])
+    input_name = session.get_inputs()[0].name
+    output_name = session.get_outputs()[0].name
+
+    original = Image.open(args.input).convert("RGB")
+    orig_w, orig_h = original.size
+
+    image = Image.open(args.input).convert("RGB")
+    if image.size != (args.width, args.height):
+        image = image.resize((args.width, args.height), Image.BICUBIC)
+    arr = np.asarray(image).astype(np.float32) / 255.0
+    arr = (arr - 0.5) / 0.5
+    arr = arr.transpose(2, 0, 1)[None, ...]
+
+    out = session.run([output_name], {input_name: arr})[0]
+    dehazed = _tensor_to_image(out)
+    if dehazed.size != (orig_w, orig_h):
+        dehazed = dehazed.resize((orig_w, orig_h), Image.BICUBIC)
+
+    hazy_labeled = original.copy()
+    dehazed_labeled = dehazed.copy()
+    _label_image(hazy_labeled, "Hazy", font)
+    _label_image(dehazed_labeled, "Dehazed", font)
+
+    concat = Image.new("RGB", (orig_w * 2, orig_h))
+    concat.paste(hazy_labeled, (0, 0))
+    concat.paste(dehazed_labeled, (orig_w, 0))
+    concat.save(args.output)
+    print(args.output)
+
+
+if __name__ == "__main__":
+    main()