taotoolkit 1.0.0__py3-none-any.whl

taotoolkit/__init__.py

@@ -0,0 +1,81 @@
+from .tao_common import (
+    debugCtrl,
+    logd,
+    logi,
+    logw,
+    loge,
+    logh,
+    logCallDebug,
+    logCallInfo,
+    logCallWarn,
+    logCallHigh,
+    logCallErr,
+    pCmd,
+    rCmd,
+    oCmd,
+    exit,
+    eExit,
+    iExit,
+    createFolder,
+    fileExist,
+    findFilesBySuffixKeyword,
+    normalize_args,
+    register_command,
+)
+
+# 导入各模块
+
+from .tao_device import deviceMain as deviceMain, printHelp as deviceHelp, DevOp
+from .tao_flash import flashMain as flashMain, printHelp as flashHelp, jenkinsTool
+from .tao_tuning import tuningMain as tuningMain, printHelp as tuningHelp, asrCamOp
+from .tao_cmdTool import cmdToolMain as cmdToolMain, printHelp as toolHelp
+from .tao_vrfTool import vrfToolMain as vrfToolMain, printHelp as vrfHelp
+from .tao_camDvt import camDvtMain as camDvtMain, printHelp as camDvtHelp, CamDvt
+
+
+from .asrVrf import Vrf
+
+__version__ = "1.0.0"
+
+__all__ = [
+    "debugCtrl",
+    "logd",
+    "logi",
+    "logw",
+    "loge",
+    "logh",
+    "logCallDebug",
+    "logCallInfo",
+    "logCallWarn",
+    "logCallHigh",
+    "logCallErr",
+    "pCmd",
+    "rCmd",
+    "oCmd",
+    "exit",
+    "eExit",
+    "iExit",
+    "createFolder",
+    "fileExist",
+    "findFilesBySuffixKeyword",
+    "normalize_args",
+    "register_command",
+    "deviceMain",
+    "deviceHelp",
+    "DevOp",
+    "flashMain",
+    "flashHelp",
+    "jenkinsTool",
+    "tuningMain",
+    "tuningHelp",
+    "asrCamOp",
+    "cmdToolMain",
+    "toolHelp",
+    "vrfToolMain",
+    "vrfHelp",
+    "camDvtMain",
+    "camDvtHelp",
+    "CamDvt",
+    "Vrf",
+    "__version__",
+]

taotoolkit/asrVrf.py

@@ -0,0 +1,322 @@
+import sys
+import os
+import numpy as np
+from typing import Optional, Tuple, Union, Any
+
+try:
+    import matplotlib.pyplot as plt
+
+    HAS_PLT = True
+except ImportError:
+    HAS_PLT = False
+
+
+class VrfTail:
+    def __init__(self):
+        self.dataSize: int = 0
+        self.packPixelNum: int = 0
+        self.rowSize: int = 0
+        self.fileSize: int = 0
+        self.metaSize: int = 128
+        self.Width: np.uint16 = np.uint16(640)
+        self.Height: np.uint16 = np.uint16(480)
+        self.TGain: np.uint16 = np.uint16(16)
+        """ np.uint16: total gain, Q4 """
+        self.ExpoLine: np.uint16 = np.uint16(10)
+        self.VTS: np.uint16 = np.uint16(0)
+        self.AWBGainB: np.uint16 = np.uint16(128)
+        """ np.uint16: AWB B gain, Q7 """
+        self.AWBGainG: np.uint16 = np.uint16(128)
+        """ np.uint16: AWB G gain, Q7 """
+        self.AWBGainR: np.uint16 = np.uint16(128)
+        """ np.uint16: AWB R gain, Q7 """
+        self.AWBGainWriteB: np.uint16 = self.AWBGainB
+        self.AWBGainWriteGb: np.uint16 = self.AWBGainG
+        self.AWBGainWriteGr: np.uint16 = self.AWBGainG
+        self.AWBGainWriteR: np.uint16 = self.AWBGainR
+        self.BLC10b: np.uint8 = np.uint8(64)
+        """ np.uint16: Black Value in 10bit """
+        self.BayerOrder: np.uint8 = np.uint8(0)
+        """ np.uint16: Bayer pattern - 0:BGGR, 1:GBRG, 2:GRBG, 3:RGGB """
+        self.BLC12b: np.uint16 = np.uint16(int(self.BLC10b) * 4)
+        self.Reserve: np.ndarray = np.zeros(78, dtype=np.uint8)
+        self.WBGoldenRG: np.uint16 = np.uint16(0)
+        self.WBModuleBG: np.uint16 = np.uint16(0)
+        self.DrcGainDark: np.uint8 = np.uint8(16)
+        """ np.uint16: DrcGainDark, Q4 """
+        self.DrcGain: np.uint8 = np.uint8(16)
+        """ np.uint16: DrcGain, Q4 """
+        self.ExpoTime_us: np.uint32 = np.uint32(10)
+        """ np.uint16: exposure time, us """
+        self.Packed: np.uint8 = np.uint8(0)  # 0-nopack, 1-pack
+        self.BitDepth: np.uint8 = np.uint8(10)
+        """ np.uint16: BitDepth - 8,10,12,14,16 """
+        self.AGain: np.uint16 = np.uint16(16)
+        """ np.uint16: Analog Gain, Q4 """
+        self.VRFRevision: np.uint16 = np.uint16(41)  # VRF 2.9
+        self.IDString: list[str] = ["V", "R", "F"]
+        self.unpackImage: np.ndarray = np.zeros((self.Height, self.Width), dtype=np.uint16)
+
+    def GetMeta(self) -> np.ndarray:
+        "Get Meta in np.uint16 format"
+        meta = np.zeros(64, dtype=np.uint16)
+        meta[0] = self.Width
+        meta[1] = self.Height
+        meta[2] = self.TGain
+        meta[3] = self.ExpoLine
+        meta[4] = self.VTS
+        meta[5] = self.AWBGainB
+        meta[6] = self.AWBGainG
+        meta[7] = self.AWBGainR
+        meta[8] = self.AWBGainB
+        meta[9] = self.AWBGainG
+        meta[10] = self.AWBGainG
+        meta[11] = self.AWBGainR
+        meta[12] = self.BLC10b + self.BayerOrder.astype(np.uint16) * 256
+        meta[13] = self.BLC12b
+        high = self.Reserve[1::2].astype(np.uint16) << 8  # 左移 8 位相当于 * 256
+        low = self.Reserve[::2].astype(np.uint16)
+        meta[14:53] = high + low
+        meta[53] = self.WBGoldenRG
+        meta[54] = self.WBModuleBG
+        meta[55] = self.WBGoldenRG
+        meta[56] = self.WBModuleBG
+        meta[57] = self.DrcGain.astype(np.uint16) * 256 + self.DrcGainDark.astype(np.uint16)
+        meta[58] = np.bitwise_and(self.ExpoTime_us, 65535)
+        meta[59] = np.right_shift(self.ExpoTime_us, 16)
+        meta[60] = self.BitDepth.astype(np.uint16) * 256 + self.Packed.astype(np.uint16)
+        meta[61] = self.AGain
+        meta[62] = self.VRFRevision + ord(self.IDString[0]) * 256
+        meta[63] = ord(self.IDString[1]) + ord(self.IDString[2]) * 256
+        return meta
+
+    def SetMeta(self, meta: np.ndarray) -> None:
+        "Set Meta in np.uint16 format"
+        if meta.shape != (64,):
+            print("SetMeta: meta.shape mismatch!")
+            return
+
+        self.Width = meta[0]
+        self.Height = meta[1]
+        self.TGain = meta[2]
+        self.ExpoLine = meta[3]
+        self.VTS = meta[4]
+        self.AWBGainB = meta[5]
+        self.AWBGainG = meta[6]
+        self.AWBGainR = meta[7]
+        self.AWBGainWriteB = self.AWBGainB
+        self.AWBGainWriteGb = self.AWBGainG
+        self.AWBGainWriteGr = self.AWBGainG
+        self.AWBGainWriteR = self.AWBGainR
+        self.BLC10b = np.bitwise_and(meta[12], 255)
+        self.BayerOrder = np.right_shift(meta[12], 8)
+        self.BLC12b = meta[13]
+        self.Reserve[1::2] = np.right_shift(meta[14:53], 8)
+        self.Reserve[::2] = np.bitwise_and(meta[14:53], 255)
+        self.WBGoldenRG = meta[53]
+        self.WBModuleBG = meta[54]
+        self.WBGoldenRG = meta[55]
+        self.WBModuleBG = meta[56]
+        self.DrcGainDark = np.bitwise_and(meta[57], 255)
+        self.DrcGain = np.right_shift(meta[57], 8)
+        self.ExpoTime_us = np.uint32(meta[58] + np.left_shift(meta[59], 16))
+        self.Packed = np.bitwise_and(meta[60], 255)
+        self.BitDepth = np.right_shift(meta[60], 8)
+        self.AGain = meta[61]
+        self.VRFRevision = np.bitwise_and(meta[62], 255)
+        self.IDString[0] = chr(np.right_shift(meta[62], 8))
+        self.IDString[1] = chr(np.bitwise_and(meta[63], 255))
+        self.IDString[2] = chr(np.right_shift(meta[63], 8))
+
+
+class Vrf(VrfTail):
+    "VRF File Class"
+
+    def __init__(self):
+        VrfTail.__init__(self)
+
+    def Read(self, fname: str) -> None:
+        "Read Vrf File"
+        with open(fname, "rb") as fp:
+            data = np.fromfile(fp, dtype=np.uint16)
+
+        self.fileSize = os.path.getsize(fname)
+        self.SetMeta(data[-64:])
+        self._checkVrf()
+
+        if self.Packed:
+            # data[:-64] 是 uint16 数组，需要转为 bytes 传给 _unpackVrf
+            packed_data = data[:-64].tobytes()
+            self.unpackImage = self._unpackVrf(packed_data)
+            self.Packed = np.uint8(0)
+        else:
+            # 确保数据是 uint16 类型
+            self.unpackImage = data[:-64].astype(np.uint16)
+
+        # 重塑图像数据
+        self.unpackImage = self.unpackImage.reshape((int(self.Height), int(self.Width)))
+
+    def _getPackVrfSize(self) -> int:
+        if self.BitDepth == 8:
+            self.packPixelNum = 16
+        elif self.BitDepth == 10:
+            self.packPixelNum = 12
+        elif self.BitDepth == 12:
+            self.packPixelNum = 10
+        elif self.BitDepth == 16:
+            self.packPixelNum = 8
+        else:
+            print("VRF BitDepth wrong, please check it")
+            sys.exit()
+
+        self.rowSize = int(self.Width / self.packPixelNum)  # in 128bit
+        if self.rowSize * self.packPixelNum < self.Width:
+            self.rowSize += 1
+        self.rowSize = self.rowSize << 4  # in byte
+        return self.rowSize * int(self.Height)
+
+    def _unpackPixels(self, packed: bytes) -> np.ndarray:
+        width = int(self.Width)
+        height = int(self.Height)
+        bitDepth = int(self.BitDepth)
+
+        if bitDepth == 10:
+            """
+            PackedRaw10 → Unpacked Raw16(每像素2字节,uint16 little-endian,值范围 0~1023)
+            输出大小 = width * height * 2 字节
+            """
+            bytes_per_line_src = (width + 11) // 12 * 16
+
+            src = np.frombuffer(packed, dtype=np.uint8)
+            src = src[: height * bytes_per_line_src].reshape(height, bytes_per_line_src)
+
+            groups_per_line = (width + 11) // 12
+
+            # shape: (height, groups_per_line, 3, 5)
+            src_grouped = src[:, : groups_per_line * 16].reshape(height, groups_per_line, 16)
+            s = np.stack(
+                [
+                    src_grouped[:, :, 0:5],
+                    src_grouped[:, :, 5:10],
+                    src_grouped[:, :, 10:15],
+                ],
+                axis=2,
+            )
+
+            s0 = s[:, :, :, 0].astype(np.uint16)
+            s1 = s[:, :, :, 1].astype(np.uint16)
+            s2 = s[:, :, :, 2].astype(np.uint16)
+            s3 = s[:, :, :, 3].astype(np.uint16)
+            s4 = s[:, :, :, 4].astype(np.uint16)
+
+            # 直接解出4个10bit像素，shape: (height, groups_per_line, 3, 4)
+            p = np.zeros((height, groups_per_line, 3, 4), dtype=np.uint16)
+            p[:, :, :, 0] = (((s0 & 0xFC) >> 2) | ((s1 & 0x03) << 6)) << 2 | (s0 & 0x03)
+            p[:, :, :, 1] = (((s1 & 0xF0) >> 4) | ((s2 & 0x0F) << 4)) << 2 | ((s1 & 0x0C) >> 2)
+            p[:, :, :, 2] = (((s2 & 0xC0) >> 6) | ((s3 & 0x3F) << 2)) << 2 | ((s2 & 0x30) >> 4)
+            p[:, :, :, 3] = s4 << 2 | ((s3 & 0xC0) >> 6)
+
+            # reshape 成 (height, groups_per_line * 3 * 4) 再裁到实际宽度
+            pixels = p.reshape(height, groups_per_line * 3 * 4)[:, :width]
+
+            return pixels.astype(np.uint16)
+        else:
+            print("unpackVrf: currently only support 10bit packed image")
+            sys.exit()
+            return np.array([], dtype=np.uint16)  # 为类型检查器添加返回
+
+    def _unpackVrf(self, src: bytes) -> np.ndarray:
+        if self.Packed == 1:
+            return self._unpackPixels(src)
+        else:
+            print("unpackVrf: image is not packed")
+            return np.array([], dtype=np.uint16)  # 返回空数组
+
+    def rot(self, mode: str) -> None:
+        if self.Packed == 1:
+            print("can't rotate packed image")
+            return
+
+        choices = ["mirror", "flip", "mirror_flip"]
+        if mode == "mirror":
+            """水平镜像（左右翻转）"""
+            self.unpackImage = np.fliplr(self.unpackImage)
+            self.BayerOrder = np.uint8(int(self.BayerOrder) ^ 1)
+        elif mode == "flip":
+            """垂直翻转（上下翻转）"""
+            self.unpackImage = np.flipud(self.unpackImage)
+            self.BayerOrder = np.uint8(int(self.BayerOrder) ^ 2)
+        elif mode == "mirror_flip":
+            """同时镜像和翻转（旋转 180 度）"""
+            self.unpackImage = np.rot90(self.unpackImage, 2)
+            self.BayerOrder = np.uint8(int(self.BayerOrder) ^ 3)
+        else:
+            print(f"{mode} is not a valid choice, must be one of {choices}")
+
+    def _checkVrf(self) -> None:
+        if self.IDString[0] == "V" and self.IDString[1] == "R" and self.IDString[2] == "F":
+            if self.Packed and self.VRFRevision >= 0x26:
+                self.dataSize = self._getPackVrfSize()
+            elif not self.Packed and self.BitDepth == 8:
+                self.dataSize = int(self.Width) * int(self.Height)  # raw8 size 待确认
+            else:
+                self.dataSize = int(self.Width) * int(self.Height) * 2
+
+            if self.dataSize != self.fileSize - self.metaSize:
+                print("VRF size wrong, please check it")
+                sys.exit()
+            if self.BayerOrder > 4:
+                print("VRF BayerOrder wrong, please check it")
+                sys.exit()
+        else:
+            print(f"VRF tag wrong, please check it {self.IDString}")
+            sys.exit()
+
+    def SaveVrf(self, fname: str) -> None:
+        data = np.ravel(self.unpackImage)
+        meta = self.GetMeta()
+        data = np.append(data, meta)
+        data.tofile(fname)
+        print(f"save {fname}")
+
+    def PrintVrf(self) -> None:
+        "Print Vrf info"
+        print("vrf Width: ", self.Width)
+        print("vrf Height: ", self.Height)
+        print("vrf BitDepth: ", self.BitDepth)
+        print("vrf BayerOrder(0:BGGR, 1:GBRG, 2:GRBG, 3:RGGB): ", self.BayerOrder)
+        print("vrf BLC10b: ", self.BLC10b)
+        print("vrf RGB_GAIN(Q7): ", self.AWBGainR, self.AWBGainG, self.AWBGainB)
+        print("vrf TGain(Q4): ", self.TGain)
+        print("vrf AGain(Q4): ", self.AGain)
+        print("vrf DrcGainDark(Q4): ", self.DrcGainDark)
+        print("vrf DrcGain(Q4): ", self.DrcGain)
+        print("")
+
+    def Plot(self) -> None:
+        "Plot Vrf Image"
+        if HAS_PLT:
+            import matplotlib.pyplot as plt
+
+            img = np.uint8(np.right_shift(self.unpackImage, int(self.BitDepth) - 8))
+            plt.imshow(img, cmap="gray")
+            plt.show()
+
+
+if __name__ == "__main__":
+    srcFile = r"tmp\random_noise10.vrf"
+    dstFile = r"tmp\2.vrf"
+    vrfObj = Vrf()
+    vrfObj.Read(srcFile)
+    vrfObj.AWBGainB = np.uint16(129)
+    vrfObj.AWBGainG = np.uint16(130)
+    vrfObj.AWBGainR = np.uint16(131)
+    vrfObj.TGain = np.uint16(64)
+    vrfObj.AGain = np.uint16(32)
+    vrfObj.BayerOrder = np.uint8(1)
+    vrfObj.DrcGain = np.uint8(20)
+    vrfObj.DrcGainDark = np.uint8(30)
+    vrfObj.ExpoTime_us = np.uint32(1000)
+    vrfObj.SaveVrf(dstFile)
+    # vrfObj.Plot()
+    print("convert ", srcFile, "to ", dstFile, "success.")