microproduct/soilSalinity/pspHAAlphaDecomposition.py

# -*- coding: UTF-8 -*-
"""
@Project:__init__.py
@File:pspHAAlphaDecomposition.py
@Function: Cloude-Pottier eigenvector/eigenvalue based decomposition of a 3x3 coherency matrix [T3]
           (Averaging using a sliding window)
           V1.0.1:（1）可选分解特征；（2）bin转tif格式
@Contact:
@Author:SHJ
@Date:2021/9/24 9:06
@Version:1.0.1
"""

import os
import shutil
import subprocess
import struct
import numpy as np
import glob
from PIL import Image
import logging
logger = logging.getLogger("mylog")
import multiprocessing

class PspHAAlphaDecomposition:
    """
    调用polsarpro4.2.0的Cloude-Pottier极化分解
    """
    def __init__(self,normalization = False):
        self.__normalization = normalization #是否做归一化
        self.__res_h_a_alpha_decomposition_T3 = {}
        self.__res_h_a_alpha_eigenvalue_set_T3 = {}
        self.__res_h_a_alpha_eigenvector_set_T3 = {}
        pass

    def api_creat_h_a_alpha_features_single_process(self, h_a_alpha_out_dir,
                                     h_a_alpha_decomposition_T3_path, h_a_alpha_eigenvalue_set_T3_path,
                                     h_a_alpha_eigenvector_set_T3_path, polsarpro_in_dir,is_trans_to_tif=True, is_read_to_dic=False):
        """
        对porsarpro格式T3矩阵做Cloude-Pottier分解(h_a_alpha_decomposition、h_a_alpha_eigenvalue_set 和 h_a_alpha_eigenvector_set)
        :param h_a_alpha_out_dir : 输出h_a_alpha二进制数据的目录
        :param h_a_alpha_decomposition_T3_path: haalphadecompositionT3.exe路径
        :param h_a_alpha_eigenvalue_set_T3_path: h_a_alpha_eigenvalue_set_T3.exe路径
        :param h_a_alpha_eigenvector_set_T3_path: h_a_alpha_eigenvector_set_T3.exe路径
        :param polsarpro_in_dir:输入porsarpro格式T3矩阵目录，包含.bin,.config
        """
        h_a_alpha_features ={}
        h_a_alpha_features.update(self.api_h_a_alpha_decomposition_T3(h_a_alpha_out_dir, h_a_alpha_decomposition_T3_path, polsarpro_in_dir, is_trans_to_tif,is_read_to_dic, *(1, 1, 1, 1, 1, 1, 1, 1, 1)))
        logger.info("run h_a_alpha_decomposition_T3 success!")
        logger.info('progress bar: 40%')
        h_a_alpha_features.update(self.api_h_a_alpha_eigenvalue_set_T3(h_a_alpha_out_dir, h_a_alpha_eigenvalue_set_T3_path, polsarpro_in_dir, is_trans_to_tif, is_read_to_dic, *(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1)))
        logger.info("run h_a_alpha_eigenvalue_set_T3 success!")
        logger.info('progress bar: 60%')
        h_a_alpha_features.update(self.api_h_a_alpha_eigenvector_set_T3(h_a_alpha_out_dir, h_a_alpha_eigenvector_set_T3_path, polsarpro_in_dir, is_trans_to_tif,is_read_to_dic, *(1, 1, 1, 1, 1)))
        logger.info("run h_a_alpha_eigenvector_set_T3 success!")
        logger.info('progress bar: 80%')
        if is_trans_to_tif:
            self.api_trans_T3_to_tif(h_a_alpha_out_dir, polsarpro_in_dir)
        if is_read_to_dic:
            h_a_alpha_features.update(self.api_read_T3_matrix(polsarpro_in_dir))
        return h_a_alpha_features

    def api_creat_h_a_alpha_features(self, h_a_alpha_out_dir,
                                     h_a_alpha_decomposition_T3_path, h_a_alpha_eigenvalue_set_T3_path,
                                     h_a_alpha_eigenvector_set_T3_path, polsarpro_in_dir,is_trans_to_tif=True, is_read_to_dic=False):
        """
        对porsarpro格式T3矩阵做Cloude-Pottier分解(h_a_alpha_decomposition、h_a_alpha_eigenvalue_set 和 h_a_alpha_eigenvector_set)
        :param h_a_alpha_out_dir : 输出h_a_alpha二进制数据的目录
        :param h_a_alpha_decomposition_T3_path: haalphadecompositionT3.exe路径
        :param h_a_alpha_eigenvalue_set_T3_path: h_a_alpha_eigenvalue_set_T3.exe路径
        :param h_a_alpha_eigenvector_set_T3_path: h_a_alpha_eigenvector_set_T3.exe路径
        :param polsarpro_in_dir:输入porsarpro格式T3矩阵目录，包含.bin,.config
        """

        pool = multiprocessing.Pool(processes=3)
        pl = []

        logger.info("run h_a_alpha_decomposition_T3!")
        pl.append(pool.apply_async(self.api_h_a_alpha_decomposition_T3, (h_a_alpha_out_dir, h_a_alpha_decomposition_T3_path, polsarpro_in_dir, is_trans_to_tif, is_read_to_dic, *(1, 1, 1, 1, 1, 1, 1, 1, 1))))
        logger.info("run h_a_alpha_eigenvalue_set_T3!")
        pl.append(pool.apply_async(self.api_h_a_alpha_eigenvalue_set_T3, (h_a_alpha_out_dir, h_a_alpha_eigenvalue_set_T3_path, polsarpro_in_dir, is_trans_to_tif, is_read_to_dic, *(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1))))
        logger.info("run h_a_alpha_eigenvector_set_T3!")
        pl.append(pool.apply_async(self.api_h_a_alpha_eigenvector_set_T3, (h_a_alpha_out_dir, h_a_alpha_eigenvector_set_T3_path, polsarpro_in_dir, is_trans_to_tif,is_read_to_dic, *(1, 1, 1, 1, 1))))

        pool.close()
        pool.join()
        logger.info(pl)
        logger.info('progress bar: 60%')

        h_a_alpha_features ={}
        h_a_alpha_features.update(self.__res_h_a_alpha_decomposition_T3)
        logger.info("run h_a_alpha_decomposition_T3 success!")
        h_a_alpha_features.update(self.__res_h_a_alpha_eigenvalue_set_T3)
        logger.info("run h_a_alpha_eigenvalue_set_T3 success!")
        h_a_alpha_features.update(self.__res_h_a_alpha_eigenvector_set_T3)
        logger.info("run h_a_alpha_eigenvector_set_T3 success!")
        if is_trans_to_tif:
            self.api_trans_T3_to_tif(h_a_alpha_out_dir, polsarpro_in_dir)
        if is_read_to_dic:
            h_a_alpha_features.update(self.api_read_T3_matrix(polsarpro_in_dir))
        return h_a_alpha_features

    def api_h_a_alpha_decomposition_T3(self, h_a_alpha_out_dir, h_a_alpha_decomposition_T3_path, polsarpro_in_dir, is_trans_to_tif=True, is_read_to_dic=False, *args):
        """
        对porsarpro格式T3矩阵做Cloude-Pottier分解（H-A-Alpha分解）
        :param h_a_alpha_out_dir : 输出h_a_alpha二进制数据的目录
        :param h_a_alpha_decomposition_T3_path: haalphadecompositionT3.exe路径
        :param polsarpro_in_dir:输入porsarpro格式T3矩阵目录，包含.bin,.config
        :param is_trans_to_tif:分解特征是否转换为tif
        :param is_read_to_dic:分解特征是否以字典输出
        :param *args:9个可选分解特征(alpbetdelgam,Lambda,alpha,entropy,anisotropy,
                    CombHA,CombH1mA,Comb1mHA,Comb1mH1mA),不输出:0，输出:1
        :return : 包含分解特征的字典
        """
        if not os.path.exists(h_a_alpha_out_dir):
            os.makedirs(h_a_alpha_out_dir)
        self.__h_a_alpha_decomposition_T3(h_a_alpha_out_dir, h_a_alpha_decomposition_T3_path, polsarpro_in_dir, *args)
        name_list = ['entropy', 'anisotropy', 'alpha', 'beta', 'delta', 'gamma', 'lambda',
                     'combination_1mH1mA', 'combination_1mHA', 'combination_H1mA', 'combination_HA']
        if is_trans_to_tif:
            self.__write_haalpha_to_tif(h_a_alpha_out_dir, h_a_alpha_out_dir, name_list)

        if is_read_to_dic:
            self.__res_h_a_alpha_decomposition_T3 = self.__read_haalpha(h_a_alpha_out_dir, name_list)
            return self.__res_h_a_alpha_decomposition_T3
        else:
            return {}

    def api_h_a_alpha_eigenvalue_set_T3(self, h_a_alpha_out_dir, h_a_alpha_eigenvalue_set_T3_path, polsarpro_in_dir, is_trans_to_tif=True, is_read_to_dic=False, *args):

        """
        Cloude-Pottier eigenvalue based decomposition of a coherency matrix
        :param h_a_alpha_out_dir :  Cloude-Pottier eigenvalue
        :param h_a_alpha_eigenvalue_set_T3_path: h_a_alpha_eigenvalue_set_T3.exe路径
        :param polsarpro_in_dir:输入porsarpro格式T3矩阵目录，包含.bin,.config
        :param is_trans_to_tif:分解特征是否转换为tif
        :param is_read_to_dic:分解特征是否以字典输出
        :param *args:9个可选分解特征(alpbetdelgam,Lambda,alpha,entropy,anisotropy,
                    CombHA,CombH1mA,Comb1mHA,Comb1mH1mA),不输出:0，输出:1
        :return : 包含分解特征的字典
        """
        if not os.path.exists(h_a_alpha_out_dir):
            os.makedirs(h_a_alpha_out_dir)
        self.__h_a_alpha_eigenvalue_set_T3(h_a_alpha_out_dir, h_a_alpha_eigenvalue_set_T3_path, polsarpro_in_dir, *args)
        name_list = ['anisotropy', 'anisotropy_lueneburg', 'anisotropy12', 'asymetry', 'derd', 'derd_norm', 'entropy_shannon',
                     'entropy_shannon_I', 'entropy_shannon_I_norm', 'entropy_shannon_norm', 'entropy_shannon_P',
                     'entropy_shannon_P_norm', 'l1', 'l2', 'l3', 'p1', 'p2', 'p3', 'pedestal', 'polarisation_fraction',
                     'rvi', 'serd', 'serd_norm']
        if is_trans_to_tif:
            self.__write_haalpha_to_tif(h_a_alpha_out_dir, h_a_alpha_out_dir, name_list)

        if is_read_to_dic:
            self.__res_h_a_alpha_eigenvalue_set_T3 = self.__read_haalpha(h_a_alpha_out_dir, name_list)
            return self.__res_h_a_alpha_eigenvalue_set_T3
        else:
            return {}

    def api_h_a_alpha_eigenvector_set_T3(self, h_a_alpha_out_dir, h_a_alpha_eigenvector_set_T3_path, polsarpro_in_dir, is_trans_to_tif=True, is_read_to_dic=False, *args):

        """
        Cloude-Pottier eigenvector based decomposition of a coherency matrix
        :param h_a_alpha_out_dir :   Cloude-Pottier eigenvector
        :param h_a_alpha_eigenvector_set_T3_path: h_a_alpha_eigenvector_set_T3.exe路径
        :param polsarpro_in_dir:输入porsarpro格式T3矩阵目录，包含.bin,.config
                :param is_trans_to_tif:分解特征是否转换为tif
        :param is_read_to_dic:分解特征是否以字典输出
        :param *args:9个可选分解特征(alpbetdelgam,Lambda,alpha,entropy,anisotropy,
                    CombHA,CombH1mA,Comb1mHA,Comb1mH1mA),不输出:0，输出:1
        :return : 包含分解特征的字典
        """
        if not os.path.exists(h_a_alpha_out_dir):
            os.makedirs(h_a_alpha_out_dir)
        self.__h_a_alpha_eigenvector_set_T3(h_a_alpha_out_dir, h_a_alpha_eigenvector_set_T3_path, polsarpro_in_dir, *args)
        name_list = ['alpha', 'alpha1', 'alpha2', 'alpha3',
                     'beta', 'beta1', 'beta2', 'beta3',
                     'delta', 'delta1', 'delta2', 'delta3',
                     'gamma', 'gamma1', 'gamma2', 'gamma3']
        if is_trans_to_tif:
            self.__write_haalpha_to_tif(h_a_alpha_out_dir, h_a_alpha_out_dir, name_list)

        if is_read_to_dic:
            self.__res_h_a_alpha_eigenvector_set_T3 = self.__read_haalpha(h_a_alpha_out_dir, name_list)
            return self.__res_h_a_alpha_eigenvector_set_T3
        else:
            return {}

    def api_read_T3_matrix(self,polsarpro_T3_dir):
        """
        读取T3矩阵，转换字典
        :param polsarpro_in_dir:输入porsarpro格式T3矩阵目录，包含.bin,.config
        :return : 包含T3矩阵的字典
        """
        name_list = ['T11', 'T12_imag', 'T12_real',
                     'T22', 'T13_imag', 'T13_real',
                     'T33', 'T23_imag', 'T23_real']
        return self.__read_haalpha(polsarpro_T3_dir, name_list)

    def api_trans_T3_to_tif(self, out_tif_dir, polsarpro_T3_dir):
        """
        将T3矩阵从bin格式转换为tif格式
        :param out_tif_dir:保存路径
        :param polsarpro_in_dir:输入porsarpro格式T3矩阵目录，包含.bin,.config
        """
        name_list = ['T11', 'T12_imag', 'T12_real',
                     'T22', 'T13_imag', 'T13_real',
                     'T33', 'T23_imag', 'T23_real']
        self.__write_haalpha_to_tif(out_tif_dir, polsarpro_T3_dir, name_list)

    @staticmethod
    def __h_a_alpha_decomposition_T3(h_a_alpha_out_dir, h_a_alpha_decomposition_T3_path, polsarpro_in_dir, *args):
        """
        对porsarpro格式T3矩阵做Cloude-Pottier分解（H-A-Alpha分解）
        :param h_a_alpha_out_dir : 输出h_a_alpha二进制数据的目录
        :param h_a_alpha_decomposition_T3_path: haalphadecompositionT3.exe路径
        :param polsarpro_in_dir:输入porsarpro格式T3矩阵目录，包含.bin,.config
        :param *args:9个可选输出变量(alpbetdelgam,Lambda,alpha,entropy,anisotropy,
                    CombHA,CombH1mA,Comb1mHA,Comb1mH1mA),不输出:0，输出:1
        """
        if not os.path.exists(h_a_alpha_decomposition_T3_path):
            raise Exception(h_a_alpha_decomposition_T3_path +' is not exists!')

        NwinFilter = 1
        offsetRow = 0
        offsetCol = 0

        config_path = os.path.join(polsarpro_in_dir, 'config.txt')
        config = open(config_path, 'r').read().split('\n', -1)

        numRow = int(config[1])
        numCol = int(config[4])

        alpbetdelgam = int(args[0])
        Lambda = int(args[1])
        alpha = int(args[2])
        entropy = int(args[3])
        anisotropy = int(args[4])

        CombHA = int(args[5])
        CombH1mA = int(args[6])
        Comb1mHA = int(args[7])
        Comb1mH1mA = int(args[8])

        para_list = [h_a_alpha_decomposition_T3_path, polsarpro_in_dir, h_a_alpha_out_dir,
                     str(NwinFilter), str(offsetRow), str(offsetCol), str(numRow), str(numCol),
                     str(alpbetdelgam), str(Lambda), str(alpha), str(entropy), str(anisotropy),
                     str(CombHA), str(CombH1mA), str(Comb1mHA), str(Comb1mH1mA)]
        cmd = ' '.join(para_list)
        logger.info(cmd)
        result_tuple = subprocess.getstatusoutput(cmd)
        if result_tuple[0] != 1 or result_tuple[1].find('error') != -1 or result_tuple[1].find('Could not open') != -1:
            raise Exception(result_tuple[1])
        shutil.copyfile(config_path, os.path.join(h_a_alpha_out_dir, 'config.txt'))

    @staticmethod
    def __h_a_alpha_eigenvalue_set_T3(h_a_alpha_out_dir, h_a_alpha_eigenvalue_set_T3_path, polsarpro_in_dir, *args):

        """
        Cloude-Pottier eigenvalue based decomposition of a coherency matrix
        :param h_a_alpha_out_dir :  Cloude-Pottier eigenvalue
        :param h_a_alpha_eigenvalue_set_T3_path: h_a_alpha_eigenvalue_set_T3.exe路径
        :param polsarpro_in_dir:输入porsarpro格式T3矩阵目录，包含.bin,.config
        :param *args:11个可选输出变量(eigen123,proba123,anisotropy,anisotropy12,asymetry,
                        polarisation_fraction,erd,rvi,pedestal,shannon,lueneburg),不输出：0，输出：1
        """
        if not os.path.exists(h_a_alpha_eigenvalue_set_T3_path):
            raise Exception(h_a_alpha_eigenvalue_set_T3_path +' is not exists!')
        NwinFilter = 1
        offsetRow = 0
        offsetCol = 0

        config_path = os.path.join(polsarpro_in_dir, 'config.txt')
        config = open(config_path, 'r').read().split('\n', -1)

        numRow = int(config[1])
        numCol = int(config[4])

        eigen123 = int(args[0])
        proba123 = int(args[1])
        anisotropy = int(args[2])
        anisotropy12 = int(args[3])
        asymetry = int(args[4])
        polarisation_fraction = int(args[5])
        erd = int(args[6])
        rvi = int(args[7])
        pedestal = int(args[8])
        shannon = int(args[9])
        lueneburg = int(args[10])

        para_list = [h_a_alpha_eigenvalue_set_T3_path, polsarpro_in_dir, h_a_alpha_out_dir,
                     str(NwinFilter), str(offsetRow), str(offsetCol), str(numRow), str(numCol),
                     str(eigen123), str(proba123), str(anisotropy), str(anisotropy12), str(asymetry),
                     str(polarisation_fraction), str(erd), str(rvi), str(pedestal),
                     str(shannon), str(lueneburg)]
        cmd = ' '.join(para_list)
        logger.info(cmd)
        result_tuple = subprocess.getstatusoutput(cmd)
        if result_tuple[0] != 1 or result_tuple[1].find('error') != -1 or result_tuple[1].find('Could not open') != -1:
            raise Exception(result_tuple[1])
        shutil.copyfile(config_path, os.path.join(h_a_alpha_out_dir, 'config.txt'))

    @staticmethod
    def __h_a_alpha_eigenvector_set_T3(h_a_alpha_out_dir, h_a_alpha_eigenvector_set_T3_path, polsarpro_in_dir, *args):

        """
        Cloude-Pottier eigenvector based decomposition of a coherency matrix
        :param h_a_alpha_out_dir :  Cloude-Pottier eigenvector
        :param h_a_alpha_eigenvector_set_T3_set_T3_path: h_a_alpha_eigenvector_set_T3.exe路径
        :param polsarpro_in_dir:输入porsarpro格式T3矩阵目录，包含.bin,.config
        :param *args:5个可选输出变量(alpha123,beta123,delta123,gamma123,alpbetdelgam),不输出：0，输出：1
        """
        if not os.path.exists(h_a_alpha_eigenvector_set_T3_path):
            raise Exception(h_a_alpha_eigenvector_set_T3_path +' is not exists!')
        NwinFilter = 1
        offsetRow = 0
        offsetCol = 0

        config_path = os.path.join(polsarpro_in_dir, 'config.txt')
        config = open(config_path, 'r').read().split('\n', -1)

        numRow = int(config[1])
        numCol = int(config[4])

        alpha123 = int(args[0])
        beta123 = int(args[1])
        delta123 = int(args[2])
        gamma123 = int(args[3])
        alpbetdelgam = int(args[4])

        para_list = [h_a_alpha_eigenvector_set_T3_path, polsarpro_in_dir, h_a_alpha_out_dir,
                     str(NwinFilter), str(offsetRow), str(offsetCol), str(numRow), str(numCol),
                     str(alpha123), str(beta123), str(delta123), str(gamma123), str(alpbetdelgam)]
        cmd = ' '.join(para_list)
        logger.info(cmd)
        result_tuple = subprocess.getstatusoutput(cmd)
        if result_tuple[0] != 1 or result_tuple[1].find('error') != -1 or result_tuple[1].find('Could not open') != -1:
            raise Exception(result_tuple[1])
        shutil.copyfile(config_path, os.path.join(h_a_alpha_out_dir, 'config.txt'))

    def __read_haalpha(self, h_a_alpha_dir, name_list):
        """
        读取H-A-Alpha分解二进制数据，输出为矩阵格式的字典
        :param h_a_alpha_dir : h_a_alpha二进制数据的目录,包含.bin,.config
        :name_list : 需要组合的名称集合['entropy', 'anisotropy', 'alpha', 'beta', 'delta', 'gamma', 'lambda',
                     'combination_1mH1mA', 'combination_1mHA', 'combination_H1mA', 'combination_HA']
        :return : 包含H-A-Alpha矩阵信息的字典
        """
        dir = os.path.join(h_a_alpha_dir, '*.bin')
        bin_paths = list(glob.glob(dir))
        haalpha_dic ={}
        for name in name_list:
            path = os.path.join(h_a_alpha_dir, name + '.bin')
            if path in bin_paths:
               img = self.__read_bin_to_img(path)
               haalpha_dic.update({name: img})
        return haalpha_dic

    def standardization(self, data, num=1):
        # 矩阵标准化到[0,1]
        data[np.isnan(data)] = np.min(data)  # 异常值填充为0
        _range = np.max(data) - np.min(data)
        return (data - np.min(data)) / _range * num

    def __write_haalpha_to_tif(self, out_tif_dir, h_a_alpha_dir, name_list):
        """
        读取H-A-Alpha分解二进制数据，输出为矩阵格式的字典
        :param out_tif_dir : tif的输出路径
        :param h_a_alpha_dir : h_a_alpha二进制数据的目录,包含.bin,.config
        :name_list : 需要组合的名称集合['entropy', 'anisotropy', 'alpha', 'beta', 'delta', 'gamma', 'lambda',
                     'combination_1mH1mA', 'combination_1mHA', 'combination_H1mA', 'combination_HA']

        """
        dir = os.path.join(h_a_alpha_dir, '*.bin')
        bin_paths = list(glob.glob(dir))

        for name in name_list:
            in_path = os.path.join(h_a_alpha_dir, name + '.bin')
            out_path = os.path.join(out_tif_dir, name + '.tif')
            if in_path in bin_paths:
               img_array = self.__read_bin_to_img(in_path)
               if self.__normalization is True:
                   img_array = self.standardization(img_array, num=1)
               out_image = Image.fromarray(img_array)
               out_image.save(out_path)

    @staticmethod
    def __read_bin_to_img(bin_path):
        """
        读取bin格式二进制数据，输出为矩阵
        :param bin_path : bin文件的路径，包含.bin,.config
        :return : 矩阵信息
        """
        (bin_dir, bin_name) = os.path.split(bin_path)
        config_path = os.path.join(bin_dir, 'config.txt')
        config = open(config_path, 'r').read().split('\n', -1)
        rows = int(config[1])
        cols = int(config[4])

        bin_file = open(bin_path, 'rb')   # 打开二进制文件
        size = os.path.getsize(bin_path)  # 获得文件大小
        if size < rows*cols*4:
            raise Exception('bin size less than rows*cols*4! size:', size, 'byte, rows:', rows, 'cols:', cols)

        img = np.zeros([rows, cols], dtype=np.float32)
        for row in range(rows):
            data = bin_file.read(4 * cols)  # 每次读取一行的二进制数据
            row_data = struct.unpack('f' * cols, data)  # 转为一行float数据
            img[row, :] = row_data
        bin_file.close()
        return img


# if __name__ == '__main__':
    # h_a_alpha_decomposition_T3_path = 'D:\\PolSARpro_v4.2.0\\Soft\data_process_sngl\\h_a_alpha_decomposition_T3.exe'
    # h_a_alpha_eigenvalue_set_T3_path = 'D:\\PolSARpro_v4.2.0\\Soft\data_process_sngl\\h_a_alpha_eigenvalue_set_T3.exe'
    # h_a_alpha_eigenvector_set_T3_path = 'D:\\PolSARpro_v4.2.0\\Soft\data_process_sngl\\h_a_alpha_eigenvector_set_T3.exe'
    # polsarpro_in_dir = 'D:\\PolSARpro_v4.2.0\\in'
    # haalpha_out_dir = 'D:\\PolSARpro_v4.2.0\\out'
    # h_a_alpha_eigenvalue_set_T3_out = 'D:\\PolSARpro_v4.2.0\\out\\h_a_alpha_eigenvalue_set_T3'
    # h_a_alpha_eigenvector_set_T3_out = 'D:\\PolSARpro_v4.2.0\\out\\h_a_alpha_eigenvector_set_T3'
    #
    # haa = PspHAAlphaDecomposition()
    # h_a_alpha_features = haa.api_creat_h_a_alpha_features(haalpha_out_dir, h_a_alpha_decomposition_T3_path, h_a_alpha_eigenvalue_set_T3_path, h_a_alpha_eigenvector_set_T3_path, polsarpro_in_dir)


    # haa = PspHAAlphaDecomposition(normalization=True)
    # psp_path = r"I:\MicroWorkspace\product\C-SAR\SoilSalinity\GF3B_MYC_QPSI_003581_E120.6_N31.3_20220729_L1A_AHV_L10000073024_RPCpsp_t3"
    # t3_path = r"I:\MicroWorkspace\product\C-SAR\SoilSalinity\t3"
    # exe_dir = r"I:\microproduct\soilSalinity/"
    # haa.api_creat_h_a_alpha_features(h_a_alpha_out_dir=t3_path,
    #                                  h_a_alpha_decomposition_T3_path= exe_dir + 'h_a_alpha_decomposition_T3.exe',
    #                                  h_a_alpha_eigenvalue_set_T3_path= exe_dir + 'h_a_alpha_eigenvalue_set_T3.exe',
    #                                  h_a_alpha_eigenvector_set_T3_path=exe_dir +'h_a_alpha_eigenvector_set_T3.exe',
    #                                  polsarpro_in_dir=psp_path)

    # print('done')