1.当前程序仅适用于CD3403芯片作为微处理器，且使用拼接通道0，通道内pipe数量为4的情况。

2.该情况可以通过查看指定调试信息查看
cat /proc/umap/avs
3.注意`-PATH`路径下必须要有当前的所有的LUT表文件，如果没有则会导致图像出现花屏，一般情况下请设置该路径为/etc/avs/
4.TODO：YAW ROLL PTICH 等参数的提升精度

4eye_2688x1520.cal

@@ -0,0 +1,8 @@
+Width:2688 Height:1520 Lens:0 Hfov:84
+Width:2688 Height:1520 Lens:0 Hfov:84
+Width:2688 Height:1520 Lens:0 Hfov:84
+Width:2688 Height:1520 Lens:0 Hfov:84
+C_0:0 C_1:0 C_2:0 A_th:3.14159 A_ph:0 H_0:1494.01 H_1:0 H_2:-1343.49 V_0:-3.4873 V_1:-1495.22 V_2:-763.82 O_th:3.14829 O_ph:369381 rho_0:0.00355143 rho_1:0.000115431 rho_2:-1.16644e-007 L:-0.447462 LAMBDA:-0.100111
+C_0:-17.4805 C_1:55.0139 C_2:37.8371 A_th:2.28924 A_ph:1.65177 H_0:1406.38 H_1:1162.75 H_2:-840.922 V_0:90.7086 V_1:-397.552 V_2:-1628.75 O_th:2.2903 O_ph:1.64956 rho_0:0.00355304 rho_1:0.000115984 rho_2:-1.06787e-007 L:-0.442603 LAMBDA:-0.0979488
+C_0:-22.9395 C_1:107.887 C_2:102.174 A_th:1.50745 A_ph:1.73275 H_0:1240.3 H_1:1553.16 H_2:293.92 V_0:74.0572 V_1:886.933 V_2:-1423.72 O_th:1.48348 O_ph:1.73447 rho_0:0.00347611 rho_1:0.000115104 rho_2:-1.26458e-007 L:-0.45064 LAMBDA:-0.101538
+C_0:-31.0358 C_1:56.3495 C_2:157.849 A_th:0.654923 A_ph:1.97648 H_0:1122.13 H_1:859.151 H_2:1428.18 V_0:-73.2644 V_1:1662.23 V_2:-225.251 O_th:0.677276 O_ph:1.97695 rho_0:0.00357901 rho_1:0.000115895 rho_2:-1.12405e-007 L:-0.443674 LAMBDA:-0.0984231

CMakeLists.txt

@@ -0,0 +1,31 @@
+cmake_minimum_required(VERSION 3.0)
+
+project(FineTuning C CXX)
+
+set(CMAKE_C_STANDARD 99)
+set(CMAKE_CXX_STANDARD 11)
+
+set(CMAKE_C_COMPILER aarch64-mix210-linux-gcc)
+set(CMAKE_CXX_COMPILER aarch64-mix210-linux-g++)
+
+set(SOURCE src/main.cpp src/avsFineTuningTool.cpp src/avsFineTuningTool.hpp src/avsUpdateTuning.cpp src/avsUpdateTuning.hpp)
+
+set(TARGET FineTuning)
+
+set(MPP_SDK /home/ebaina/ss928v100_sdk/SS928V100_SDK_V2.0.2.1/smp/a55_linux/mpp/out)
+set(RUNTIME_LIB /home/ebaina/ss928v100_sdk/aarch64-mix210-linux/runtime_lib/lib/)
+set(SVP_ACL_SDK ${CMAKE_CURRENT_SOURCE_DIR}/PublicLibrary/svp_npu)
+
+include_directories(${MPP_SDK}/include)
+include_directories(${SVP_ACL_SDK}/include)
+
+link_directories(${MPP_SDK}/lib)
+link_directories(${RUNTIME_LIB})
+link_directories(${SVP_ACL_SDK}/lib)
+
+add_executable(${TARGET} ${SOURCE})
+
+target_link_libraries(${TARGET} pthread m dl stdc++)
+target_link_libraries(${TARGET} libhiavslut.a libmpi.a libsecurec.a)
+target_link_libraries(${TARGET} libupvqe.a libdnvqe.a libVoiceEngine.a)
+

readme.md

@@ -0,0 +1,69 @@
+# FineTuing工具使用说明
+
+作者：康家琦
+时间：2025年1月9日
+
+该程序用于调整和更新AVS（全景视频拼接）参数，并且可以实时通过web或者VLC完成查看微调结果。以下是使用说明：
+
+~~~ad-info
+注意：本文档仅适用于AVS FineTuningTool程序.
+当前程序仅适用于CD3403芯片作为微处理器，且使用拼接通道0，通道内pipe数量为4的情况。
+该情况可以通过查看指定调试信息查看
+cat /proc/umap/avs
+~~~
+
+## 确保已经把程序目录下的文件准备完毕
+
+需要一个文件夹./calibration/，里面包含了cal文件，通过PQtool生成，生成的详细方法查看《嵌入式标定流程一览》。
+当前的cal文件仅支持一种名称：4eye_2688x1520.cal，如果名称与之不一致会导致无法正常使用.
+
+如果出现了提示无权限的情况，可以通过以下命令解决：
+```sh
+chmod +x ./avsFineTuningTool 
+```
+
+## 运行
+
+运行程序时需要提供以下参数：
+
+```sh
+./avsFineTuningTool -INDEX <value> -YAW <value> -PITCH <value> -ROLL <value> -OFFSETX <value> -OFFSETY <value> -DISTANCE <value> -PATH <value>
+```
+
+### 参数说明
+
+- `-INDEX <value>`: 设置索引值。
+- `-YAW <value>`: 设置偏航角度。
+- `-PITCH <value>`: 设置俯仰角度。
+- `-ROLL <value>`: 设置滚转角度。
+- `-OFFSETX <value>`: 设置X轴偏移量，需要注意的是某些情况下图像是经过倒放后进行投影的，需要考虑offsetx和offsety的转换。
+- `-OFFSETY <value>`: 设置Y轴偏移量。
+- `-DISTANCE <value>`: 设置拼接距离，值必须在0.5到10000之间。
+- `-PATH <value>`: 设置保存路径,保存index对应的LUT文件到指定路径，如果没有路径，则会保存到当前目录下。
+
+### 示例
+
+```sh
+./avsFineTuningTool -INDEX 1 -YAW 10.5 -PITCH 5.2 -ROLL 3.1 -OFFSETX 0.5 -OFFSETY 0.3 -DISTANCE 100 -PATH /path/to/save
+```
+
+### 注意事项
+
+- 确保所有参数都已正确提供，否则程序将输出错误信息并退出。
+- `-INDEX` 必须存在，用以指定需要生成的LUT文件, 参数的值必须在0到3之间。
+- `-DISTANCE` 参数的值必须在0.5到10000之间，否则程序将输出错误信息并退出。
+- 提供的参数值必须是整数，在后台会*100。
+- 最少提供一个INDEX加上任意一个参数，否则程序将输出错误信息并退出。
+
+## 功能
+
+程序将根据提供的参数进行以下操作：
+
+1. 设置拼接距离。
+2. 设置索引对应的偏航、俯仰和滚转角度。
+3. 设置索引对应的X轴和Y轴偏移量。
+4. 设置AVSP LUT保存路径。
+5. 生成LUT文件。
+6. 更新组属性。
+
+可以查看程序输出信息，以确认是否成功生成LUT文件。

src/avsFineTuningTool.cpp

@@ -0,0 +1,130 @@
+#include "avsFineTuningTool.hpp"
+#include "hi_mpi_sys.h"
+#include <iostream>
+#include <memory>
+#include <cstring>
+
+AvsFineTuningTool* AvsFineTuningTool::instance = nullptr;
+
+void AvsFineTuningTool::GenerateLutFile(int index)
+{
+    // Generate the LUT file
+    
+    ot_avs_lut_generate_input *lut_input = new ot_avs_lut_generate_input();
+    td_s32 i;   
+    td_s32 ret = 0;
+    
+
+    /*************************************************************************** */
+    // Create a new LUT mask
+    ot_avs_lut_mask *lut_mask = new ot_avs_lut_mask();
+
+    lut_mask->input_yuv_mask_flag = TD_FALSE; // input yuv mask flag
+    lut_mask->same_mask_flag      = TD_TRUE; // if this is true , all the mask define will be the same as the first one
+    for(i = 0; i < m_cameraNumber; i++) { 
+        lut_mask->mask_define[i].mask_shape      = OT_AVS_MASK_SHAPE_RECT; 
+        lut_mask->mask_define[i].offset_h        = 0; 
+        lut_mask->mask_define[i].offset_v        = 0; 
+        lut_mask->mask_define[i].half_major_axis = g_width / 2;   /* half 2 */ 
+        lut_mask->mask_define[i].half_minor_axis = g_height / 2;  /* half 2 */ 
+    }
+    std::cout << "mask param is done" << std::endl;
+
+    /*************************************************************************** */
+
+    
+    td_char out_lut[MAX_CAMERA_NUM][FILE_MAX_LEN]; /* 2 */ 
+    td_u64 lut_output[MAX_CAMERA_NUM]{0}; /* 2 */
+    FILE *lut_file = NULL; 
+
+    td_s32 cal_size =0;
+    //char calibrationPath[OT_AVS_CALIBRATION_FILE_LEN] = "./calibration/4eye_2688x1520.cal";
+    //std::memcpy(g_cal_file,calibrationPath,OT_AVS_CALIBRATION_FILE_LEN);
+    cal_size = getCalFileLong("./calibration/4eye_2688x1520.cal");
+    if(cal_size == 0) {
+        printf("getCalFileLong failed\n");
+        return;
+    }
+
+    ret = readCalFile("./calibration/4eye_2688x1520.cal",g_cal_file,cal_size);
+    if(ret != TD_SUCCESS) {
+        printf("readCalFile failed\n");
+        return;
+    }
+
+
+    ret = hi_mpi_sys_mmz_alloc(&g_avs_lut_addr, &m_avsLut, NULL, NULL, OT_AVS_LUT_SIZE*m_cameraNumber*sizeof(char));
+    if(ret != TD_SUCCESS) {
+        return;
+    }
+
+    std::cout << "LUT mmz alloc is done" << std::endl;
+
+    for (i = 0; i < m_cameraNumber; i++) { 
+        lut_output[i] = (td_u64)(td_uintptr_t)m_avsLut + i * OT_AVS_LUT_SIZE;
+    }
+
+    ret = hi_mpi_sys_mmz_alloc(&g_avs_mask_addr, &m_avsMask, NULL, NULL, g_width * g_height * sizeof(td_u16));
+    if(ret != TD_SUCCESS) {
+        return;
+    }
+    
+    for(i = 0; i < m_cameraNumber; i++) { 
+        lut_mask->mask_addr[i] = (td_u64)(td_uintptr_t)m_avsMask;
+    }
+
+    std::cout << "Mask mmz alloc is done" << std::endl;
+
+    /*************************************************************************** */
+    // Create a new LUT fine tuning
+    
+    m_fine_tuning_cfg.fine_tuning_en = TD_TRUE; // trun on fine tuning
+    for(i = 0; i < m_cameraNumber; i++) { 
+        if(i == index)
+            m_fine_tuning_cfg.adjust[i].adjust_en = TD_TRUE;
+        else
+            m_fine_tuning_cfg.adjust[i].adjust_en = TD_FALSE; 
+        m_fine_tuning_cfg.adjust[i].pitch     = m_finePackages[i].pitch * 100; 
+        m_fine_tuning_cfg.adjust[i].yaw       = m_finePackages[i].yaw * 100; 
+        m_fine_tuning_cfg.adjust[i].roll      = m_finePackages[i].roll* 100; 
+        m_fine_tuning_cfg.adjust[i].offset_x  = m_finePackages[i].offsetX * 100; 
+        m_fine_tuning_cfg.adjust[i].offset_y  = m_finePackages[i].offsetY * 100;
+    }
+    lut_input->fine_tuning_cfg                = m_fine_tuning_cfg; 
+    lut_input->lut_accuracy                   = OT_AVS_LUT_ACCURACY_HIGH;  // accuracy configure
+    lut_input->type                           = OT_AVS_TYPE_AVSP; // use AVSP
+    lut_input->stitch_distance                = m_StitchingDistance; // set stitching distance
+    lut_input->mask                           = lut_mask; // set mask
+    lut_input->file_input_addr                = (td_u64)(td_uintptr_t)g_cal_file; // set cal file address 
+
+    /*************************************************************************** */
+
+    ot_avs_status status;
+
+    status = hi_mpi_avs_lut_generate(lut_input,lut_output);
+
+    if(status != OT_AVS_STATUS_OK) {
+        printf("hi_mpi_avs_lut_generate failed\n");
+        return;
+    }
+
+    writeLutFile(index,m_SaveAVSPPath,OT_AVS_LUT_SIZE,lut_output);
+}
+
+void AvsFineTuningTool::FreeResources()
+{
+    td_s32 ret = TD_SUCCESS;
+    if (g_avs_lut_addr != 0) { 
+        ret = hi_mpi_sys_mmz_free(g_avs_lut_addr, NULL);
+        if(ret != TD_SUCCESS) {
+            printf("hi_mpi_sys_mmz_free failed\n");}
+    }
+    if(g_avs_mask_addr != 0)
+    {
+        ret = hi_mpi_sys_mmz_free(g_avs_mask_addr, NULL);
+        if(ret != TD_SUCCESS) {
+            printf("hi_mpi_sys_mmz_free failed\n");}
+    }
+}
+
+

src/avsFineTuningTool.hpp

@@ -0,0 +1,161 @@
+#include <hi_mpi_avs_lut_generate.h>
+#include <ot_common_avs.h>
+#include <ot_common_avs_lut_generate.h>
+#include <fstream>
+#include <vector>
+#include <iostream>
+
+static td_phys_addr_t  g_avs_lut_addr = 0; 
+static td_phys_addr_t  g_avs_mask_addr = 0; 
+static td_char g_cal_file[OT_AVS_CALIBRATION_FILE_LEN]; 
+static td_u32 g_width = 2688;
+static td_u32 g_height = 1520;
+
+#define FILE_MAX_LEN 256
+#define MAX_CAMERA_NUM 8
+
+typedef struct fine_package{
+    int cameraIndex;
+    int yaw;
+    int pitch;
+    int roll;
+    int offsetX;
+    int offsetY;
+}FINE_PACKAGE, *LPFINE_PACKAGE;
+
+class AvsFineTuningTool {
+public:
+    static AvsFineTuningTool* getInstance() {
+        if (instance == nullptr) {
+            instance = new AvsFineTuningTool(4);
+        }
+        return instance;
+    }
+
+    // set the yaw pitch roll that is concerned with the camera
+    void SetYaw(int index, int yaw){m_finePackages[index].yaw = yaw;}
+    void SetPitch(int index,int pitch){m_finePackages[index].pitch = pitch;}
+    void SetRoll(int index,int roll){m_finePackages[index].roll = roll;}
+    void SetOffsetX(int index,int offsetX){m_finePackages[index].offsetX = offsetX;}
+    void SetOffsetY(int index,int offsetY){m_finePackages[index].offsetY = offsetY;}
+
+    void setStitchingDistance(float distance) {m_StitchingDistance = distance;}
+
+    void setAVSPLUTSavePath(std::string path){m_SaveAVSPPath = path;}
+
+    // get the yaw pitch roll that is concerned with the camera
+    int GetYaw(int index){return m_finePackages[index].yaw;}
+    int GetPitch(int index){return m_finePackages[index].pitch;}
+    int GetRoll(int index){return m_finePackages[index].roll;}
+    int GetOffsetX(int index){return m_finePackages[index].offsetX;}
+    int GetOffsetY(int index){return m_finePackages[index].offsetY;}
+
+    // generate the LUT file
+    void GenerateLutFile(int index);
+
+    // Delete copy constructor and assignment operator to prevent copies
+    AvsFineTuningTool(const AvsFineTuningTool&) = delete;
+    AvsFineTuningTool& operator=(const AvsFineTuningTool&) = delete;
+
+    static hi_u32 getCalFileLong(const hi_char* calFile) {
+        FILE* fp;
+        hi_u32 fileLen = 0;
+        hi_s32 ret = 0;
+
+        fp = fopen(calFile, "rb");
+        if (fp == NULL) {
+            printf("open file %s failed\n", calFile);
+            return 0;
+        }
+        ret = fseek(fp, 0, SEEK_END);
+        if (ret != 0) {
+            printf("fseek failed\n");
+            fclose(fp);
+            return 0;
+        }
+
+        fileLen = ftell(fp);
+
+        fclose(fp);
+        
+        return fileLen;
+    }
+
+    static hi_s32 readCalFile(const hi_char* calFile, hi_char* addr,hi_u32 size) {
+        FILE* fp;
+        hi_s32 readByte = 0;
+
+        fp = fopen(calFile, "rb");
+        if(fp == NULL) {
+            printf("open file %s failed\n", calFile);
+            return HI_FAILURE;
+        }
+
+        readByte = fread(addr, 1, size, fp);
+        if(readByte != size) {
+            printf("read file failed\n");
+            fclose(fp);
+            return HI_FAILURE;
+        }
+
+        fclose(fp);
+
+        return HI_SUCCESS;
+
+    }
+
+    static hi_s32 writeLutFile(int index,std::string path,td_u32 length,td_u64 lut_output_addr[])
+    {
+        td_s32 i;
+        td_char out_lut[MAX_CAMERA_NUM][FILE_MAX_LEN];
+        FILE *lut_file = NULL;
+
+        for(i = 0 ; i < MAX_CAMERA_NUM; i++) {
+            if(i != index)
+                continue; 
+            std::string curPath;
+            snprintf(out_lut[i], FILE_MAX_LEN, "avsp_mesh_out_%d.bin", i);
+            curPath = path + out_lut[i];
+            if(lut_output_addr[i] == 0) {
+                continue;
+            }
+            lut_file = fopen(curPath.c_str(), "wb");
+            if(lut_file == NULL) {
+                return HI_FAILURE;
+            }
+            fwrite((td_char*)(td_uintptr_t)lut_output_addr[i], length, 1, lut_file);
+            fclose(lut_file);
+        }
+    }
+
+    // Add your fine-tuning methods here
+private:
+    AvsFineTuningTool(int camera) {
+        m_cameraNumber = camera;
+        m_finePackages.resize(camera);
+    }
+
+    ~AvsFineTuningTool() {
+        // Clean up your tool here
+    }
+
+    // free the resources
+    void FreeResources();
+
+private:
+    static AvsFineTuningTool* instance;
+    std::vector<FINE_PACKAGE> m_finePackages;
+    ot_avs_fine_tuning  m_fine_tuning_cfg;
+    int m_cameraNumber;
+
+    float m_StitchingDistance{2};
+
+    // generate resouces
+    td_void* m_avsMask;
+    td_void* m_avsLut;
+
+    // save path 
+    std::string m_SaveAVSPPath;
+
+};
+

src/avsUpdateTuning.cpp

@@ -0,0 +1,57 @@
+#include "avsUpdateTuning.hpp"
+#include <iostream>
+
+
+void AvsUpdateTuning::readLutFile(int index,std::string path, hi_u32 length, hi_u64 lut_output_addr[])
+{
+    FILE *fp;
+    hi_s32 readByte = 0;
+
+    std::string curPath;
+    curPath = path + AVSP_LUT_NAME + std::to_string(index) + ".bin";
+
+    fp = fopen(curPath.c_str(), "rb");
+    if(fp == NULL) {
+        printf("open file %s failed\n", curPath.c_str());
+        return;
+    }
+
+    // address of the LUT offset 
+    hi_u64 readAddr= lut_output_addr[index];
+
+    readByte = fread((hi_char*)readAddr, 1, length, fp);
+
+    if(readByte != length) {
+        printf("read file failed\n");
+        fclose(fp);
+        return;
+    }
+
+    fclose(fp);
+
+    return;
+    
+}
+
+hi_s32 AvsUpdateTuning::updateGrpAttr()
+{
+    hi_s32 ret = 0;
+
+    readLutFile(0,m_strPath,OT_AVS_LUT_SIZE,m_LutArray);
+    readLutFile(1,m_strPath,OT_AVS_LUT_SIZE,m_LutArray);
+    readLutFile(2,m_strPath,OT_AVS_LUT_SIZE,m_LutArray);
+    readLutFile(3,m_strPath,OT_AVS_LUT_SIZE,m_LutArray);
+    
+    for(int i = 0; i < m_avs_pipe_num; i++) {
+        m_avs_grp_attr.lut.phys_addr[i] = m_avs_lut_addr + i * OT_AVS_LUT_SIZE;
+    }
+
+    ret = hi_mpi_avs_set_grp_attr(m_avs_grp_index, &m_avs_grp_attr);
+    if(ret != HI_SUCCESS) {
+        return HI_FAILURE;
+    }
+
+    std::cout << "Update LUT address done" << std::endl;
+
+    return HI_SUCCESS;
+}

src/avsUpdateTuning.hpp

@@ -0,0 +1,68 @@
+#ifndef __AVS_UPDATE_TUNING_HPP__
+#define __AVS_UPDATE_TUNING_HPP__
+
+#include <hi_mpi_avs_lut_generate.h>
+#include <ot_common_avs.h>
+#include <ot_common_avs_lut_generate.h>
+#include <hi_common_avs.h>
+#include <hi_mpi_avs.h>
+#include <hi_common.h>
+#include <hi_mpi_sys.h>
+#include <string>
+#include <stdexcept>
+
+#define AVSP_LUT_NAME "avsp_mesh_out_"
+
+class AvsUpdateTuning {
+public:
+    AvsUpdateTuning(hi_avs_grp index) {
+        m_avs_grp_index = index;
+
+        hi_s32 ret = 0;
+
+        ret = hi_mpi_avs_get_grp_attr(m_avs_grp_index, &m_avs_grp_attr);
+
+        if(ret != HI_SUCCESS) {
+            printf("hi_mpi_avs_set_grp_attr failed\n");
+            throw std::runtime_error("hi_mpi_avs_set_grp_attr failed");
+        }
+
+        m_avs_pipe_num = m_avs_grp_attr.pipe_num;
+
+        ret = hi_mpi_sys_mmz_alloc(&m_avs_lut_addr, &m_avsLut, "avs_lut", NULL, OT_AVS_LUT_SIZE * sizeof(char) * m_avs_pipe_num);
+
+        if (ret != HI_SUCCESS) {
+            printf("hi_mpi_sys_mmz_alloc failed\n");
+            throw std::runtime_error("hi_mpi_sys_mmz_alloc failed");
+        }
+
+        for(int i = 0; i < m_avs_pipe_num; i++) {
+            m_LutArray[i] = (hi_u64)(hi_uintptr_t)m_avsLut + i * OT_AVS_LUT_SIZE;
+        }
+
+    }
+
+    void setPath(std::string path) {
+        m_strPath = path;
+    }
+
+    void readLutFile(int index,std::string path, hi_u32 length, hi_u64 lut_output_addr[]);
+
+    hi_s32 updateGrpAttr();
+
+private:
+    hi_avs_grp m_avs_grp_index;
+    hi_avs_grp_attr m_avs_grp_attr;
+
+    hi_u64 m_LutArray[OT_AVS_MAX_CAMERA_NUM];
+
+    std::string m_strPath;
+
+    hi_u32 m_avs_pipe_num;
+
+    hi_phys_addr_t m_avs_lut_addr;
+    hi_void* m_avsLut;
+
+};
+
+#endif // __AVS_UPDATE_TUNING_HPP__

src/main.cpp

@@ -0,0 +1,80 @@
+#include "avsFineTuningTool.hpp"
+#include "avsUpdateTuning.hpp"
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <algorithm>
+
+
+int main(int argc, char* argv[]) {
+
+    std::cout << "Usage: " << argv[0] << " -INDEX <value> -YAW <value> -PITCH <value> -ROLL <value> -OFFSETX <value> -OFFSETY <value> -DISTANCE <value> -PATH <value>" << std::endl;
+
+    if (argc < 2) {
+        std::cerr << "No parameters provided" << std::endl;
+        return 1;
+    }
+
+    double index = 0, yaw = 0, pitch = 0, roll = 0, offsetX = 0, offsetY = 0, distance = 0;
+    std::string path;
+    for (int i = 1; i < argc; i += 2) {
+        std::string arg = argv[i];
+        std::transform(arg.begin(), arg.end(), arg.begin(), ::toupper);
+        if (arg == "-INDEX") {
+            index = std::stoi(argv[i + 1]);
+        } else if (arg == "-YAW") {
+            yaw = std::stod(argv[i + 1]);
+        } else if (arg == "-PITCH") {
+            pitch = std::stod(argv[i + 1]);
+        } else if (arg == "-ROLL") {
+            roll = std::stod(argv[i + 1]);
+        } else if (arg == "-OFFSETX") {
+            offsetX = std::stod(argv[i + 1]);
+        } else if (arg == "-OFFSETY") {
+            offsetY = std::stod(argv[i + 1]);
+        } else if (arg == "-DISTANCE") {
+            distance = std::stod(argv[i + 1]);
+            if(distance <= 0.5 || distance >= 50000){
+                std::cerr << "Distance value must be between 0.5 and 10000" << std::endl;
+                return -1;
+            }
+        } else if(arg == "-PATH"){
+            path = argv[i + 1];
+            std::cout << "SAVE AVSP PATH: " << path << std::endl;
+        }else {
+            std::cerr << "Unknown parameter: " << arg << std::endl;
+            return -1;
+        }
+    }
+
+    std::cout << "INDEX: " << index << std::endl;
+    std::cout << "YAW: " << yaw << std::endl;
+    std::cout << "PITCH: " << pitch << std::endl;
+    std::cout << "ROLL: " << roll << std::endl;
+    std::cout << "OFFSETX: " << offsetX << std::endl;
+    std::cout << "OFFSETY: " << offsetY << std::endl;
+    std::cout << "DISTANCE: " << distance << std::endl;
+
+    // Further processing with the parsed parameters
+
+    AvsFineTuningTool* avsFineTuningTool = AvsFineTuningTool::getInstance();
+
+    avsFineTuningTool->setStitchingDistance(distance);
+    avsFineTuningTool->SetYaw(index, yaw);
+    avsFineTuningTool->SetPitch(index, pitch);
+    avsFineTuningTool->SetRoll(index, roll);
+    avsFineTuningTool->SetOffsetX(index, offsetX);
+    avsFineTuningTool->SetOffsetY(index, offsetY);
+    avsFineTuningTool->setAVSPLUTSavePath(path);
+
+    avsFineTuningTool->GenerateLutFile(index);
+
+    AvsUpdateTuning avsUpdateTuning(0);
+
+    avsUpdateTuning.setPath(path);
+
+    avsUpdateTuning.updateGrpAttr();
+
+    return 0;
+
+}