taotoolkit 1.0.0__py3-none-any.whl

taotoolkit/tao_camDvt.py

@@ -0,0 +1,1186 @@
+# -*- coding: utf-8 -*-
+# @Time : 2024/1/4
+# @Author : taotaoli
+# @File : camDvt.py
+
+import os
+import sys
+import argparse
+import time
+import re
+from . import asrVrf
+import math
+import numpy as np
+from matplotlib import pyplot as plt
+
+from .tao_common import (
+    debugCtrl,
+    pCmd,
+    is_number,
+    loge,
+    logi,
+    renameFile,
+    normalize_args,
+    register_command,
+)
+
+from .tao_tuning import (
+    asrCamOp,
+)
+
+plt.set_loglevel("INFO")
+
+
+def removeFile(fullName):
+    if os.path.exists(fullName):
+        os.remove(fullName)
+
+
+def is_increasing(lst: list):
+    return all(x <= y for x, y in zip(lst, lst[1:]))
+
+
+class CamDvt(asrCamOp):
+    """
+    camera Dvt Test
+    """
+
+    def __init__(self, folder=""):
+        super(CamDvt, self).__init__()
+        self.packageName = "com.asrmicro.camera"
+        self.fileAF = "af.log"
+        self.fileGainLuma = "gainLuma.log"
+        self.fileExpLuma = "expLuma.log"
+        self.fileGainBlc = "gainBlc.log"
+        self.fileExpBlc = "expBlc.log"
+        self.pointAE = 100
+        self.pointAF = 100
+        self.pointBLC = 8
+        self.outPath = self.createOutFolder(folder) if folder else os.path.join(os.getcwd(), "dvtResult")
+        self.aeChl = self.checkAeChannel()
+
+    def checkAeChannel(self):
+        cmd = f"{self.tuning_assistant} 127.0.0.1 t 3000 3000 3000 r m0_g0 CAECFilter m_pLumaRLong 5 7"
+        try:
+            out, _ = pCmd(cmd)
+            cmdResult = re.split("[ \n,]+", out)[2]
+
+            if is_number(cmdResult):
+                return 3
+            else:
+                return 1
+        except Exception as e:
+            loge(str(e))
+            return 1
+
+    def createOutFolder(self, folderName="result"):
+        """
+        :以时间戳创建输出目录
+        """
+
+        cmd = f"{self.tuning_assistant} 127.0.0.1 t 3000 3000 3000 gv"
+        out, _ = pCmd(cmd)
+        if "successfully" in out:
+            timestamp = time.strftime("%Y%m%d_%H%M%S", time.localtime())
+            outPath = os.path.join(os.getcwd(), folderName + timestamp)
+            print("*" * 10, "output is ", outPath)
+            os.makedirs(outPath)
+            return outPath
+        else:
+            loge(f"{self.tuning_assistant} 127.0.0.1 t 3000 3000 3000 gv ,error ,please check it !")
+            sys.exit()
+
+    def __blcSetZero(self, maunalEnable: bool):
+        self.writeIsp("CDigitalGainFirmwareFilter", "m_bManualMode", 0, 0, maunalEnable)
+        for i in range(4):
+            self.writeIsp("CDigitalGainFirmwareFilter", "m_pGlobalBlackValueManual", 0, i, 0)
+
+    def __filterEnable(
+        self,
+        aeEnable: int,
+        afEnable: int,
+        awbEnable: int,
+        lscEnable: int,
+        bpcEnable: int,
+        rawDenoiseEnable: int,
+    ):
+        aeMode = 2 if aeEnable == 1 else 0
+        self.writeIsp("CAECFilter", "m_bManualAEEnable", 0, 0, aeMode)
+
+        self.writeIsp("CWbFirmwareFilter", "m_bEnable", 0, 0, awbEnable)
+        self.writeIsp("CAFMFirmwareFilter", "m_bEnable", 0, 0, afEnable)
+        self.writeIsp("CLSCFirmwareFilter", "m_bEnable", 0, 0, lscEnable)
+        self.writeIsp("CBPCFirmwareFilter", "m_bEnable", 0, 0, bpcEnable)
+        self.writeIsp("CRawDenoiseFirmwareFilter", "m_bEnable", 0, 0, rawDenoiseEnable)
+
+    # debug API
+    def manulaGainTest(self):
+        step = 8
+        gainMin = 1500
+        gainMax = 1700
+
+        self.writeIsp("CAECFilter", "m_bManualAEEnable", 0, 0, 1)
+        ExpTimeManual = 10000
+        self.writeIsp("CAECFilter", "m_pExpTimeManual", 0, 0, ExpTimeManual)
+
+        self.__filterEnable(1, 0, 0, 0, 0, 0)
+        cur = 1
+        total = (gainMax - gainMin) // step + 1
+        for i in range(gainMin, gainMax + 1, step):
+            self.writeIsp("CAECFilter", "m_pTotalGainManual", 0, 0, i)
+            time.sleep(0.1)
+            luma = self.readIsp("CAECFilter", "m_pLumaMatrixLong", 5, 7, True)
+            info = "m_pExpTimeManual(us) = %d m_pTotalGainManual(Q8) = %d luma = %f %d/%d" % (
+                ExpTimeManual,
+                i,
+                luma,
+                cur,
+                total,
+            )
+            cur += 1
+            logi(info)
+            time.sleep(0.1)
+        self.__filterEnable(1, 1, 1, 1, 1, 1)
+
+    # debug API
+    def manualExpTest(self):
+        step = 100
+        expMin = 58550
+        expMax = 63050
+
+        self.writeIsp("CAECFilter", "m_bManualAEEnable", 0, 0, 1)
+        gainManual = 512
+        self.writeIsp("CAECFilter", "m_pTotalGainManual", 0, 0, gainManual)
+        self.__filterEnable(1, 0, 0, 0, 0, 0)
+        cur = 1
+        total = (expMax - expMin) // step + 1
+        for i in range(expMin, expMax + 1, step):
+            self.writeIsp("CAECFilter", "m_pExpTimeManual", 0, 0, i)
+            time.sleep(0.1)
+            luma = self.readIsp("CAECFilter", "m_pLumaMatrixLong", 5, 7, True)
+
+            logi(f"m_pExpTimeManual(us) = {i} m_pTotalGainManual(Q8) = {gainManual} luma = {luma}  {cur}/{total}")
+            cur += 1
+            # time.sleep(0.1)
+        self.__filterEnable(1, 1, 1, 1, 1, 1)
+
+    def __getLumaWithGain(self, gain: int):
+        self.writeIsp("CAECFilter", "m_pTotalGainManual", 0, 0, gain)
+        time.sleep(0.6)
+        if self.aeChl == 3:
+            r = self.readIsp("CAECFilter", "m_pLumaRLong", 5, 7, True)
+            g = self.readIsp("CAECFilter", "m_pLumaGLong", 5, 7, True)
+            b = self.readIsp("CAECFilter", "m_pLumaBLong", 5, 7, True)
+            return [r, g, b]
+        elif self.aeChl == 1:
+            y = self.readIsp("CAECFilter", "m_pLumaMatrixLong", 5, 7, True)
+            return [y]
+        else:
+            return [0.0, 0.0, 0.0]
+
+    def __getLumaWithExp(self, exp: int):
+        self.writeIsp("CAECFilter", "m_pExpTimeManual", 0, 0, exp)
+        time.sleep(0.6)
+        if self.aeChl == 3:
+            r = self.readIsp("CAECFilter", "m_pLumaRLong", 5, 7, True)
+            g = self.readIsp("CAECFilter", "m_pLumaGLong", 5, 7, True)
+            b = self.readIsp("CAECFilter", "m_pLumaBLong", 5, 7, True)
+            return [r, g, b]
+        elif self.aeChl == 1:
+            y = self.readIsp("CAECFilter", "m_pLumaMatrixLong", 5, 7, True)
+            return [y]
+        else:
+            return [0.0, 0.0, 0.0]
+
+    def getVrfMean(self, outPath: str, inVRF: str, fullImg: bool):
+        """
+        :param raw: raw图->(H, W)
+        :return: 12bit meanR,meanGr,meanGb,meanB
+        """
+
+        if not os.path.exists(outPath):
+            os.makedirs(outPath)
+        self.dumpVrf(outPath, inVRF)
+        inVrf = os.path.join(outPath, inVRF)
+        outVrf = os.path.join(outPath, os.path.splitext(inVRF)[0] + "_unpack.vrf")
+        # asr devices output is packed vrf
+        cmd = "imageConvert.exe -i %s -o %s -in_format VRF -out_format VRF" % (
+            inVrf,
+            outVrf,
+        )
+        pCmd(cmd)
+        removeFile(inVrf)
+        vrfObj = asrVrf.Vrf()
+        vrfObj.Read(outVrf)
+        raw = vrfObj.unpackImage.astype(np.uint16)
+        raw = raw.reshape(vrfObj.Height, vrfObj.Width)
+
+        R = Gr = Gb = B = np.zeros((vrfObj.Height, vrfObj.Width), dtype=np.uint16)
+        # 0:BGGR, 1:GBRG, 2:GRBG, 3:RGGB
+        if vrfObj.BayerOrder == 3:
+            R = raw[0::2, 0::2]  # [0,0]
+            Gr = raw[0::2, 1::2]  # [0,1]
+            Gb = raw[1::2, 0::2]  # [1,0]
+            B = raw[1::2, 1::2]  # [1,1]
+        elif vrfObj.BayerOrder == 2:
+            Gr = raw[0::2, 0::2]
+            R = raw[0::2, 1::2]
+            B = raw[1::2, 0::2]
+            Gb = raw[1::2, 1::2]
+        elif vrfObj.BayerOrder == 1:
+            Gb = raw[0::2, 0::2]
+            B = raw[0::2, 1::2]
+            R = raw[1::2, 0::2]
+            Gr = raw[1::2, 1::2]
+        elif vrfObj.BayerOrder == 0:
+            B = raw[0::2, 0::2]
+            Gb = raw[0::2, 1::2]
+            Gr = raw[1::2, 0::2]
+            R = raw[1::2, 1::2]
+
+        if fullImg:
+            meanR = np.mean(R)
+            meanGr = np.mean(Gr)
+            meanGb = np.mean(Gb)
+            meanB = np.mean(B)
+        else:
+            # 计算中心1/9区域的坐标四个通道的10bit均值
+            left = vrfObj.Width // 3
+            top = vrfObj.Height // 3
+            right = vrfObj.Width - left
+            bottom = vrfObj.Height - top
+
+            # print(left,top,right,bottom)
+            meanR = np.mean(R[top:bottom, left:right])
+            meanGr = np.mean(Gr[top:bottom, left:right])
+            meanGb = np.mean(Gb[top:bottom, left:right])
+            meanB = np.mean(B[top:bottom, left:right])
+
+        needSave = False
+        if needSave:
+            tmpstr = str(vrfObj.Width // 2) + "x" + str(vrfObj.Height // 2) + ".raw"
+            R.tofile(os.path.join(outPath, "ch1_" + tmpstr))
+            Gr.tofile(os.path.join(outPath, "ch2_" + tmpstr))
+            Gb.tofile(os.path.join(outPath, "ch3_" + tmpstr))
+            B.tofile(os.path.join(outPath, "ch4_" + tmpstr))
+
+            out1 = np.stack((R, Gr), axis=1)  # 横向堆叠
+            out2 = np.stack((Gb, B), axis=1)
+            out = np.stack((out1, out2), axis=0)  # 纵向堆叠
+            out.tofile(os.path.join(outPath, "out_" + str(vrfObj.Width) + "x" + str(vrfObj.Height) + ".raw"))
+
+        dgain = vrfObj.TGain / vrfObj.AGain
+        # print(meanR,meanGr,meanGb,meanB)
+        return (
+            round(meanR * dgain * 4, 3),
+            round(meanGr * dgain * 4, 3),
+            round(meanGb * dgain * 4, 3),
+            round(meanB * dgain * 4, 3),
+        )
+
+    def __getGainLumaWithVrf(self, gain: int, exp: int):
+        self.writeIsp("CAECFilter", "m_pTotalGainManual", 0, 0, gain)
+        # self.writeIsp("CAECFilter", "m_pExpTimeManual", 0, 0, exp)
+        time.sleep(0.2)
+        vrfName = "gain" + str(gain) + "_exp" + str(exp) + ".vrf"
+        return self.getVrfMean(self.outPath, vrfName, True)
+
+    def __getExpLumaWithVrf(self, gain: int, exp: int):
+        # self.writeIsp("CAECFilter", "m_pTotalGainManual", 0, 0, gain)
+        self.writeIsp("CAECFilter", "m_pExpTimeManual", 0, 0, exp)
+        time.sleep(0.2)
+        vrfName = "gain" + str(gain) + "_exp" + str(exp) + ".vrf"
+        return self.getVrfMean(self.outPath, vrfName, True)
+
+    def __getManual(self, min: int, max: int, flag: str) -> int:
+        """手动二分查找目标值"""
+        if min == max - 1:  # 避免死循环
+            return int(min)
+
+        mid = min + (max - min) // 2
+
+        if flag == "gain":
+            if self.aeChl == 3:
+                lumaMin, lumaMid, lumaMax = (
+                    self.__getLumaWithGain(min)[1],
+                    self.__getLumaWithGain(mid)[1],
+                    self.__getLumaWithGain(max)[1],
+                )
+            else:
+                lumaMin, lumaMid, lumaMax = (
+                    self.__getLumaWithGain(min)[0],
+                    self.__getLumaWithGain(mid)[0],
+                    self.__getLumaWithGain(max)[0],
+                )
+        elif flag == "exp":
+            if self.aeChl == 3:
+                lumaMin, lumaMid, lumaMax = (
+                    self.__getLumaWithExp(min)[1],
+                    self.__getLumaWithExp(mid)[1],
+                    self.__getLumaWithExp(max)[1],
+                )
+            else:
+                lumaMin, lumaMid, lumaMax = (
+                    self.__getLumaWithExp(min)[0],
+                    self.__getLumaWithExp(mid)[0],
+                    self.__getLumaWithExp(max)[0],
+                )
+        else:
+            return int(min)
+
+        lumaThr = 220.0  # G channel 过早饱和，导致统计亮度不线性，将门限设低
+        if lumaMin is None or lumaMid is None or lumaMax is None:
+            exit(f"{flag} manual search error")
+
+        if lumaMin >= lumaThr:
+            return int(min)
+        elif lumaMax >= lumaThr:
+            if lumaMid >= lumaThr:
+                return int(self.__getManual(min, mid, flag))
+            return int(self.__getManual(mid, max, flag))
+        return int(max)
+
+    def __getExpTimeManual(self, gainMin, gainMax, expMin, expMax):
+        self.writeIsp("CAECFilter", "m_bManualAEEnable", 0, 0, 1)
+
+        self.writeIsp("CAECFilter", "m_pTotalGainManual", 0, 0, gainMax)
+        print("__getExpTimeManual... gain[%d,%d] exp[%d,%d]" % (gainMin, gainMax, expMin, expMax))
+        ExpTimeManual = self.__getManual(expMin, expMax, "exp")
+        if expMin == ExpTimeManual:
+            print("warning ,environment lux may too high")
+        elif expMax == ExpTimeManual:
+            print("warning ,environment lux may too low")
+
+        return int(ExpTimeManual)
+
+    def __getGainManual(self, gainMin, gainMax, expMin, expMax):
+        self.writeIsp("CAECFilter", "m_bManualAEEnable", 0, 0, 1)
+
+        self.writeIsp("CAECFilter", "m_pExpTimeManual", 0, 0, expMax)
+        print("__getGainManual... gain[%d,%d] exp[%d,%d]" % (gainMin, gainMax, expMin, expMax))
+        # 动态设置增益，使得最大曝光时，统计亮度尽量不饱和
+        gainManual = self.__getManual(gainMin, gainMax, "gain")
+        if gainMin == gainManual:
+            print("warning ,environment lux may too high")
+        elif gainMax == gainManual:
+            print("warning ,environment lux may too low")
+
+        return gainManual
+
+    def __aeGainScanVrf(self, blcTest: bool):
+        """
+        遍历AnaGain与VRF亮度
+        :blcTest: 测试blc还是亮度
+        """
+
+        # gainMin = self.readIsp("CAECFilter", "m_pMinTotalGain")
+        # gainMax = self.readIsp("CAECFilter", "m_pMaxTotalGain")
+        gainMin = int(self.readIsp("CAECFilter", "m_pMinAnaGain"))
+        gainMax = int(self.readIsp("CAECFilter", "m_pMaxAnaGain"))
+        expMin = int(self.readIsp("CAECFilter", "m_pMinExpTime"))
+        expMax = int(self.readIsp("CAECFilter", "m_pMaxExpTime"))
+        # 动态设置曝光，使得最大增益时，统计亮度尽量不饱和
+
+        if blcTest:
+            logFile = self.fileGainBlc
+            ExpTimeManual = expMin
+            # ponit = self.pointBLC
+        else:
+            logFile = self.fileGainLuma
+            ExpTimeManual = self.__getExpTimeManual(gainMin, gainMax, expMin, expMax)
+            # ponit = self.pointAE
+
+        # step = (gainMax - gainMin) // ponit
+        step = 256
+        print("gainMin(Q8)=", gainMin, "gainMax(Q8)=", gainMax, "step=", step)
+        print("set ExpTimeManual = ", ExpTimeManual)
+        self.writeIsp("CAECFilter", "m_pExpTimeManual", 0, 0, ExpTimeManual)
+        self.writeIsp("CAECFilter", "m_bManualAEEnable", 0, 0, 1)
+
+        cur = 1
+        total = int(math.log2(math.ceil(gainMax / gainMin))) + 1
+        with open(os.path.join(self.outPath, logFile), "a") as f:
+            for i in range(0, total):
+                gain = int(gainMin * math.pow(2, i))
+                meanR, meanGr, meanGb, meanB = self.__getGainLumaWithVrf(gain, ExpTimeManual)
+                writeStr = f"m_pExpTimeManual(us) = {ExpTimeManual} m_pTotalGainManual(Q8) = {gain} meanRGGB(12bit) = {meanR} {meanGr} {meanGb} {meanB} {cur}/{total}\n"
+                cur += 1
+                f.write(writeStr)
+                logi(writeStr)
+
+        time.sleep(1)
+
+    def __aeExpScanVrf(self, blcTest: bool):
+        """
+        遍历ExpTime与VRF亮度
+        :blcTest: 测试blc还是亮度
+        """
+
+        # gainMin = self.readIsp("CAECFilter", "m_pMinTotalGain")
+        # gainMax = self.readIsp("CAECFilter", "m_pMaxTotalGain")
+        gainMin = int(self.readIsp("CAECFilter", "m_pMinAnaGain"))
+        gainMax = int(self.readIsp("CAECFilter", "m_pMaxAnaGain"))
+        expMin = int(self.readIsp("CAECFilter", "m_pMinExpTime"))
+        expMax = int(self.readIsp("CAECFilter", "m_pMaxExpTime"))
+
+        if blcTest:
+            logFile = self.fileExpBlc
+            gainManual = gainMin
+            ponit = self.pointBLC
+        else:
+            logFile = self.fileExpLuma
+            gainManual = self.__getGainManual(gainMin, gainMax, expMin, expMax)
+            ponit = self.pointAE
+
+        step = (expMax - expMin) // ponit
+        print("expMin(us)=", expMin, "expMax(us)=", expMax, "step=", step)
+        print("set gainManual = ", gainManual)
+        self.writeIsp("CAECFilter", "m_pTotalGainManual", 0, 0, gainManual)
+        self.writeIsp("CAECFilter", "m_pAnaGainManual", 0, 0, gainManual)
+        self.writeIsp("CAECFilter", "m_bManualAEEnable", 0, 0, 1)
+
+        cur = 1
+        total = (expMax - expMin) // step + 1
+        with open(os.path.join(self.outPath, logFile), "a") as f:
+            for i in range(expMin, expMax + 1, step):
+                meanR, meanGr, meanGb, meanB = self.__getExpLumaWithVrf(gainManual, i)
+                writeStr = f"m_pExpTimeManual(us) = {i} m_pTotalGainManual(Q8) = {gainManual} meanRGGB(12bit) = {meanR} {meanGr} {meanGb} {meanB} {cur}/{total}\n"
+                cur += 1
+                f.write(writeStr)
+                logi(writeStr)
+
+        time.sleep(1)
+
+    def __aeGainScanStat(self):
+        """
+        遍历totalGain与AEM统计亮度,统计经过BLC,linearization
+        """
+
+        gainMin = int(self.readIsp("CAECFilter", "m_pMinTotalGain"))
+        gainMax = int(self.readIsp("CAECFilter", "m_pMaxTotalGain"))
+        # gainMin = self.readIsp("CAECFilter", "m_pMinAnaGain")
+        # gainMax = self.readIsp("CAECFilter", "m_pMaxAnaGain")
+        expMin = self.readIsp("CAECFilter", "m_pMinExpTime")
+        expMax = self.readIsp("CAECFilter", "m_pMaxExpTime")
+        # 动态设置曝光，使得最大增益时，统计亮度尽量不饱和
+        ExpTimeManual = self.__getExpTimeManual(gainMin, gainMax, expMin, expMax)
+
+        step = (gainMax - gainMin) // self.pointAE
+        print("gainMin(Q8)=", gainMin, "gainMax(Q8)=", gainMax, "step=", step)
+        print("set ExpTimeManual = ", ExpTimeManual)
+        self.writeIsp("CAECFilter", "m_bManualAEEnable", 0, 0, 1)
+        self.writeIsp("CAECFilter", "m_pExpTimeManual", 0, 0, ExpTimeManual)
+
+        logFile = self.fileGainLuma
+
+        cur = 1
+        total = (gainMax - gainMin) // step + 1
+        writeStr = ''
+        with open(os.path.join(self.outPath, logFile), "a") as f:
+            for i in range(gainMin, gainMax + 1, step):
+                if self.aeChl == 3:
+                    lumaR, lumaG, lumaB = self.__getLumaWithGain(i)
+                    writeStr = (
+                        "m_pExpTimeManual(us) = %d m_pTotalGainManual(Q8) = %d lumaRGB(8bit) = %f %f %f %d/%d\n"
+                        % (ExpTimeManual, i, lumaR, lumaG, lumaB, cur, total)
+                    )
+                elif self.aeChl == 1:
+                    luma = self.__getLumaWithGain(i)
+                    writeStr = "m_pExpTimeManual(us) = %d m_pTotalGainManual(Q8) = %d luma(8bit) = %f %d/%d\n" % (
+                        ExpTimeManual,
+                        i,
+                        luma,
+                        cur,
+                        total,
+                    )
+                cur += 1
+                f.write(writeStr)
+                logi(writeStr.replace("\n", "").replace("\r", ""))
+
+        time.sleep(1)
+
+    def __aeExpScanStat(self):
+        """
+        遍历ExpTime与AEM统计亮度,统计经过BLC,linearization
+        """
+
+        gainMin = int(self.readIsp("CAECFilter", "m_pMinTotalGain"))
+        gainMax = int(self.readIsp("CAECFilter", "m_pMaxTotalGain"))
+        # gainMin = self.readIsp("CAECFilter", "m_pMinAnaGain")
+        # gainMax = self.readIsp("CAECFilter", "m_pMaxAnaGain")
+        expMin = int(self.readIsp("CAECFilter", "m_pMinExpTime"))
+        expMax = int(self.readIsp("CAECFilter", "m_pMaxExpTime"))
+        # 动态设置曝光，使得最大增益时，统计亮度尽量不饱和
+        gainManual = self.__getGainManual(gainMin, gainMax, expMin, expMax)
+
+        step = (expMax - expMin) // self.pointAE
+        print("expMin(us)=", expMin, "expMax(us)=", expMax, "step=", step)
+        print("set gainManual = ", gainManual)
+        self.writeIsp("CAECFilter", "m_bManualAEEnable", 0, 0, 1)
+        self.writeIsp("CAECFilter", "m_pTotalGainManual", 0, 0, gainManual)
+
+        logFile = self.fileExpLuma
+        cur = 1
+        total = (expMax - expMin) // step + 1
+        writeStr = ''
+        with open(os.path.join(self.outPath, logFile), "a") as f:
+            for i in range(expMin, expMax + 1, step):
+                if self.aeChl == 3:
+                    lumaR, lumaG, lumaB = self.__getLumaWithExp(i)
+                    writeStr = (
+                        "m_pExpTimeManual(us) = %d m_pTotalGainManual(Q8) = %d lumaRGB(8bit) = %f %f %f %d/%d\n"
+                        % (i, gainManual, lumaR, lumaG, lumaB, cur, total)
+                    )
+
+                elif self.aeChl == 1:
+                    luma = self.__getLumaWithExp(i)
+                    writeStr = "m_pExpTimeManual(us) = %d m_pTotalGainManual(Q8) = %d luma(8bit) = %f %d/%d\n" % (
+                        i,
+                        gainManual,
+                        luma,
+                        cur,
+                        total,
+                    )
+                cur += 1
+                f.write(writeStr)
+                logi(writeStr.replace("\n", "").replace("\r", ""))
+
+        time.sleep(1)
+
+    def calibrateAE(self):
+        m_pExpIndexLong = self.readIsp("CAECFilter", "m_pExpIndexLong", 0, 0, False)
+        m_nLumaQ16 = self.readIsp("CAECFilter", "m_nLumaQ16", 0, 0, False)
+        logi(f"m_pExpIndexLong={m_pExpIndexLong}, m_nLumaQ16={m_nLumaQ16}")
+
+        self.writeIsp("CAECFilter", "m_nCalibExposureIndex", 0, 0, m_pExpIndexLong)
+        self.writeIsp("CAECFilter", "m_nCalibSceneLuma", 0, 0, m_nLumaQ16)
+
+        m_nCurLux = int(input(f"请输入当前照度lux: "))
+        self.writeIsp("CAECFilter", "m_nCalibSceneLux", 0, 0, m_nCurLux)
+
+    @staticmethod
+    def plotCurve(
+        out_path: str,
+        txt_file: str,
+        title: str,
+        xlabel: str,
+        ylabel: str,
+        col_x: int,
+        col_y: int,
+        fig=None,
+    ):
+        """
+        :param out_path: 需要读取的测试结果文件路径
+        :param txt_file: 需要读取的测试结果文件
+        :param title: 图表标题
+        :param xlabel: 图表x轴名称
+        :param ylabel: 图表y轴名称
+        :param col_x: 图表x轴数据所在列
+        :param col_y: 图表y轴数据所在列
+        :param fig: figure类,用于重绘曲线
+        """
+        needSave = 0
+
+        x = []
+        y = []
+        with open(os.path.join(out_path, txt_file), "r") as fp:
+            line = fp.readline()
+
+            while line:
+                # print(line.strip().split(' '))
+                x.append(float(line.strip().split(" ")[col_x]))  # get column col_x as x
+                y.append(float(line.strip().split(" ")[col_y]))  # get column col_y as y
+                line = fp.readline()
+
+        # if not is_increasing(x) or not is_increasing(y):
+        #     loge("%s not increasing, please check the %s " % (ylabel, title))
+
+        # print(x,y)
+        if fig == None:
+            fig = plt.figure(figsize=(16, 9))
+            needSave = 1
+        a1 = fig.add_axes((0.12, 0.1, 0.85, 0.85))
+        a1.plot(x, y, "r", linewidth=0.3)
+        a1.set_title(title)
+        # 设置y轴
+        a1.set_ylabel(ylabel)
+        # 设置x轴
+        a1.set_xlabel(xlabel)
+        # 设置grid
+        a1.grid(color="b", ls="-.", linewidth=0.3)
+        # 设置x从0开始
+        a1.set_xlim(0, max(x))
+
+        # 设置坐标轴刻度
+        ticks_x = np.linspace(0, max(x) + x[1] - x[0], 8)
+        ticks_y = np.linspace(0, max(y) + 10, 8)
+        a1.set_xticks(ticks_x)
+        a1.set_yticks(ticks_y)
+        if needSave == 1:
+            plt.savefig(os.path.join(out_path, title + ".png"))
+        plt.show()
+
+    @staticmethod
+    def plot3Curve(
+        out_path: str,
+        txt_file: str,
+        title: str,
+        xlabel: str,
+        ylabel: str,
+        col_x: int,
+        col_y: int,
+        fig=None,
+    ):
+        """
+        :param out_path: 需要读取的测试结果文件路径
+        :param txt_file: 需要读取的测试结果文件
+        :param title: 图表标题
+        :param xlabel: 图表x轴名称
+        :param ylabel: 图表y轴名称
+        :param col_x: 图表x轴数据所在列
+        :param col_y: 图表y轴数据所在列
+        :param fig: figure类,用于重绘曲线
+        """
+        needSave = 0
+
+        x = []
+        r = []
+        g = []
+        b = []
+        with open(os.path.join(out_path, txt_file), "r") as fp:
+            line = fp.readline()
+
+            while line:
+                # print(line.strip().split(' '))
+                x.append(float(line.strip().split(" ")[col_x]))  # get column col_x as x
+                r.append(float(line.strip().split(" ")[col_y]))  # get column col_y as r
+                g.append(float(line.strip().split(" ")[col_y + 1]))
+                b.append(float(line.strip().split(" ")[col_y + 2]))
+                line = fp.readline()
+
+        if not is_increasing(x) or not is_increasing(r) or not is_increasing(g) or not is_increasing(b):
+            loge("%s not increasing, please check the %s " % (ylabel, title))
+
+        # print(x,y)
+        if fig == None:
+            fig = plt.figure(figsize=(16, 9))
+            needSave = 1
+        a1 = fig.add_axes((0.12, 0.1, 0.85, 0.85))
+        a1.plot(
+            x,
+            r,
+            color="red",
+            label="R",
+            linewidth=0.3,
+        )
+        a1.plot(x, g, color="green", label="G", linewidth=0.3)
+        a1.plot(x, b, color="blue", label="B", linewidth=0.3)
+        a1.set_title(title)
+        # 设置y轴
+        a1.set_ylabel(ylabel)
+        # 设置x轴
+        a1.set_xlabel(xlabel)
+        # 设置grid
+        a1.grid(color="Magenta", ls="-.", lw=0.35)
+        # 设置x从0开始
+        a1.set_xlim(0, max(x))
+        a1.legend()
+        # 设置坐标轴刻度
+        ticks_x = np.linspace(0, max(x) + x[1] - x[0], 8)
+        ticks_y = np.linspace(0, max(max(r), max(g), max(b)) + 10, 8)
+        a1.set_xticks(ticks_x)
+        a1.set_yticks(ticks_y)
+        if needSave == 1:
+            plt.savefig(os.path.join(out_path, title + ".png"))
+        # plt.show()
+
+    @staticmethod
+    def plot4Curve(
+        out_path: str,
+        txt_file: str,
+        title: str,
+        xlabel: str,
+        ylabel: str,
+        col_x: int,
+        col_y: int,
+        fig=None,
+    ):
+        """
+        :param out_path: 需要读取的测试结果文件路径
+        :param txt_file: 需要读取的测试结果文件
+        :param title: 图表标题
+        :param xlabel: 图表x轴名称
+        :param ylabel: 图表y轴名称
+        :param col_x: 图表x轴数据所在列
+        :param col_y: 图表y轴数据所在列
+        :param fig: figure类,用于重绘曲线
+        """
+        needSave = 0
+
+        x = []
+        r = []
+        gr = []
+        gb = []
+        b = []
+        with open(os.path.join(out_path, txt_file), "r") as fp:
+            line = fp.readline()
+
+            while line:
+                # print(line.strip().split(' '))
+                # rc = re.compile(r"(m_pExpTimeManual.*?|m_pTotalGainManual.*?|meanRGGB.*?) = (\d+|\d+\.\d+)")
+                # print(rc.findall(line))
+                x.append(float(line.strip().split()[col_x]))  # get column col_x as x
+                r.append(float(line.strip().split()[col_y]))  # get column col_y as r
+                gr.append(float(line.strip().split()[col_y + 1]))
+                gb.append(float(line.strip().split()[col_y + 2]))
+                b.append(float(line.strip().split()[col_y + 3]))
+                line = fp.readline()
+
+        if fig == None:
+            fig = plt.figure(figsize=(16, 9))
+            needSave = 1
+        a1 = fig.add_axes((0.12, 0.1, 0.85, 0.85))
+
+        a1.plot(x, r, color="red", label="R", linewidth=0.3)
+        a1.plot(x, gr, color=("yellowgreen"), label="Gr", linewidth=0.3)
+        a1.plot(x, gb, color="lightgreen", label="Gb", linewidth=0.3)
+        a1.plot(x, b, color="blue", label="B", linewidth=0.3)
+        a1.set_title(title)
+        # 设置y轴
+        a1.set_ylabel(ylabel)
+        # 设置x轴
+        a1.set_xlabel(xlabel)
+        # 设置grid
+        a1.grid(color="Magenta", ls="-.", lw=0.35)
+        # 设置x从0开始
+        a1.set_xlim(0, max(x))
+        a1.legend()
+        # 设置坐标轴刻度
+        ticks_x = np.linspace(0, max(x) + x[1] - x[0], 8)
+        ticks_y = np.linspace(0, max(max(r), max(gr), max(gb), max(b)) + 10, 8)
+        a1.set_xticks(ticks_x)
+        a1.set_yticks(ticks_y)
+        if needSave == 1:
+            plt.savefig(os.path.join(out_path, title + ".png"))
+        # plt.show()
+
+    def aeVrfDvt(self):
+        """
+        1. 光源需直流无频闪,照度约 800-1000lux
+        """
+
+        self.__filterEnable(1, 0, 0, 0, 0, 0)
+
+        self.__aeGainScanVrf(False)
+        self.plot4Curve(
+            self.outPath,
+            self.fileGainLuma,
+            "Gain-Luma",
+            "Gain(Q8)",
+            "Luma(10bit)",
+            5,
+            8,
+        )
+
+        self.__aeExpScanVrf(False)
+        self.plot4Curve(self.outPath, self.fileExpLuma, "Exp-Luma", "Exp(us)", "Luma(10bit)", 2, 8)
+        self.__filterEnable(1, 1, 1, 1, 1, 1)
+        self.writeIsp("CAECFilter", "m_bManualAEEnable", 0, 0, 0)
+
+    def aeStatDvt(self):
+        """
+        1. 光源需直流无频闪,照度约 800-1000lux
+        """
+
+        self.__filterEnable(1, 0, 0, 0, 0, 0)
+
+        self.__aeGainScanStat()
+        if self.aeChl == 3:
+            self.plot3Curve(
+                self.outPath,
+                self.fileGainLuma,
+                "Gain-Luma",
+                "Gain(Q8)",
+                "Luma(8bit)",
+                5,
+                8,
+            )
+        elif self.aeChl == 1:
+            self.plotCurve(
+                self.outPath,
+                self.fileGainLuma,
+                "Gain-Luma",
+                "Gain(Q8)",
+                "Luma(8bit)",
+                5,
+                8,
+            )
+        self.__aeExpScanStat()
+        if self.aeChl == 3:
+            self.plot3Curve(self.outPath, self.fileExpLuma, "Exp-Luma", "Exp(us)", "Luma(8bit)", 2, 8)
+        elif self.aeChl == 1:
+            self.plotCurve(self.outPath, self.fileExpLuma, "Exp-Luma", "Exp(us)", "Luma(8bit)", 2, 8)
+        self.__filterEnable(1, 1, 1, 1, 1, 1)
+        self.writeIsp("CAECFilter", "m_bManualAEEnable", 0, 0, 0)
+
+    def blcDvt(self):
+        """
+        1. 全黑环境
+        """
+
+        self.__filterEnable(1, 0, 0, 0, 0, 0)
+        self.__aeGainScanVrf(True)
+        self.plot4Curve(self.outPath, self.fileGainBlc, "Gain-blc", "Gain(Q8)", "blc(10bit)", 5, 8)
+
+        self.__aeExpScanVrf(True)
+        self.plot4Curve(self.outPath, self.fileExpBlc, "Exp-blc", "Exp(us)", "blc(10bit)", 2, 8)
+        self.__filterEnable(1, 1, 1, 1, 1, 1)
+        self.writeIsp("CAECFilter", "m_bManualAEEnable", 0, 0, 0)
+
+    def blcScanVrf(self):
+        """
+        遍历AnaGain与VRF
+        """
+        # gainMin = self.readIsp("CAECFilter", "m_pMinAnaGain")
+        gainMin = 256
+        gainMax = self.readIsp("CAECFilter", "m_pMaxAnaGain")
+        print("gainMin(Q8)=", gainMin, "gainMax(Q8)=", gainMax)
+        self.writeIsp("CAECFilter", "m_bManualAEEnable", 0, 0, 1)
+        pCmd("adb shell rm data/vendor/camera/*", 1)
+        pCmd("adb shell setprop persist.vendor.camera.enable.capturedump 1", 0.5)
+        # outPath = os.path.join(self.outPath, "raw")
+        outPath = self.outPath
+        if not os.path.exists(outPath):
+            os.makedirs(outPath)
+        for i in range(0, int(math.log2(math.ceil(gainMax / gainMin))) + 1):
+            gain = int(gainMin * math.pow(2, i))
+            print("gain(Q8)=", gain)
+            self.writeIsp("CAECFilter", "m_pTotalGainManual", 0, 0, gain)
+            self.writeIsp("CAECFilter", "m_pAnaGainManual", 0, 0, gain)
+            time.sleep(0.2)
+            vrfName = "gain_" + str(gain // 256) + ".vrf"
+            self.dumpVrf(outPath, vrfName)
+            # pCmd("adb shell input keyevent 27",sleep_s=5)
+
+        time.sleep(1)
+
+    def gainScanVrf(self):
+        """
+        遍历AnaGain与VRF
+        """
+
+        gainMin = 256
+        gainMax = self.readIsp("CAECFilter", "m_pMaxAnaGain")
+        print("gainMin(Q8)=", gainMin, "gainMax(Q8)=", gainMax)
+        self.writeIsp("CAECFilter", "m_bManualAEEnable", 0, 0, 0)
+        pCmd("adb shell rm data/vendor/camera/*", 1)
+        pCmd("adb shell setprop persist.vendor.camera.enable.capturedump 1", 0.5)
+        # outPath = os.path.join(self.outPath, "raw")
+        outPath = self.outPath
+        if not os.path.exists(outPath):
+            os.makedirs(outPath)
+        for i in range(0, int(math.log2(math.ceil(gainMax / gainMin))) + 1):
+            gain = int(gainMin * math.pow(2, i))
+            print("gain(Q8)=", gain)
+            self.writeIsp("CAECFilter", "m_pMinAnaGain", 0, 0, gain)
+            self.writeIsp("CAECFilter", "m_pMaxAnaGain", 0, 0, gain)
+            self.writeIsp("CAECFilter", "m_pMinTotalGain", 0, 0, gain)
+            self.writeIsp("CAECFilter", "m_pMaxTotalGain", 0, 0, gain)
+            time.sleep(0.2)
+            vrfName = "gain_" + str(gain // 256) + ".vrf"
+            self.dumpVrf(outPath, vrfName)
+            # pCmd("adb shell input keyevent 27",sleep_s=5)
+
+        time.sleep(1)
+
+    def afScan(self):
+        """
+        遍历AF position与FV
+        """
+
+        # full scan
+        startPosition = 0
+        endPosition = 1023
+        step = (endPosition - startPosition) // self.pointAF
+
+        self.writeIsp("CAFFilter", "m_nMinMotorPosition", 0, 0, startPosition)
+        self.writeIsp("CAFFilter", "m_nMaxMotorPosition", 0, 0, endPosition)
+        logi(f"startPosition= {startPosition}, endPosition= {endPosition}, step= {step}")
+
+        self.writeIsp("CAFFilter", "m_bAFTrigger", 0, 0, 0)
+
+        cur = 1
+        total = (endPosition - startPosition) // step + 1
+        with open(os.path.join(self.outPath, self.fileAF), "a") as f:
+            for i in range(startPosition, endPosition + 1, step):
+                self.writeIsp("CAFFilter", "m_nManualMotorPosition", 0, 0, i)
+                self.writeIsp("CAFFilter", "m_bMotorManualTrigger", 0, 0, 1)
+                time.sleep(1)
+                m_pRTFVList = self.readIsp("CAFFilter", "m_pRTFVList", 0, 0, False)
+
+                writeStr = "%d/%d position = %d FV = %d \n" % (cur, total, i, m_pRTFVList)
+                cur += 1
+                f.write(writeStr)
+                logi(writeStr.replace("\n", "").replace("\r", ""))
+
+        time.sleep(1)
+
+    def dumpPDVrf(self, outPath: str, posCode: str):
+        cmd = f"{self.tuning_assistant} 127.0.0.1 t 3000 3000 3000 dp m0_g0 {outPath} 1"
+        out = pCmd(cmd)
+
+        # 使用正则表达式查找关键词之间的字符串
+        keyword1 = "ID="
+        keyword2 = "\n"
+        match = re.search(f"{keyword1}(.*?){keyword2}", out[0])
+        if match:
+            ch0 = str(match.group(1)) + "_0.vrf"
+            ch1 = str(match.group(1)) + "_1.vrf"
+            fullpath0 = os.path.join(outPath, ch0)
+            fullpath1 = os.path.join(outPath, ch1)
+            newfile0 = os.path.join(outPath, str(posCode) + "_L.vrf")
+            newfile1 = os.path.join(outPath, str(posCode) + "_R.vrf")
+            renameFile(newfile0, fullpath0)
+            renameFile(newfile1, fullpath1)
+        else:
+            print("抓取vrf失败")
+            sys.exit()
+
+    def pdafScan(self, isType2=False):
+        """
+        抓取11张不同position的vrf
+        """
+
+        # full scan
+        startPosition = int(self.readIsp("CAFFilter", "m_nMinMotorPosition", 0, 0, False))
+        endPosition = int(self.readIsp("CAFFilter", "m_nMaxMotorPosition", 0, 0, False))
+        step = (endPosition - startPosition) // 10
+
+        logi(f"startPosition= {startPosition}, endPosition= {endPosition}, step= {step}")
+
+        self.writeIsp("CAFFilter", "m_bAFTrigger", 0, 0, 0)
+
+        if isType2:
+            self.writeIsp("CPDC64FirmwareFilter", "m_nWindowMode", 0, 0, 2)
+
+        cur = 1
+        total = (endPosition - startPosition) // step + 1
+        for i in range(startPosition, endPosition + 1, step):
+            self.writeIsp("CAFFilter", "m_nManualMotorPosition", 0, 0, i)
+            self.writeIsp("CAFFilter", "m_bMotorManualTrigger", 0, 0, 1)
+            time.sleep(2)
+            # outPath = os.path.join(self.outPath, "raw")
+            outPath = self.outPath
+            if not os.path.exists(outPath):
+                os.makedirs(outPath)
+            if isType2:
+                self.dumpPDVrf(outPath, str(i))
+                self.dumpVrf(outPath, str(i) + ".vrf")
+            else:
+                self.dumpVrf(outPath, str(i) + ".vrf")
+            logi(f"position = {i} {cur}/{total}")
+            cur += 1
+        time.sleep(1)
+
+    def afDvt(self):
+        """
+        光源需直流无频闪,照度800lux, 50cm距离细节丰富的chart
+        """
+
+        pCmd("adb shell input keyevent KEYCODE_HOME", 3)
+        pCmd("adb shell am start -a android.media.action.STILL_IMAGE_CAMERA", 2)
+
+        self.__filterEnable(0, 1, 0, 0, 0, 0)
+
+        self.afScan()
+        self.plotCurve(self.outPath, self.fileAF, "position-FV", "position", "FV", 3, 6)
+
+        self.__filterEnable(1, 1, 1, 1, 1, 1)
+
+
+def reDrawAE(outPath: str, chl: int):
+    """
+    再次绘制AE曲线
+    :outPath: log文件夹
+    :chl 曲线是三通道还是四通道
+    """
+
+    fileGainLuma = "gainLuma.log"
+    fileExpLuma = "expLuma.log"
+    plt.ion()  # 开启interactive mode
+    fig1 = plt.figure(1, figsize=(16, 9))
+    fig2 = plt.figure(2, figsize=(16, 9))
+    if chl == 4:
+        CamDvt.plot4Curve(outPath, fileGainLuma, "Gain-Luma", "Gain(Q8)", "Luma(10bit)", 5, 8, fig1)
+        CamDvt.plot4Curve(outPath, fileExpLuma, "Exp-Luma", "Exp(us)", "Luma(10bit)", 2, 8, fig2)
+    elif chl == 3:
+        CamDvt.plot3Curve(outPath, fileGainLuma, "Gain-Luma", "Gain(Q8)", "Luma(8bit)", 5, 8, fig1)
+        CamDvt.plot3Curve(outPath, fileExpLuma, "Exp-Luma", "Exp(us)", "Luma(8bit)", 2, 8, fig2)
+    elif chl == 1:
+        CamDvt.plotCurve(outPath, fileGainLuma, "Gain-Luma", "Gain(Q8)", "Luma(8bit)", 5, 8, fig1)
+        CamDvt.plotCurve(outPath, fileExpLuma, "Exp-Luma", "Exp(us)", "Luma(8bit)", 2, 8, fig2)
+    plt.ioff()  # 关闭interactive mode
+    plt.show()  # 显示图像1,2并且阻塞程序
+
+
+def reDrawBLC(outPath: str):
+    fileGainBlc = "gainBlc.log"
+    fileExpBlc = "expBlc.log"
+    plt.ion()  # 开启interactive mode
+    fig1 = plt.figure(1, figsize=(16, 9))
+    fig2 = plt.figure(2, figsize=(16, 9))
+    CamDvt.plot4Curve(outPath, fileGainBlc, "Gain-blc", "Gain(Q8)", "blc(10bit)", 5, 8, fig1)
+    CamDvt.plot4Curve(outPath, fileExpBlc, "Exp-blc", "Exp(us)", "blc(10bit)", 2, 8, fig2)
+    plt.ioff()  # 关闭interactive mode
+    plt.show()  # 显示图像1,2并且阻塞程序
+
+
+def reDrawAF(outPath: str):
+    fileAF = "af.log"
+    plt.ion()
+    fig1 = plt.figure(1, figsize=(16, 9))
+    CamDvt.plotCurve(outPath, fileAF, "position-FV", "position", "FV", 3, 6, fig1)
+    plt.ioff()
+    plt.show()
+
+
+def CLI_aeDVT(argsList):
+    parser = argparse.ArgumentParser(
+        prog="aeDvt", description="测试AE线性度" "光源需直流无频闪,照度800lux, 镜头前使用diffuse盖住"
+    )
+    parser.add_argument(
+        "-t", "--type", type=str, required=True, default="statistic", choices=["vrf", "statistic"], help="统计方式"
+    )
+    args = parser.parse_args(argsList)
+
+    start_time = time.time()
+    dvt = CamDvt(sys._getframe(0).f_code.co_name)
+    if args.type == "vrf":
+        dvt.aeVrfDvt()
+    else:
+        dvt.aeStatDvt()
+    end_time = time.time()
+    elapsed_time = int(end_time - start_time)
+    print(f"测试耗时：{elapsed_time} 秒")
+
+
+def CLI_afDVT():
+    """
+    光源需直流无频闪,照度800lux, 50cm距离细节丰富的chart
+    """
+
+    start_time = time.time()
+    dvt = CamDvt(sys._getframe(0).f_code.co_name)
+    dvt.afDvt()
+    end_time = time.time()
+    elapsed_time = int(end_time - start_time)
+    print(f"测试耗时：{elapsed_time} 秒")
+
+
+def CLI_pdafCap(argsList):
+    parser = argparse.ArgumentParser(
+        prog="pdafVrfCap",
+        description="抓取不同position的vrf,用于pdaf测试"
+        "光源需直流无频闪,照度800lux, 据棋盘格距离为 对焦范围中间位合焦位置",
+    )
+    parser.add_argument(
+        "-t", "--type", type=str, required=True, default="type2", choices=["type2", "type3"], help="pdaf类型"
+    )
+    args = parser.parse_args(argsList)
+
+    isType2 = False
+    if args.type == "type2":
+        isType2 = True
+        logi("pdaf type2")
+    else:
+        logi("pdaf type3")
+    start_time = time.time()
+    dvt = CamDvt(sys._getframe(0).f_code.co_name)
+    dvt.pdafScan(isType2)
+    end_time = time.time()
+    elapsed_time = int(end_time - start_time)
+    print(f"测试耗时：{elapsed_time} 秒")
+
+
+def CLI_gainScan():
+    start_time = time.time()
+    dvt = CamDvt(sys._getframe(0).f_code.co_name)
+    dvt.gainScanVrf()
+    end_time = time.time()
+    elapsed_time = int(end_time - start_time)
+    print(f"测试耗时：{elapsed_time} 秒")
+
+
+def CLI_blcScan():
+    """
+    1. 全黑环境
+    """
+
+    start_time = time.time()
+    dvt = CamDvt(sys._getframe(0).f_code.co_name)
+    dvt.blcScanVrf()
+    end_time = time.time()
+    elapsed_time = int(end_time - start_time)
+    print(f"测试耗时：{elapsed_time} 秒")
+
+
+def CLI_blcDVT():
+    """
+    1. 全黑环境
+    """
+
+    start_time = time.time()
+    dvt = CamDvt(sys._getframe(0).f_code.co_name)
+    dvt.blcDvt()
+    end_time = time.time()
+    elapsed_time = int(end_time - start_time)
+    print(f"测试耗时：{elapsed_time} 秒")
+
+
+def CLI_calibAE():
+    dvt = CamDvt()
+    dvt.calibrateAE()
+
+
+_COMMAND_REGISTRY = {}
+
+
+def printHelp():
+    print("[camDvt]")
+    print("ae -h         :ae dvt with vrf/statistic [800lux, no flicker with diffuse]")
+    print("af           :af dvt [光源需直流无频闪,照度800lux, 50cm距离细节丰富的chart]")
+    print("pdaf -h        :pdaf capture 31 frames [直流无频闪,照度800lux, 据棋盘格距离为 对焦范围中间位合焦位置]")
+    print("blc          :blc dvt [全黑环境]")
+    print("blcscan      :blc scan [全黑环境]")
+    print("gainscan     :gain scan [gain 指数增加]")
+    print("calae        :AE校准")
+
+
+CLI_aeDVT = register_command("ae", registry=_COMMAND_REGISTRY)(CLI_aeDVT)
+CLI_afDVT = register_command("af", registry=_COMMAND_REGISTRY)(CLI_afDVT)
+CLI_blcDVT = register_command("blc", registry=_COMMAND_REGISTRY)(CLI_blcDVT)
+CLI_pdafCap = register_command("pdaf", registry=_COMMAND_REGISTRY)(CLI_pdafCap)
+CLI_blcScan = register_command("blcscan", registry=_COMMAND_REGISTRY)(CLI_blcScan)
+CLI_gainScan = register_command("gainscan", registry=_COMMAND_REGISTRY)(CLI_gainScan)
+CLI_calibAE = register_command("calae", registry=_COMMAND_REGISTRY)(CLI_calibAE)
+
+
+def camDvtMain(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
+    camDvtMain(sys.argv)