taotoolkit 1.0.0__py3-none-any.whl

taotoolkit/tao_vrfTool.py

@@ -0,0 +1,690 @@
+#!/usr/bin/env python
+# -*- encoding: utf-8 -*-
+"""VRF文件处理工具"""
+
+import os
+import re
+import sys
+import cv2
+import argparse
+import math
+import numpy as np
+from pathlib import Path
+from .asrVrf import Vrf
+
+
+from .tao_common import (
+    debugCtrl,
+    eExit,
+    loge,
+    logi,
+    logd,
+    normalize_args,
+    register_command,
+)
+
+
+def get_file_index(filename):
+    pattern = re.compile(r"req\[(\d+)\]")
+    res = pattern.findall(filename)
+    if len(res) != 1:
+        raise Exception("Cannot get file index!")
+    file_index = int(res[0])
+    return file_index
+
+
+def get_meta_file_by_index(path, file_index):
+    file_list = os.listdir(path)
+    meta_fname = ""
+    for f in file_list:
+        if f.endswith("_%d.txt" % (file_index)):
+            meta_fname = f
+            break
+    meta_fname = path + "\\" + meta_fname
+    return meta_fname
+
+
+def get_meta_file(path):
+    file_list = os.listdir(path)
+    meta_fname = ""
+    for f in file_list:
+        if f.endswith(".xml"):
+            meta_fname = f
+            break
+    meta_fname = path + "\\" + meta_fname
+    return meta_fname
+
+
+def grep_info(tag, meta_txt):
+    pattern_str = "<%s>(.*?)</%s>" % (tag, tag)
+    pattern = re.compile(pattern_str)
+    return float(pattern.findall(meta_txt)[0])
+
+
+def unpack_mipi_raw10(byte_buf):
+    data = np.frombuffer(byte_buf, dtype=np.uint8)
+    # 5 bytes contain 4 10-bit pixels (5x8 == 4x10)
+    b1, b2, b3, b4, b5 = np.reshape(data, (data.shape[0] // 5, 5)).astype(np.uint16).T
+    p1 = (b1 << 2) + ((b5) & 0x3)
+    p2 = (b2 << 2) + ((b5 >> 2) & 0x3)
+    p3 = (b3 << 2) + ((b5 >> 4) & 0x3)
+    p4 = (b4 << 2) + ((b5 >> 6) & 0x3)
+    unpacked = np.reshape(np.concatenate((p1[:, None], p2[:, None], p3[:, None], p4[:, None]), axis=1), 4 * p1.shape[0])
+    return unpacked
+
+
+def unpack_mipi_raw12(byte_buf):
+    data = np.frombuffer(byte_buf, dtype=np.uint8)
+    # 3 bytes contain 2 12-bit pixels (3x8 == 2x12)
+    b1, b2, b3 = np.reshape(data, (data.shape[0] // 3, 3)).astype(np.uint16).T
+    p1 = (b1 << 4) + ((b3) & 0xF)
+    p2 = (b2 << 4) + ((b3 >> 4) & 0xF)
+    unpacked = np.reshape(np.concatenate((p1[:, None], p2[:, None]), axis=1), 2 * p1.shape[0])
+    return unpacked
+
+
+def unpack_mipi_raw14(byte_buf):
+    data = np.frombuffer(byte_buf, dtype=np.uint8)
+    # 7 bytes contain 4 14-bit pixels (7x8 == 4x14)
+    b1, b2, b3, b4, b5, b6, b7 = np.reshape(data, (data.shape[0] // 7, 7)).astype(np.uint16).T
+    p1 = (b1 << 6) + (b5 & 0x3F)
+    p2 = (b2 << 6) + (b5 >> 6) + (b6 & 0xF)
+    p3 = (b3 << 6) + (b6 >> 4) + (b7 & 0x3)
+    p4 = (b4 << 6) + (b7 >> 2)
+    unpacked = np.reshape(np.concatenate((p1[:, None], p2[:, None], p3[:, None], p4[:, None]), axis=1), 4 * p1.shape[0])
+    return unpacked
+
+
+def convertMipi2RawWithStrde(mipiFile, bitDeepth, width, height, stride):
+    mipiData = np.fromfile(mipiFile, dtype="uint8")
+
+    # print(mipiFile," file size:", mipiData.size)
+    mipiData.resize(height, stride)
+    # print(mipiData.shape)
+
+    if bitDeepth == 8 or bitDeepth == 16:
+        print("raw8 and raw16 no need to unpack")
+        return None
+    elif bitDeepth == 10:
+        byte2pixel = 5 / 4  # 5 bytes contain 4 10-bit pixels (5x8 == 4x10)
+        dataWithoutStride = np.ascontiguousarray(mipiData[::, : int(width * byte2pixel) :])
+        bayerData = unpack_mipi_raw10(dataWithoutStride)
+    elif bitDeepth == 12:
+        byte2pixel = 3 / 2  # 3 bytes contain 2 12-bit pixels (3x8 == 2x12)
+        dataWithoutStride = np.ascontiguousarray(mipiData[::, : int(width * byte2pixel) :])
+        bayerData = unpack_mipi_raw12(dataWithoutStride)
+    elif bitDeepth == 14:
+        byte2pixel = 7 / 4  # 7 bytes contain 4 14-bit pixels (7x8 == 4x14)
+        dataWithoutStride = np.ascontiguousarray(mipiData[::, : int(width * byte2pixel) :])
+        bayerData = unpack_mipi_raw14(dataWithoutStride)
+    else:
+        print("unsupport bayer bitDeepth:", bitDeepth)
+        return
+
+    # bayerData.tofile("tmp1920x1080_raw12.raw")
+    return bayerData
+
+
+def convertMipi2Raw(mipiFile, bitDeepth, imgWidth, imgHeight, bayer_order=cv2.COLOR_BayerBG2BGR):
+    mipiData = np.fromfile(mipiFile, dtype="uint8")
+    print("mipiraw file size:", mipiData.size)
+    bayerData = None
+
+    if bitDeepth == 8 or bitDeepth == 16:
+        print("raw8 and raw16 no need to unpack")
+        return None
+    elif bitDeepth == 10:
+        # raw10
+        bayerData = unpack_mipi_raw10(mipiData[: imgWidth * imgHeight * 5 // 4])
+        img = bayerData >> 2
+    elif bitDeepth == 12:
+        # raw12
+        bayerData = unpack_mipi_raw12(mipiData[: imgWidth * imgHeight * 3 // 2])
+        img = bayerData >> 4
+    elif bitDeepth == 14:
+        # raw14
+        bayerData = unpack_mipi_raw14(mipiData[: imgWidth * imgHeight * 7 // 4])
+        img = bayerData >> 6
+    else:
+        print("unsupport bayer bitDeepth:", bitDeepth)
+
+    # bayerData.tofile(mipiFile[:-4]+'_unpack.raw')
+
+    # img = img.astype(np.uint8).reshape(imgHeight, imgWidth, 1)
+    # # print(bayer_order)
+    # rgbimg = cv2.cvtColor(img, bayer_order)
+    # cv2.imwrite(mipiFile[:-4]+'_unpack.jpg', rgbimg)
+
+    return bayerData
+
+
+def judge_exist_xml(path):
+    files = os.listdir(path)
+    for k in range(len(files)):
+        files[k] = os.path.splitext(files[k])[1]
+
+    Str = ".xml"
+
+    if Str in files:
+        return True
+    else:
+        return False
+
+
+"""
+处理单个RAW文件，将其转换为VRF格式
+
+根据输入参数处理RAW图像数据，包括MIPI数据转换、元数据提取和VRF文件生成。
+
+Args:
+    raw_name: RAW文件路径
+    width: 图像宽度
+    height: 图像高度
+    BLC10b: 黑电平校正值（10bit）
+    BayerOrder: Bayer格式顺序
+    BitDepth: 像素位深度
+    stride: MIPI数据步长，默认为0
+    isMipiRaw: 是否为MIPI RAW格式，默认为False
+    dgain: 数字增益值，默认为1
+
+Returns:
+    无返回值，处理结果保存为.vrf文件
+"""
+
+
+def raw2vrf(
+    raw_name, width, height, BLC10b, BayerOrder, BitDepth, stride=0, isMipiRaw=False, dgain=1.0, WBGain=[1.0, 1.0, 1.0]
+):
+
+    path, filename = os.path.split(raw_name)
+
+    exist_xml = False
+
+    vrfObj = Vrf()
+    vrfObj.Width = np.uint16(width)
+    vrfObj.Height = np.uint16(height)
+
+    vrfObj.BLC10b = np.uint8(BLC10b)
+    vrfObj.BayerOrder = np.uint8(BayerOrder)
+    vrfObj.BitDepth = np.uint8(BitDepth)
+
+    if exist_xml:
+        # file_index = get_file_index(filename)
+        # meta_fname = get_meta_file_by_index(path, file_index)
+        meta_fname = get_meta_file(path)
+        f = open(meta_fname, "rt")
+        meta_txt = f.read()
+        f.close()
+
+        dgain = grep_info("digitalGain", meta_txt)
+        vrfObj.AWBGainB = np.uint16(128 * grep_info("gain_b", meta_txt))
+        vrfObj.AWBGainG = np.uint16(128 * grep_info("gain_g", meta_txt))
+        vrfObj.AWBGainR = np.uint16(128 * grep_info("gain_r", meta_txt))
+
+        vrfObj.AGain = np.uint16(16 * grep_info("shortGain", meta_txt))
+        vrfObj.TGain = np.uint16(vrfObj.AGain * dgain)
+        vrfObj.DrcGainDark = np.uint8(16 * grep_info("DrcGainDark", meta_txt))
+        vrfObj.DrcGain = np.uint8(16 * grep_info("DrcGain", meta_txt))
+        vrfObj.ExpoTime_us = np.uint32((grep_info("Short", meta_txt) / 1000))
+
+    else:
+        vrfObj.AWBGainB = np.uint16(128 * WBGain[2])
+        vrfObj.AWBGainG = np.uint16(128 * WBGain[1])
+        vrfObj.AWBGainR = np.uint16(128 * WBGain[0])
+
+        vrfObj.AGain = np.uint16(16)
+        vrfObj.TGain = np.uint16(vrfObj.AGain * dgain)
+        vrfObj.DrcGainDark = np.uint8(16)
+        vrfObj.DrcGain = np.uint8(16)
+
+        vrfObj.ExpoTime_us = np.uint32(65536)
+
+    vrfObj.PrintVrf()
+    if isMipiRaw:
+        if stride != 0:
+            bayerData = convertMipi2RawWithStrde(raw_name, vrfObj.BitDepth, width, height, stride)
+        else:
+            bayerData = convertMipi2Raw(raw_name, vrfObj.BitDepth, width, height)
+    else:
+        if BitDepth == 8:
+            bayerData = np.fromfile(raw_name, dtype="uint8")
+        else:
+            bayerData = np.fromfile(raw_name, dtype="uint16")
+
+    if bayerData != None:
+        vrfObj.unpackImage = bayerData.astype(np.uint16)
+    else:
+        eExit("get bayer data failed")
+
+    vrfName = os.path.join(path, os.path.splitext(filename)[0] + ".vrf")
+    vrfObj.SaveVrf(vrfName)
+    print(f"save {vrfName} successful")
+
+
+def scaner_file(url):
+    file = os.listdir(url)
+    for f in file:
+        real_url = os.path.join(url, f)
+        if os.path.isfile(real_url):
+            print(os.path.abspath(real_url))
+        elif os.path.isdir(real_url):
+            scaner_file(real_url)
+        else:
+            print("other")
+            pass
+        print(real_url)
+
+
+def raw2vrfBatch(
+    path,
+    width,
+    height,
+    BLC10b,
+    BayerOrder,
+    BitDepth,
+    stride,
+    isMipiRaw=False,
+    dgain=1.0,
+    WBGain=[1.0, 1.0, 1.0],
+    suffix="raw",
+):
+    file_list = os.listdir(path)
+    for f in file_list:
+        f_lower = f.lower()
+        if (
+            f_lower.endswith(".rawmipi")
+            or f_lower.endswith(".rawmipi10")
+            or f_lower.endswith(".raw")
+            or f_lower.endswith(".mipiraw")
+            or f_lower.endswith(f".{suffix}")
+        ):
+            raw_name = os.path.join(path, f)
+            raw2vrf(raw_name, width, height, BLC10b, BayerOrder, BitDepth, stride, isMipiRaw, dgain, WBGain)
+
+
+def srgb_to_linear(c_srgb_8bit):
+    """
+    sRGB (0-255, gamma编码) -> 线性光强度 (0-1)
+    标准 sRGB EOTF (IEC 61966-2-1)
+    """
+    c = np.asarray(c_srgb_8bit, dtype=np.float64) / 255.0
+    linear = np.where(c <= 0.04045, c / 12.92, ((c + 0.055) / 1.055) ** 2.4)
+    return linear
+
+
+def map_colorchecker_to_bitdepth(raw_color_values_8bit, dataMin, dataMax, out_dtype=np.uint16):
+    """
+    把 sRGB 8bit 色卡值动态映射到任意 bitDepth 对应的 RAW 数据范围
+
+    Args:
+        raw_color_values_8bit: (24, 3) 的 sRGB 8bit 色值列表
+        dataMin: 目标 bit depth 下的最小值 (通常是黑电平)
+        dataMax: 目标 bit depth 下的最大值 (通常是 2^bitDepth - 1)
+        out_dtype: 输出数据类型
+
+    Returns:
+        (24, 3) 的 ndarray，值域映射到 [dataMin, dataMax]
+    """
+    linear_values = srgb_to_linear(raw_color_values_8bit)  # [0,1]
+    mapped = linear_values * (dataMax - dataMin) + dataMin
+    return mapped.astype(out_dtype)
+
+
+def get_bayer_pattern(bayer_order):
+    """返回 2x2 pattern，索引方式 pattern[row_phase][col_phase] -> 'R'/'G'/'B'"""
+    patterns = {
+        3: [["R", "G"], ["G", "B"]],  # RGGB
+        0: [["B", "G"], ["G", "R"]],  # BGGR
+        1: [["G", "B"], ["R", "G"]],  # GBRG
+        2: [["G", "R"], ["B", "G"]],  # GRBG
+    }
+    return patterns.get(bayer_order, patterns[3])  # 默认 RGGB
+
+
+def fill_bayer_region(arr, y_start, y_end, x_start, x_end, r, g, b, pattern):
+    """
+    按 Bayer CFA 相位，把 arr 的 [y_start:y_end, x_start:x_end] 区域
+    填充为给定的 r/g/b 值。相位由区域在全图中的绝对起始坐标决定。
+    """
+    h = y_end - y_start
+    w = x_end - x_start
+    if h <= 0 or w <= 0:
+        return
+    region = np.zeros((h, w), dtype=arr.dtype)
+    color_map = {"R": r, "G": g, "B": b}
+    for dy in range(2):
+        for dx in range(2):
+            row_phase = (y_start + dy) % 2
+            col_phase = (x_start + dx) % 2
+            region[dy::2, dx::2] = color_map[pattern[row_phase][col_phase]]
+    arr[y_start:y_end, x_start:x_end] = region
+
+
+def generateVrf(outPath, width, height, bitDepth=10):
+    """
+    生成带中心标准 24 色卡的随机噪声 VRF 文件
+
+    Args:
+        outPath: 输出路径
+        width: 图像宽度
+        height: 图像高度
+        bitDepth: 位深 (默认 10)
+    """
+    if not os.path.exists(outPath):
+        os.makedirs(outPath)
+
+    vrfObj = Vrf()
+    vrfObj.BitDepth = np.uint8(bitDepth)
+    vrfObj.Width = np.uint16(width)
+    vrfObj.Height = np.uint16(height)
+    vrfObj.BLC10b = np.uint8(0)
+
+    dataMax = int(math.pow(2, bitDepth)) - 1
+    dataMin = int(vrfObj.BLC10b * (vrfObj.BitDepth - 9))
+
+    logi(f"bitDepth:{bitDepth} wxh: {width,height}  dataRange: {dataMin,dataMax}")
+
+    # 生成完整随机噪声
+    random_noise = np.random.randint(dataMin, dataMax, (height, width), dtype=np.uint16)
+
+    # ========== 标准 24 色卡 (sRGB, 8-bit) ==========
+    # 24 个色块，按行排列 (4 行 x 6 列)
+    color_checker_rows = 4
+    color_checker_cols = 6
+    # ========== 标准 24 色卡 (sRGB, 8-bit, gamma编码) ==========
+    raw_color_values_8bit = [
+        [115, 82, 68],  # 暗肤色
+        [194, 150, 130],  # 亮肤色
+        [98, 122, 157],  # 蓝天
+        [87, 108, 67],  # 叶片绿
+        [133, 128, 177],  # 蓝花
+        [103, 189, 170],  # 蓝绿
+        [214, 126, 44],  # 橙色
+        [80, 91, 166],  # 紫蓝花
+        [193, 90, 99],  # moderate red
+        [94, 60, 108],  # 紫色
+        [157, 188, 64],  # 黄绿
+        [224, 163, 46],  # 橙黄
+        [56, 61, 150],  # 蓝
+        [70, 148, 73],  # 绿
+        [175, 54, 60],  # 红
+        [231, 199, 31],  # 黄
+        [187, 86, 149],  # 品红
+        [8, 133, 161],  # 青
+        [243, 243, 242],  # 白
+        [200, 200, 200],  # 浅灰 1
+        [160, 160, 160],  # 浅灰 2
+        [122, 122, 121],  # 浅灰 3
+        [85, 85, 85],  # 浅灰 4
+        [52, 52, 52],  # 黑
+    ]
+
+    # 映射到 sensor RAW 的实际数据范围 [dataMin, dataMax]
+    raw_color_values = map_colorchecker_to_bitdepth(raw_color_values_8bit, dataMin, dataMax)
+
+    # ========== 计算中心区域 ==========
+    left = (width // 3) // 2 * 2
+    top = (height // 3) // 2 * 2
+    right = width - left
+    bottom = height - top
+
+    cell_w = ((right - left) // color_checker_cols) // 2 * 2
+    cell_h = ((bottom - top) // color_checker_rows) // 2 * 2
+
+    logd(f"色卡区域: left={left}, right={right}, top={top}, bottom={bottom}")
+    logd(f"每个色块大小: {cell_w} x {cell_h}")
+
+    border_px = 2
+    black_level = dataMin  # 用 sensor 黑电平作为"纯黑"边框值
+    # ========== 绘制 24 色卡 ==========
+    for row in range(color_checker_rows):
+        for col in range(color_checker_cols):
+            y_start = top + row * cell_h
+            y_end = top + (row + 1) * cell_h
+            x_start = left + col * cell_w
+            x_end = left + (col + 1) * cell_w
+
+            idx = row * color_checker_cols + col
+            r, g, b = raw_color_values[idx]
+
+            pattern = get_bayer_pattern(vrfObj.BayerOrder)
+
+            # 1) 先把整个格子填成黑色边框底色
+            fill_bayer_region(
+                random_noise, y_start, y_end, x_start, x_end, black_level, black_level, black_level, pattern
+            )
+
+            # 2) 再在内缩 border_px 后的区域填实际色块颜色
+            inner_y_start = y_start + border_px
+            inner_y_end = y_end - border_px
+            inner_x_start = x_start + border_px
+            inner_x_end = x_end - border_px
+
+            if inner_y_end > inner_y_start and inner_x_end > inner_x_start:
+                fill_bayer_region(
+                    random_noise, inner_y_start, inner_y_end, inner_x_start, inner_x_end, r, g, b, pattern
+                )
+            else:
+                logi(f"警告: 色块 idx={idx} 尺寸太小,border_px={border_px} 后无法容纳色块内容，已跳过内部填充")
+
+    vrfObj.unpackImage = random_noise
+    vrfName = os.path.join(outPath, f"random_noise{bitDepth}.vrf")
+    vrfObj.SaveVrf(vrfName)
+    logi(f"VRF 文件已生成: {vrfName}")
+
+    # return vrfObj
+
+
+def generateRandomVrf(outPath, width, height, bitDepth=10):
+    if not os.path.exists(outPath):
+        os.makedirs(outPath)
+
+    vrfObj = Vrf()
+    vrfObj.BitDepth = np.uint8(bitDepth)
+    vrfObj.Width = np.uint16(width)
+    vrfObj.Height = np.uint16(height)
+
+    dataMax = int(math.pow(2, bitDepth)) - 1
+    dataMin = int(vrfObj.BLC10b * (vrfObj.BitDepth - 9))
+    # 生成10位随机噪声数据（0-1023）
+    logi(f"bitDepth:{bitDepth} wxh: {width,height}  dataRange: {dataMin,dataMax}")
+    random_noise = np.random.randint(dataMin, dataMax, (height, width), dtype=np.uint16)  # 10位数据范围是0-1023
+
+    vrfObj.unpackImage = random_noise
+
+    vrfName = os.path.join(outPath, f"random_noise{bitDepth}.vrf")
+    vrfObj.SaveVrf(vrfName)
+
+
+def makeNoiseToVrf(vrfFile: str, noiseLevel: float):
+    path = Path(vrfFile)
+    if not path.is_file():
+        raise FileNotFoundError(f"{vrfFile} 不是一个有效的文件")
+
+    outPath, _, nameWithoutSuffix, _ = path.parent, path.name, path.stem, path.suffix
+
+    vrfObj = Vrf()
+    vrfObj.Read(vrfFile)
+    bitDepth = vrfObj.BitDepth
+
+    dataMax = int(math.pow(2, bitDepth)) - 1
+    dataMin = vrfObj.BLC10b * (vrfObj.BitDepth - 9)
+
+    # 生成随机噪声, 噪声范围可以根据需要调整
+    noiseMax = int(noiseLevel * dataMax)
+    noiseMin = -noiseMax
+    print(f"bitDepth:{bitDepth}   noiseRange: {noiseMin,noiseMax}")
+    random_noise = np.random.randint(noiseMin, noiseMax, (vrfObj.Height, vrfObj.Width), dtype=np.int16)
+
+    # 将噪声添加到原始数据中
+    noisy_data = vrfObj.unpackImage + random_noise
+
+    # 确保数据在bitDepth位范围内
+    print(f"dataMin: {dataMin}")
+    noisy_data = np.clip(noisy_data, dataMin, dataMax).astype(np.uint16)
+
+    vrfObj.unpackImage = noisy_data
+
+    vrfName = os.path.join(outPath, nameWithoutSuffix + f"_random_noise_{noiseLevel}.vrf")
+    vrfObj.SaveVrf(vrfName)
+
+
+def CLI_raw2vrf(argsList):
+    parser = argparse.ArgumentParser(prog="raw2vrf", description="mipiraw/raw文件转换成vrf文件")
+    parser.add_argument(
+        "-p",
+        "--path",
+        type=str,
+        required=True,
+        default="",
+        help="RAW文件路径或文件名,如果是路径则会处理该路径下的所有raw/mipiraw文件",
+    )
+    parser.add_argument(
+        "-f", "--format", type=str, required=True, choices=["raw", "mipiraw"], help="raw格式,可选值: raw, mipiraw"
+    )
+    parser.add_argument("--width", type=int, required=True, help="图像宽度")
+    parser.add_argument("--height", type=int, required=True, help="图像高度")
+    parser.add_argument("-d", "--depth", type=int, required=True, choices=[8, 10, 12, 14, 16], help="像素位深度")
+    parser.add_argument("-g", "--gain", type=float, default=1, help="数字增益值,float类型")
+    parser.add_argument("-s", "--stride", type=int, default=0, help="raw stride,默认为0表示无stride")
+    parser.add_argument("-o", "--ob10b", type=int, default=0, help="黑电平校正值(10bit)")
+    parser.add_argument(
+        "-b",
+        "--bayerorder",
+        type=int,
+        default=0,
+        choices=[0, 1, 2, 3],
+        help="Bayer格式顺序,0:BGGR, 1:GBRG, 2:GRBG, 3:RGGB",
+    )
+    parser.add_argument("--wbgain", type=float, default=[1.0, 1.0, 1.0], help="wb gain,float类型, 顺序为R G B", nargs=3)
+    parser.add_argument(
+        "--suffix",
+        type=str,
+        required=False,
+        default="raw",
+        help="文件后缀,默认为raw/rawmipi/mipiraw,如果是路径则会处理该路径下的所有指定后缀的文件",
+    )
+
+    args = parser.parse_args(argsList)
+
+    path = args.path
+    isMipiRaw = True if args.format == "mipiraw" else False
+    width = int(args.width)
+    height = int(args.height)
+    dgain = float(args.gain)
+    stride = int(args.stride)
+    BLC10b = np.uint16(int(args.ob10b))
+    BayerOrder = np.uint16(int(args.bayerorder))
+    BitDepth = np.uint16(int(args.depth))
+    WBGain = [float(gain) for gain in args.wbgain]
+    suffix = args.suffix
+
+    if os.path.isdir(path):
+        raw2vrfBatch(path, width, height, BLC10b, BayerOrder, BitDepth, stride, isMipiRaw, dgain, WBGain, suffix)
+    else:
+        raw2vrf(path, width, height, BLC10b, BayerOrder, BitDepth, stride, isMipiRaw, dgain, WBGain)
+
+
+def rotVrf(input, output, mode):
+    vrfObj = Vrf()
+    vrfObj.Read(input)
+    vrfObj.rot(mode)
+    vrfObj.SaveVrf(output)
+
+
+def rotVrfBatch(path, mode, tag):
+    file_list = os.listdir(path)
+    for f in file_list:
+        f_lower = f.lower()
+        if f_lower.endswith(".vrf") and f.find(tag) == -1:
+            input = os.path.join(path, f)
+            output = os.path.join(path, os.path.splitext(f)[0] + f"{tag}.vrf")
+            rotVrf(input, output, mode)
+
+
+def CLI_rotVrf(argsList):
+    parser = argparse.ArgumentParser(prog="rotVrf", description="vrf旋转")
+    parser.add_argument(
+        "-p", "--path", type=str, required=True, default="", help="RAW文件路径或文件名,路径则处理所有raw/mipiraw文件"
+    )
+    parser.add_argument("-o", "--orientation", type=str, required=True, choices=["mirror", "flip", "mirror_flip"])
+    parser.add_argument("-s", "--suffix", type=str, required=False, default="_rot", help="输出文件添加后缀")
+    args = parser.parse_args(argsList)
+
+    if os.path.isdir(args.path):
+        rotVrfBatch(args.path, args.orientation, args.suffix)
+    else:
+        rotVrf(args.path, os.path.splitext(args.path)[0] + f"{args.suffix}.vrf", args.orientation)
+
+
+def CLI_generateVrf(argsList):
+    parser = argparse.ArgumentParser(prog="generateVrf", description="生成VRF")
+    parser.add_argument("-p", "--path", type=str, required=True, default="", help="输出VRF路径")
+    parser.add_argument("--width", type=int, required=True, help="vrf宽度")
+    parser.add_argument("--height", type=int, required=True, help="vrf高度")
+    parser.add_argument("-d", "--depth", type=int, required=True, choices=[8, 10, 12, 14, 16], help="像素位深度")
+    args = parser.parse_args(argsList)
+
+    generateVrf(args.path, args.width, args.height, args.depth)
+
+
+def float_range(min_val: float, max_val: float):
+    def _check(value):
+        try:
+            f = float(value)
+        except ValueError:
+            raise argparse.ArgumentTypeError(f"无效的浮点数: {value}")
+        if f < min_val or f > max_val:
+            raise argparse.ArgumentTypeError(f"值必须在 {min_val} 到 {max_val} 之间")
+        return f
+
+    return _check
+
+
+def CLI_addNoise2Vrf(argsList):
+    parser = argparse.ArgumentParser(prog="addNoise2Vrf", description="在VRF中添加随机噪声")
+    parser.add_argument(
+        "-p", "--path", type=str, required=True, default="", help="RAW文件路径或文件名,路径则处理所有raw/mipiraw文件"
+    )
+    parser.add_argument("-l", "--level", type=float_range(0.0, 1.0), required=True, help="噪声等级,范围0-1.0")
+    args = parser.parse_args(argsList)
+
+    makeNoiseToVrf(args.path, args.level)
+
+
+_COMMAND_REGISTRY = {}
+
+
+def printHelp():
+    print("[vrfProcess]")
+    print("raw2vrf -h   : raw/mipiraw to vrf")
+    print("rotVrf -h    : 旋转 vrf")
+    print("gvrf -h      : 生成随机噪声 vrf")
+    print("avrf -h      : 增加随机噪声到 vrf")
+
+
+CLI_raw2vrf = register_command("raw2vrf", registry=_COMMAND_REGISTRY)(CLI_raw2vrf)
+CLI_rotVrf = register_command("rotvrf", registry=_COMMAND_REGISTRY)(CLI_rotVrf)
+CLI_generateVrf = register_command("gvrf", registry=_COMMAND_REGISTRY)(CLI_generateVrf)
+CLI_addNoise2Vrf = register_command("avrf", registry=_COMMAND_REGISTRY)(CLI_addNoise2Vrf)
+
+
+def vrfToolMain(args):
+    debugCtrl(1) if "debug" in args else debugCtrl(0)
+    args.remove("debug") if "debug" in args else args
+    args = normalize_args(args)
+    if len(args) < 1 or args[0] in {"help", "-h", "--help"}:
+        printHelp()
+        return
+    cmd = args[0]
+    handler = _COMMAND_REGISTRY.get(cmd)
+    if handler is None:
+        loge(f"unsupport command {cmd}")
+        return
+    handler(args[1:])
+
+
+if __name__ == "__main__":
+    debugCtrl(1) if "debug" in sys.argv else debugCtrl(0)
+    sys.argv.remove("debug") if "debug" in sys.argv else sys.argv
+    vrfToolMain(sys.argv)