add some icons

ReadMe.md

@@ -6,7 +6,15 @@ CVEO团队
 Python3.7 + PyQt + QGIS
 
 ## 配置方式
+
+```
 conda create -f conda.yaml
+```
+或
+
+```
+conda env create -n cevo_qt -f conda.yaml
+```
 
 
 # 打包方式

conda.yaml

@@ -11,6 +11,7 @@ dependencies:
   - pyqtads=3.8.2=py37hf2a7229_0
   - python=3.7.10=h7840368_101_cpython
   - python_abi=3.7=2_cp37m
+  - pip
   - pyyaml=5.4.1=py37hcc03f2d_1
   - qgis=3.18.3=py37h3dc7164_2
   - qt=5.12.9=h5909a2a_4

lic/license.lic

@@ -1 +1 @@
-vd4FiYncytyziGH9GNCAA8hGGr1/79Xmphtc5+PHPJDpxvqj1hP7+985QMojYO4M5Qn/aqEAvFgeDN3CA8x1YAK8SdCgSXSBJpRBK8wqPQjBY1ak96QfdPCrTLunr+xuPxK3Gxe772adTTsee2+ot7WePYUsC4y4NcS5+rlP1if87xtYqVeSwx3c64cOmAGP
+IEhM2L0c7TWXeIEGUm8n1nMToPxkWiapMjEFtLFLHad4a1+2IKcrD2wbRobBLmTIdux5iOV+AV+t2JY75+w5NAU+umtYPWmpbAiphAQ1S8s8/h7fclRBU6Ym8oXDxCmZoWpCLCpJd8lE/R3nfKBoexDRYXecz/lw58wkdZbHktpNVKfjoe827/aKa7gmYNXO

plugins/unsupervised_method/scripts/__init__.py

@@ -1,6 +1,14 @@
+from rscder.utils.icons import IconInstance
+from .SH import SH
+from .LHBA import LHBA
+from .OCD import OCD
+from .AHT import AHT
+from .ACD import ACD
+import numpy as np
 from datetime import datetime
 from osgeo import gdal
-import math,os
+import math
+import os
 import time
 from PyQt5 import QtWidgets
 from sklearn.cluster import k_means
@@ -10,29 +18,26 @@ from misc import Register, AlgFrontend
 
 UNSUPER_CD = Register('无监督变化检测方法')
 
-import numpy as np
-from .ACD import ACD
-from .AHT import AHT
-from .OCD import OCD
-from .LHBA import LHBA
-from .SH import SH
 
-def warp(file,ds:gdal.Dataset,srcWin=[0,0,0,0]):
+def warp(file, ds: gdal.Dataset, srcWin=[0, 0, 0, 0]):
     driver = gdal.GetDriverByName('GTiff')
-    xsize=ds.RasterXSize
-    ysize=ds.RasterYSize
-    geo=ds.GetGeoTransform()
-    orj=ds.GetProjection()
-    band=ds.RasterCount
+    xsize = ds.RasterXSize
+    ysize = ds.RasterYSize
+    geo = ds.GetGeoTransform()
+    orj = ds.GetProjection()
+    band = ds.RasterCount
     if os.path.exists(file):
         os.remove(file)
-    out_ds:gdal.Dataset=driver.Create(file, xsize, ysize, band, gdal.GDT_Byte)
+    out_ds: gdal.Dataset = driver.Create(
+        file, xsize, ysize, band, gdal.GDT_Byte)
     out_ds.SetGeoTransform(geo)
     out_ds.SetProjection(orj)
-    for b in range(1,band+1):
-        out_ds.GetRasterBand(b).WriteArray(ds.ReadAsArray(*srcWin,band_list=[b]),*(0,0))
+    for b in range(1, band+1):
+        out_ds.GetRasterBand(b).WriteArray(
+            ds.ReadAsArray(*srcWin, band_list=[b]), *(0, 0))
     del out_ds
 
+
 @UNSUPER_CD.register
 class BasicCD(AlgFrontend):
 
@@ -41,10 +46,14 @@ class BasicCD(AlgFrontend):
         return '差分法'
 
     @staticmethod
-    def run_alg(pth1:str,pth2:str,layer_parent:PairLayer,send_message = None,*args, **kargs):
+    def get_icon():
+        return IconInstance().ARITHMETIC3
 
-        ds1:gdal.Dataset=gdal.Open(pth1)
-        ds2:gdal.Dataset=gdal.Open(pth2)
+    @staticmethod
+    def run_alg(pth1: str, pth2: str, layer_parent: PairLayer, send_message=None, *args, **kargs):
+
+        ds1: gdal.Dataset = gdal.Open(pth1)
+        ds2: gdal.Dataset = gdal.Open(pth2)
 
         cell_size = layer_parent.cell_size
         xsize = layer_parent.size[0]
@@ -56,43 +65,47 @@ class BasicCD(AlgFrontend):
         driver = gdal.GetDriverByName('GTiff')
         out_tif = os.path.join(Project().other_path, 'temp.tif')
         out_ds = driver.Create(out_tif, xsize, ysize, 1, gdal.GDT_Float32)
-        geo=layer_parent.grid.geo
-        proj=layer_parent.grid.proj
+        geo = layer_parent.grid.geo
+        proj = layer_parent.grid.proj
         out_ds.SetGeoTransform(geo)
         out_ds.SetProjection(proj)
 
         max_diff = 0
         min_diff = math.inf
 
-        start1x,start1y=geo2imageRC(ds1.GetGeoTransform(),layer_parent.mask.xy[0],layer_parent.mask.xy[1])
-        end1x,end1y=geo2imageRC(ds1.GetGeoTransform(),layer_parent.mask.xy[2],layer_parent.mask.xy[3])
+        start1x, start1y = geo2imageRC(ds1.GetGeoTransform(
+        ), layer_parent.mask.xy[0], layer_parent.mask.xy[1])
+        end1x, end1y = geo2imageRC(ds1.GetGeoTransform(
+        ), layer_parent.mask.xy[2], layer_parent.mask.xy[3])
 
-        start2x,start2y=geo2imageRC(ds2.GetGeoTransform(),layer_parent.mask.xy[0],layer_parent.mask.xy[1])
-        end2x,end2y=geo2imageRC(ds2.GetGeoTransform(),layer_parent.mask.xy[2],layer_parent.mask.xy[3])
+        start2x, start2y = geo2imageRC(ds2.GetGeoTransform(
+        ), layer_parent.mask.xy[0], layer_parent.mask.xy[1])
+        end2x, end2y = geo2imageRC(ds2.GetGeoTransform(
+        ), layer_parent.mask.xy[2], layer_parent.mask.xy[3])
 
-        for j in range(yblocks + 1):#该改这里了
+        for j in range(yblocks + 1):  # 该改这里了
             if send_message is not None:
                 send_message.emit(f'计算{j}/{yblocks}')
             block_xy1 = (start1x, start1y+j * cell_size[1])
-            block_xy2 = (start2x,start2y+j*cell_size[1])
-            block_xy=(0,j * cell_size[1])
+            block_xy2 = (start2x, start2y+j*cell_size[1])
+            block_xy = (0, j * cell_size[1])
             if block_xy1[1] > end1y or block_xy2[1] > end2y:
                 break
-            block_size=(xsize, cell_size[1])
+            block_size = (xsize, cell_size[1])
             block_size1 = (xsize, cell_size[1])
-            block_size2 = (xsize,cell_size[1])
+            block_size2 = (xsize, cell_size[1])
             if block_xy[1] + block_size[1] > ysize:
                 block_size = (xsize, ysize - block_xy[1])
             if block_xy1[1] + block_size1[1] > end1y:
-                block_size1 = (xsize,end1y - block_xy1[1])
+                block_size1 = (xsize, end1y - block_xy1[1])
             if block_xy2[1] + block_size2[1] > end2y:
                 block_size2 = (xsize, end2y - block_xy2[1])
             block_data1 = ds1.ReadAsArray(*block_xy1, *block_size1)
             block_data2 = ds2.ReadAsArray(*block_xy2, *block_size2)
 
             if band == 1:
-                block_data1 =  block_data1[None, ...]
-                block_data2 =  block_data2[None, ...]
+                block_data1 = block_data1[None, ...]
+                block_data2 = block_data2[None, ...]
             # pdb.set_trace()
             block_diff = block_data1.sum(0) - block_data2.sum(0)
             block_diff = block_diff.astype(np.float32)
@@ -112,8 +125,10 @@ class BasicCD(AlgFrontend):
             send_message.emit('归一化概率中...')
         temp_in_ds = gdal.Open(out_tif)
 
-        out_normal_tif = os.path.join(Project().cmi_path, '{}_{}_cmi.tif'.format(layer_parent.name, int(np.random.rand() * 100000)))
-        out_normal_ds = driver.Create(out_normal_tif, xsize, ysize, 1, gdal.GDT_Byte)
+        out_normal_tif = os.path.join(Project().cmi_path, '{}_{}_cmi.tif'.format(
+            layer_parent.name, int(np.random.rand() * 100000)))
+        out_normal_ds = driver.Create(
+            out_normal_tif, xsize, ysize, 1, gdal.GDT_Byte)
         out_normal_ds.SetGeoTransform(geo)
         out_normal_ds.SetProjection(proj)
         # hist = np.zeros(256, dtype=np.int32)
@@ -141,6 +156,7 @@ class BasicCD(AlgFrontend):
             send_message.emit('差分法计算完成')
         return out_normal_tif
 
+
 @UNSUPER_CD.register
 class LSTS(AlgFrontend):
 
@@ -148,6 +164,10 @@ class LSTS(AlgFrontend):
     def get_name():
         return 'LSTS'
 
+    @staticmethod
+    def get_icon():
+        return IconInstance().ARITHMETIC3
+
     @staticmethod
     def get_widget(parent=None):
 
@@ -157,12 +177,12 @@ class LSTS(AlgFrontend):
 
     @staticmethod
     def get_params(widget=None):
-        return dict(n=5, w_size=(3,3))
+        return dict(n=5, w_size=(3, 3))
 
     @staticmethod
-    def run_alg(pth1:str,pth2:str,layer_parent:PairLayer,send_message=None,n=5,w_size=(3,3), *args, **kws):
-        ds1:gdal.Dataset=gdal.Open(pth1)
-        ds2:gdal.Dataset=gdal.Open(pth2)
+    def run_alg(pth1: str, pth2: str, layer_parent: PairLayer, send_message=None, n=5, w_size=(3, 3), *args, **kws):
+        ds1: gdal.Dataset = gdal.Open(pth1)
+        ds2: gdal.Dataset = gdal.Open(pth2)
 
         cell_size = layer_parent.cell_size
         xsize = layer_parent.size[0]
@@ -172,83 +192,90 @@ class LSTS(AlgFrontend):
         yblocks = ysize // cell_size[1]
 
         driver = gdal.GetDriverByName('GTiff')
-        out_tif = os.path.join(Project().other_path, '%d.tif'%(int(datetime.now().timestamp() * 1000)))
+        out_tif = os.path.join(Project().other_path, '%d.tif' % (
+            int(datetime.now().timestamp() * 1000)))
         out_ds = driver.Create(out_tif, xsize, ysize, 1, gdal.GDT_Float32)
-        geo=layer_parent.grid.geo
-        proj=layer_parent.grid.proj
+        geo = layer_parent.grid.geo
+        proj = layer_parent.grid.proj
         out_ds.SetGeoTransform(geo)
         out_ds.SetProjection(proj)
-        pixnum=w_size[0]*w_size[1]
+        pixnum = w_size[0]*w_size[1]
         # send_message.emit('pixnum:'pixnum)
         max_diff = 0
         min_diff = math.inf
-        win_h=w_size[0]//2 #half hight of window 
-        win_w=w_size[1]//2 #half width of window
-        a=[[(i+1)**j for j in range(n+1)] for i in range(pixnum)]
-        A=np.array(a).astype(np.float64)# 
+        win_h = w_size[0]//2  # half hight of window
+        win_w = w_size[1]//2  # half width of window
+        a = [[(i+1)**j for j in range(n+1)] for i in range(pixnum)]
+        A = np.array(a).astype(np.float64)
 
-        k_=np.array(range(1,n+1))
-        df1=np.zeros(pixnum).astype(np.float64)
-        df2=np.zeros(pixnum).astype(np.float64)
+        k_ = np.array(range(1, n+1))
+        df1 = np.zeros(pixnum).astype(np.float64)
+        df2 = np.zeros(pixnum).astype(np.float64)
 
-        start1x,start1y=geo2imageRC(ds1.GetGeoTransform(),layer_parent.mask.xy[0],layer_parent.mask.xy[1])
-        end1x,end1y=geo2imageRC(ds1.GetGeoTransform(),layer_parent.mask.xy[2],layer_parent.mask.xy[3])
+        start1x, start1y = geo2imageRC(ds1.GetGeoTransform(
+        ), layer_parent.mask.xy[0], layer_parent.mask.xy[1])
+        end1x, end1y = geo2imageRC(ds1.GetGeoTransform(
+        ), layer_parent.mask.xy[2], layer_parent.mask.xy[3])
 
-        start2x,start2y=geo2imageRC(ds2.GetGeoTransform(),layer_parent.mask.xy[0],layer_parent.mask.xy[1])
-        end2x,end2y=geo2imageRC(ds2.GetGeoTransform(),layer_parent.mask.xy[2],layer_parent.mask.xy[3])
+        start2x, start2y = geo2imageRC(ds2.GetGeoTransform(
+        ), layer_parent.mask.xy[0], layer_parent.mask.xy[1])
+        end2x, end2y = geo2imageRC(ds2.GetGeoTransform(
+        ), layer_parent.mask.xy[2], layer_parent.mask.xy[3])
 
         for j in range(yblocks + 1):
             if send_message is not None:
                 send_message.emit(f'计算{j}/{yblocks}')
             block_xy1 = (start1x, start1y+j * cell_size[1])
-            block_xy2 = (start2x,start2y+j*cell_size[1])
-            block_xy=(0,j * cell_size[1])
+            block_xy2 = (start2x, start2y+j*cell_size[1])
+            block_xy = (0, j * cell_size[1])
             if block_xy1[1] > end1y or block_xy2[1] > end2y:
                 break
-            block_size=(xsize, cell_size[1])
+            block_size = (xsize, cell_size[1])
             block_size1 = (xsize, cell_size[1])
-            block_size2 = (xsize,cell_size[1])
+            block_size2 = (xsize, cell_size[1])
             if block_xy[1] + block_size[1] > ysize:
                 block_size = (xsize, ysize - block_xy[1])
             if block_xy1[1] + block_size1[1] > end1y:
-                block_size1 = (xsize,end1y - block_xy1[1])
+                block_size1 = (xsize, end1y - block_xy1[1])
             if block_xy2[1] + block_size2[1] > end2y:
                 block_size2 = (xsize, end2y - block_xy2[1])
             block_data1 = ds1.ReadAsArray(*block_xy1, *block_size1)
             block_data2 = ds2.ReadAsArray(*block_xy2, *block_size2)
 
             if band == 1:
-                block_data1 =  block_data1[None, ...]
-                block_data2 =  block_data2[None, ...]
+                block_data1 = block_data1[None, ...]
+                block_data2 = block_data2[None, ...]
             # pdb.set_trace()
             else:
-                block_data1=np.mean(block_data1,0)
-                block_data2=np.mean(block_data2,0)
-            block_diff=np.zeros(block_data1.shape).astype(np.float64)
+                block_data1 = np.mean(block_data1, 0)
+                block_data2 = np.mean(block_data2, 0)
+            block_diff = np.zeros(block_data1.shape).astype(np.float64)
 
-            for i in range(win_h,block_size1[1]-win_h):
-                for j_ in range(win_w,block_size1[0]-win_w):
-                    pix=0
+            for i in range(win_h, block_size1[1]-win_h):
+                for j_ in range(win_w, block_size1[0]-win_w):
+                    pix = 0
 
-                    #get b
+                    # get b
                     # b1=block_data[i+win_h:i+win_h] c in range(j_-win_w,j_+win_w+1)
-                    b1=block_data1[i-win_h:i+win_h+1,j_-win_w:j_+win_w+1]
-                    b2=block_data2[i-win_h:i+win_h+1,j_-win_w:j_+win_w+1]
-                    b1=[b if (r+1)//2 else b[::-1] for r,b in enumerate(b1)]
-                    b2=[b if (r+1)//2 else b[::-1] for r,b in enumerate(b2)]
-                    b1=np.expand_dims(np.concatenate(b1,0),1)
-                    b2=np.expand_dims(np.concatenate(b2,0),1)
+                    b1 = block_data1[i-win_h:i+win_h+1, j_-win_w:j_+win_w+1]
+                    b2 = block_data2[i-win_h:i+win_h+1, j_-win_w:j_+win_w+1]
+                    b1 = [b if (r+1)//2 else b[::-1] for r, b in enumerate(b1)]
+                    b2 = [b if (r+1)//2 else b[::-1] for r, b in enumerate(b2)]
+                    b1 = np.expand_dims(np.concatenate(b1, 0), 1)
+                    b2 = np.expand_dims(np.concatenate(b2, 0), 1)
 
-                    x1=np.squeeze(np.linalg.pinv(A).dot(b1))
-                    x2=np.squeeze(np.linalg.pinv(A).dot(b2))
-                    #df
-                    k_=range(1,n+1)
-                    for pix in range(1,pixnum+1):
-                        df1[pix-1]=x1[1:n+1].dot(np.array([k*(pix**(k-1)) for k in k_]))
-                        df2[pix-1]=x2[1:n+1].dot(np.array([k*(pix**(k-1)) for k in k_]))
+                    x1 = np.squeeze(np.linalg.pinv(A).dot(b1))
+                    x2 = np.squeeze(np.linalg.pinv(A).dot(b2))
+                    # df
+                    k_ = range(1, n+1)
+                    for pix in range(1, pixnum+1):
+                        df1[pix-1] = x1[1:n +
+                                        1].dot(np.array([k*(pix**(k-1)) for k in k_]))
+                        df2[pix-1] = x2[1:n +
+                                        1].dot(np.array([k*(pix**(k-1)) for k in k_]))
 
-                    #distance 欧式距离
-                    block_diff[i][j_]=np.dot(df1-df2,df1-df2)**0.5
+                    # distance 欧式距离
+                    block_diff[i][j_] = np.dot(df1-df2, df1-df2)**0.5
 
             min_diff = min(min_diff, block_diff[block_diff > 0].min())
             max_diff = max(max_diff, block_diff.max())
@@ -263,8 +290,10 @@ class LSTS(AlgFrontend):
             send_message.emit('归一化概率中...')
         temp_in_ds = gdal.Open(out_tif)
 
-        out_normal_tif = os.path.join(Project().cmi_path, '{}_{}_cmi.tif'.format(layer_parent.name, int(np.random.rand() * 100000)))
-        out_normal_ds = driver.Create(out_normal_tif, xsize, ysize, 1, gdal.GDT_Byte)
+        out_normal_tif = os.path.join(Project().cmi_path, '{}_{}_cmi.tif'.format(
+            layer_parent.name, int(np.random.rand() * 100000)))
+        out_normal_ds = driver.Create(
+            out_normal_tif, xsize, ysize, 1, gdal.GDT_Byte)
         out_normal_ds.SetGeoTransform(geo)
         out_normal_ds.SetProjection(proj)
         # hist = np.zeros(256, dtype=np.int32)
@@ -302,10 +331,14 @@ class CVAAlg(AlgFrontend):
         return 'CVA'
 
     @staticmethod
-    def run_alg(pth1:str,pth2:str,layer_parent:PairLayer,send_message = None, *args, **kargs):
+    def get_icon():
+        return IconInstance().ARITHMETIC3
 
-        ds1:gdal.Dataset=gdal.Open(pth1)
-        ds2:gdal.Dataset=gdal.Open(pth2)
+    @staticmethod
+    def run_alg(pth1: str, pth2: str, layer_parent: PairLayer, send_message=None, *args, **kargs):
+
+        ds1: gdal.Dataset = gdal.Open(pth1)
+        ds2: gdal.Dataset = gdal.Open(pth2)
 
         cell_size = layer_parent.cell_size
         xsize = layer_parent.size[0]
@@ -317,45 +350,48 @@ class CVAAlg(AlgFrontend):
         driver = gdal.GetDriverByName('GTiff')
         out_tif = os.path.join(Project().other_path, 'temp.tif')
         out_ds = driver.Create(out_tif, xsize, ysize, 1, gdal.GDT_Float32)
-        geo=layer_parent.grid.geo
-        proj=layer_parent.grid.proj
+        geo = layer_parent.grid.geo
+        proj = layer_parent.grid.proj
         out_ds.SetGeoTransform(geo)
         out_ds.SetProjection(proj)
         max_diff = 0
         min_diff = math.inf
 
+        start1x, start1y = geo2imageRC(ds1.GetGeoTransform(
+        ), layer_parent.mask.xy[0], layer_parent.mask.xy[1])
+        end1x, end1y = geo2imageRC(ds1.GetGeoTransform(
+        ), layer_parent.mask.xy[2], layer_parent.mask.xy[3])
 
-        start1x,start1y=geo2imageRC(ds1.GetGeoTransform(),layer_parent.mask.xy[0],layer_parent.mask.xy[1])
-        end1x,end1y=geo2imageRC(ds1.GetGeoTransform(),layer_parent.mask.xy[2],layer_parent.mask.xy[3])
-
-        start2x,start2y=geo2imageRC(ds2.GetGeoTransform(),layer_parent.mask.xy[0],layer_parent.mask.xy[1])
-        end2x,end2y=geo2imageRC(ds2.GetGeoTransform(),layer_parent.mask.xy[2],layer_parent.mask.xy[3])
+        start2x, start2y = geo2imageRC(ds2.GetGeoTransform(
+        ), layer_parent.mask.xy[0], layer_parent.mask.xy[1])
+        end2x, end2y = geo2imageRC(ds2.GetGeoTransform(
+        ), layer_parent.mask.xy[2], layer_parent.mask.xy[3])
 
         for j in range(yblocks + 1):
             if send_message is not None:
                 send_message.emit(f'计算{j}/{yblocks}')
             block_xy1 = (start1x, start1y+j * cell_size[1])
-            block_xy2 = (start2x,start2y+j*cell_size[1])
-            block_xy=(0,j * cell_size[1])
+            block_xy2 = (start2x, start2y+j*cell_size[1])
+            block_xy = (0, j * cell_size[1])
             if block_xy1[1] > end1y or block_xy2[1] > end2y:
                 break
-            block_size=(xsize, cell_size[1])
+            block_size = (xsize, cell_size[1])
             block_size1 = (xsize, cell_size[1])
-            block_size2 = (xsize,cell_size[1])
+            block_size2 = (xsize, cell_size[1])
             if block_xy[1] + block_size[1] > ysize:
                 block_size = (xsize, ysize - block_xy[1])
             if block_xy1[1] + block_size1[1] > end1y:
-                block_size1 = (xsize,end1y - block_xy1[1])
+                block_size1 = (xsize, end1y - block_xy1[1])
             if block_xy2[1] + block_size2[1] > end2y:
                 block_size2 = (xsize, end2y - block_xy2[1])
             block_data1 = ds1.ReadAsArray(*block_xy1, *block_size1)
             block_data2 = ds2.ReadAsArray(*block_xy2, *block_size2)
 
             if band == 1:
-                block_data1 =  block_data1[None, ...]
-                block_data2 =  block_data2[None, ...]
+                block_data1 = block_data1[None, ...]
+                block_data2 = block_data2[None, ...]
             # pdb.set_trace()
-            block_diff=np.sum((block_data1-block_data2)**2,0)**0.5
+            block_diff = np.sum((block_data1-block_data2)**2, 0)**0.5
             min_diff = min(min_diff, block_diff[block_diff > 0].min())
             max_diff = max(max_diff, block_diff.max())
             out_ds.GetRasterBand(1).WriteArray(block_diff, *block_xy)
@@ -369,8 +405,10 @@ class CVAAlg(AlgFrontend):
             send_message.emit('归一化概率中...')
         temp_in_ds = gdal.Open(out_tif)
 
-        out_normal_tif = os.path.join(Project().cmi_path, '{}_{}_cmi.tif'.format(layer_parent.name, int(np.random.rand() * 100000)))
-        out_normal_ds = driver.Create(out_normal_tif, xsize, ysize, 1, gdal.GDT_Byte)
+        out_normal_tif = os.path.join(Project().cmi_path, '{}_{}_cmi.tif'.format(
+            layer_parent.name, int(np.random.rand() * 100000)))
+        out_normal_ds = driver.Create(
+            out_normal_tif, xsize, ysize, 1, gdal.GDT_Byte)
         out_normal_ds.SetGeoTransform(geo)
         out_normal_ds.SetProjection(proj)
         # hist = np.zeros(256, dtype=np.int32)
@@ -398,6 +436,7 @@ class CVAAlg(AlgFrontend):
             send_message.emit('欧式距离计算完成')
         return out_normal_tif
 
+
 @UNSUPER_CD.register
 class ACDAlg(AlgFrontend):
 
@@ -406,7 +445,11 @@ class ACDAlg(AlgFrontend):
         return 'ACD'
 
     @staticmethod
-    def run_alg(pth1:str,pth2:str,layer_parent:PairLayer,send_message = None, *args, **kargs):
+    def get_icon():
+        return IconInstance().ARITHMETIC3
+
+    @staticmethod
+    def run_alg(pth1: str, pth2: str, layer_parent: PairLayer, send_message=None, *args, **kargs):
 
         if send_message is None:
             class Empty:
@@ -418,39 +461,41 @@ class ACDAlg(AlgFrontend):
 
         xsize = layer_parent.size[0]
         ysize = layer_parent.size[1]
-        geo=layer_parent.grid.geo
-        proj=layer_parent.grid.proj
-        #提取公共部分
+        geo = layer_parent.grid.geo
+        proj = layer_parent.grid.proj
+        # 提取公共部分
         send_message.emit('提取重叠区域数据.....')
 
-        ds2:gdal.Dataset=gdal.Open(pth2)
-        temp_tif2 = os.path.join(Project().other_path,'temp2.tif')
-        start2x,start2y=geo2imageRC(ds2.GetGeoTransform(),layer_parent.mask.xy[0],layer_parent.mask.xy[1])
-        end2x,end2y=geo2imageRC(ds2.GetGeoTransform(),layer_parent.mask.xy[2],layer_parent.mask.xy[3])
-        warp(temp_tif2,ds2,srcWin=[start2x,start2y,xsize,ysize])
+        ds2: gdal.Dataset = gdal.Open(pth2)
+        temp_tif2 = os.path.join(Project().other_path, 'temp2.tif')
+        start2x, start2y = geo2imageRC(ds2.GetGeoTransform(
+        ), layer_parent.mask.xy[0], layer_parent.mask.xy[1])
+        end2x, end2y = geo2imageRC(ds2.GetGeoTransform(
+        ), layer_parent.mask.xy[2], layer_parent.mask.xy[3])
+        warp(temp_tif2, ds2, srcWin=[start2x, start2y, xsize, ysize])
         del ds2
         send_message.emit('图像二提取完成')
 
-
-        ds1:gdal.Dataset=gdal.Open(pth1)
+        ds1: gdal.Dataset = gdal.Open(pth1)
         temp_tif1 = os.path.join(Project().other_path, 'temp1.tif')
-        start1x,start1y=geo2imageRC(ds1.GetGeoTransform(),layer_parent.mask.xy[0],layer_parent.mask.xy[1])
-        end1x,end1y=geo2imageRC(ds1.GetGeoTransform(),layer_parent.mask.xy[2],layer_parent.mask.xy[3])
-        warp(temp_tif1,ds1,srcWin=[start1x,start1y,xsize,ysize])
+        start1x, start1y = geo2imageRC(ds1.GetGeoTransform(
+        ), layer_parent.mask.xy[0], layer_parent.mask.xy[1])
+        end1x, end1y = geo2imageRC(ds1.GetGeoTransform(
+        ), layer_parent.mask.xy[2], layer_parent.mask.xy[3])
+        warp(temp_tif1, ds1, srcWin=[start1x, start1y, xsize, ysize])
         del ds1
         send_message.emit('图像一提取完成')
 
-        
-        
-        #运算
+        # 运算
         send_message.emit('开始ACD计算.....')
         time.sleep(0.1)
-        out_normal_tif = os.path.join(Project().cmi_path, '{}_{}_cmi.tif'.format(layer_parent.name, int(np.random.rand() * 100000)))
-        ACD(temp_tif1,temp_tif2,out_normal_tif)
-        #添加投影
+        out_normal_tif = os.path.join(Project().cmi_path, '{}_{}_cmi.tif'.format(
+            layer_parent.name, int(np.random.rand() * 100000)))
+        ACD(temp_tif1, temp_tif2, out_normal_tif)
+        # 添加投影
         send_message.emit('录入投影信息.....')
         time.sleep(0.1)
-        ds=gdal.Open(out_normal_tif,1)
+        ds = gdal.Open(out_normal_tif, 1)
         ds.SetGeoTransform(geo)
         ds.SetProjection(proj)
         del ds
@@ -466,7 +511,11 @@ class AHTAlg(AlgFrontend):
         return 'AHT'
 
     @staticmethod
-    def run_alg(pth1:str,pth2:str,layer_parent:PairLayer,send_message = None, *args, **kargs):
+    def get_icon():
+        return IconInstance().ARITHMETIC3
+
+    @staticmethod
+    def run_alg(pth1: str, pth2: str, layer_parent: PairLayer, send_message=None, *args, **kargs):
 
         if send_message is None:
             class Empty:
@@ -477,39 +526,41 @@ class AHTAlg(AlgFrontend):
 
         xsize = layer_parent.size[0]
         ysize = layer_parent.size[1]
-        geo=layer_parent.grid.geo
-        proj=layer_parent.grid.proj
-        #提取公共部分
+        geo = layer_parent.grid.geo
+        proj = layer_parent.grid.proj
+        # 提取公共部分
         send_message.emit('提取重叠区域数据.....')
 
-        ds2:gdal.Dataset=gdal.Open(pth2)
-        temp_tif2 = os.path.join(Project().other_path,'temp2.tif')
-        start2x,start2y=geo2imageRC(ds2.GetGeoTransform(),layer_parent.mask.xy[0],layer_parent.mask.xy[1])
-        end2x,end2y=geo2imageRC(ds2.GetGeoTransform(),layer_parent.mask.xy[2],layer_parent.mask.xy[3])
-        warp(temp_tif2,ds2,srcWin=[start2x,start2y,xsize,ysize])
+        ds2: gdal.Dataset = gdal.Open(pth2)
+        temp_tif2 = os.path.join(Project().other_path, 'temp2.tif')
+        start2x, start2y = geo2imageRC(ds2.GetGeoTransform(
+        ), layer_parent.mask.xy[0], layer_parent.mask.xy[1])
+        end2x, end2y = geo2imageRC(ds2.GetGeoTransform(
+        ), layer_parent.mask.xy[2], layer_parent.mask.xy[3])
+        warp(temp_tif2, ds2, srcWin=[start2x, start2y, xsize, ysize])
         del ds2
         send_message.emit('图像二提取完成')
 
-
-        ds1:gdal.Dataset=gdal.Open(pth1)
+        ds1: gdal.Dataset = gdal.Open(pth1)
         temp_tif1 = os.path.join(Project().other_path, 'temp1.tif')
-        start1x,start1y=geo2imageRC(ds1.GetGeoTransform(),layer_parent.mask.xy[0],layer_parent.mask.xy[1])
-        end1x,end1y=geo2imageRC(ds1.GetGeoTransform(),layer_parent.mask.xy[2],layer_parent.mask.xy[3])
-        warp(temp_tif1,ds1,srcWin=[start1x,start1y,xsize,ysize])
+        start1x, start1y = geo2imageRC(ds1.GetGeoTransform(
+        ), layer_parent.mask.xy[0], layer_parent.mask.xy[1])
+        end1x, end1y = geo2imageRC(ds1.GetGeoTransform(
+        ), layer_parent.mask.xy[2], layer_parent.mask.xy[3])
+        warp(temp_tif1, ds1, srcWin=[start1x, start1y, xsize, ysize])
         del ds1
         send_message.emit('图像一提取完成')
 
-        
-        
-        #运算
+        # 运算
         send_message.emit('开始AHT计算.....')
         time.sleep(0.1)
-        out_normal_tif = os.path.join(Project().cmi_path, '{}_{}_cmi.tif'.format(layer_parent.name, int(np.random.rand() * 100000)))
-        AHT(temp_tif1,temp_tif2,out_normal_tif)
-        #添加投影
+        out_normal_tif = os.path.join(Project().cmi_path, '{}_{}_cmi.tif'.format(
+            layer_parent.name, int(np.random.rand() * 100000)))
+        AHT(temp_tif1, temp_tif2, out_normal_tif)
+        # 添加投影
         send_message.emit('录入投影信息.....')
         time.sleep(0.1)
-        ds=gdal.Open(out_normal_tif,1)
+        ds = gdal.Open(out_normal_tif, 1)
         ds.SetGeoTransform(geo)
         ds.SetProjection(proj)
         del ds
@@ -525,7 +576,11 @@ class OCDAlg(AlgFrontend):
         return 'OCD'
 
     @staticmethod
-    def run_alg(pth1:str,pth2:str,layer_parent:PairLayer,send_message = None, *args, **kargs):
+    def get_icon():
+        return IconInstance().ARITHMETIC3
+
+    @staticmethod
+    def run_alg(pth1: str, pth2: str, layer_parent: PairLayer, send_message=None, *args, **kargs):
 
         if send_message is None:
             class Empty:
@@ -536,45 +591,48 @@ class OCDAlg(AlgFrontend):
 
         xsize = layer_parent.size[0]
         ysize = layer_parent.size[1]
-        geo=layer_parent.grid.geo
-        proj=layer_parent.grid.proj
-        #提取公共部分
+        geo = layer_parent.grid.geo
+        proj = layer_parent.grid.proj
+        # 提取公共部分
         send_message.emit('提取重叠区域数据.....')
 
-        ds2:gdal.Dataset=gdal.Open(pth2)
-        temp_tif2 = os.path.join(Project().other_path,'temp2.tif')
-        start2x,start2y=geo2imageRC(ds2.GetGeoTransform(),layer_parent.mask.xy[0],layer_parent.mask.xy[1])
-        end2x,end2y=geo2imageRC(ds2.GetGeoTransform(),layer_parent.mask.xy[2],layer_parent.mask.xy[3])
-        warp(temp_tif2,ds2,srcWin=[start2x,start2y,xsize,ysize])
+        ds2: gdal.Dataset = gdal.Open(pth2)
+        temp_tif2 = os.path.join(Project().other_path, 'temp2.tif')
+        start2x, start2y = geo2imageRC(ds2.GetGeoTransform(
+        ), layer_parent.mask.xy[0], layer_parent.mask.xy[1])
+        end2x, end2y = geo2imageRC(ds2.GetGeoTransform(
+        ), layer_parent.mask.xy[2], layer_parent.mask.xy[3])
+        warp(temp_tif2, ds2, srcWin=[start2x, start2y, xsize, ysize])
         del ds2
         send_message.emit('图像二提取完成')
 
-
-        ds1:gdal.Dataset=gdal.Open(pth1)
+        ds1: gdal.Dataset = gdal.Open(pth1)
         temp_tif1 = os.path.join(Project().other_path, 'temp1.tif')
-        start1x,start1y=geo2imageRC(ds1.GetGeoTransform(),layer_parent.mask.xy[0],layer_parent.mask.xy[1])
-        end1x,end1y=geo2imageRC(ds1.GetGeoTransform(),layer_parent.mask.xy[2],layer_parent.mask.xy[3])
-        warp(temp_tif1,ds1,srcWin=[start1x,start1y,xsize,ysize])
+        start1x, start1y = geo2imageRC(ds1.GetGeoTransform(
+        ), layer_parent.mask.xy[0], layer_parent.mask.xy[1])
+        end1x, end1y = geo2imageRC(ds1.GetGeoTransform(
+        ), layer_parent.mask.xy[2], layer_parent.mask.xy[3])
+        warp(temp_tif1, ds1, srcWin=[start1x, start1y, xsize, ysize])
         del ds1
         send_message.emit('图像一提取完成')
 
-        
-        
-        #运算
+        # 运算
         send_message.emit('开始OCD计算.....')
         time.sleep(0.1)
-        out_normal_tif = os.path.join(Project().cmi_path, '{}_{}_cmi.tif'.format(layer_parent.name, int(np.random.rand() * 100000)))
-        OCD(temp_tif1,temp_tif2,out_normal_tif,Project().other_path)
-        #添加投影
+        out_normal_tif = os.path.join(Project().cmi_path, '{}_{}_cmi.tif'.format(
+            layer_parent.name, int(np.random.rand() * 100000)))
+        OCD(temp_tif1, temp_tif2, out_normal_tif, Project().other_path)
+        # 添加投影
         send_message.emit('录入投影信息.....')
         time.sleep(0.1)
-        ds=gdal.Open(out_normal_tif,1)
+        ds = gdal.Open(out_normal_tif, 1)
         ds.SetGeoTransform(geo)
         ds.SetProjection(proj)
         del ds
 
         return out_normal_tif
 
+
 @UNSUPER_CD.register
 class LHBAAlg(AlgFrontend):
 
@@ -583,7 +641,11 @@ class LHBAAlg(AlgFrontend):
         return 'LHBA'
 
     @staticmethod
-    def run_alg(pth1:str,pth2:str,layer_parent:PairLayer,send_message = None, *args, **kargs):
+    def get_icon():
+        return IconInstance().ARITHMETIC3
+
+    @staticmethod
+    def run_alg(pth1: str, pth2: str, layer_parent: PairLayer, send_message=None, *args, **kargs):
 
         if send_message is None:
             class Empty:
@@ -592,40 +654,43 @@ class LHBAAlg(AlgFrontend):
                     print(args)
             send_message = Empty()
 
-
         xsize = layer_parent.size[0]
         ysize = layer_parent.size[1]
-        geo=layer_parent.grid.geo
-        proj=layer_parent.grid.proj
-        #提取公共部分
+        geo = layer_parent.grid.geo
+        proj = layer_parent.grid.proj
+        # 提取公共部分
         send_message.emit('提取重叠区域数据.....')
 
-        ds2:gdal.Dataset=gdal.Open(pth2)
-        temp_tif2 = os.path.join(Project().other_path,'temp2.tif')
-        start2x,start2y=geo2imageRC(ds2.GetGeoTransform(),layer_parent.mask.xy[0],layer_parent.mask.xy[1])
-        end2x,end2y=geo2imageRC(ds2.GetGeoTransform(),layer_parent.mask.xy[2],layer_parent.mask.xy[3])
-        warp(temp_tif2,ds2,srcWin=[start2x,start2y,xsize,ysize])
+        ds2: gdal.Dataset = gdal.Open(pth2)
+        temp_tif2 = os.path.join(Project().other_path, 'temp2.tif')
+        start2x, start2y = geo2imageRC(ds2.GetGeoTransform(
+        ), layer_parent.mask.xy[0], layer_parent.mask.xy[1])
+        end2x, end2y = geo2imageRC(ds2.GetGeoTransform(
+        ), layer_parent.mask.xy[2], layer_parent.mask.xy[3])
+        warp(temp_tif2, ds2, srcWin=[start2x, start2y, xsize, ysize])
         del ds2
         send_message.emit('图像二提取完成')
 
-
-        ds1:gdal.Dataset=gdal.Open(pth1)
+        ds1: gdal.Dataset = gdal.Open(pth1)
         temp_tif1 = os.path.join(Project().other_path, 'temp1.tif')
-        start1x,start1y=geo2imageRC(ds1.GetGeoTransform(),layer_parent.mask.xy[0],layer_parent.mask.xy[1])
-        end1x,end1y=geo2imageRC(ds1.GetGeoTransform(),layer_parent.mask.xy[2],layer_parent.mask.xy[3])
-        warp(temp_tif1,ds1,srcWin=[start1x,start1y,xsize,ysize])
+        start1x, start1y = geo2imageRC(ds1.GetGeoTransform(
+        ), layer_parent.mask.xy[0], layer_parent.mask.xy[1])
+        end1x, end1y = geo2imageRC(ds1.GetGeoTransform(
+        ), layer_parent.mask.xy[2], layer_parent.mask.xy[3])
+        warp(temp_tif1, ds1, srcWin=[start1x, start1y, xsize, ysize])
         del ds1
         send_message.emit('图像一提取完成')
 
-        #运算
+        # 运算
         send_message.emit('开始LHBA计算.....')
         time.sleep(0.1)
-        out_normal_tif = os.path.join(Project().cmi_path, '{}_{}_cmi.tif'.format(layer_parent.name, int(np.random.rand() * 100000)))
-        LHBA(temp_tif1,temp_tif2,out_normal_tif)
-        #添加投影
+        out_normal_tif = os.path.join(Project().cmi_path, '{}_{}_cmi.tif'.format(
+            layer_parent.name, int(np.random.rand() * 100000)))
+        LHBA(temp_tif1, temp_tif2, out_normal_tif)
+        # 添加投影
         send_message.emit('录入投影信息.....')
         time.sleep(0.1)
-        ds=gdal.Open(out_normal_tif,1)
+        ds = gdal.Open(out_normal_tif, 1)
         ds.SetGeoTransform(geo)
         ds.SetProjection(proj)
         del ds
@@ -640,7 +705,11 @@ class SHAlg(AlgFrontend):
         return 'SH'
 
     @staticmethod
-    def run_alg(pth1:str,pth2:str,layer_parent:PairLayer,send_message = None, *args, **kargs):
+    def get_icon():
+        return IconInstance().ARITHMETIC3
+
+    @staticmethod
+    def run_alg(pth1: str, pth2: str, layer_parent: PairLayer, send_message=None, *args, **kargs):
 
         if send_message is None:
             class Empty:
@@ -649,41 +718,43 @@ class SHAlg(AlgFrontend):
                     print(args)
             send_message = Empty()
 
-
-
         xsize = layer_parent.size[0]
         ysize = layer_parent.size[1]
-        geo=layer_parent.grid.geo
-        proj=layer_parent.grid.proj
-        #提取公共部分
+        geo = layer_parent.grid.geo
+        proj = layer_parent.grid.proj
+        # 提取公共部分
         send_message.emit('提取重叠区域数据.....')
 
-        ds2:gdal.Dataset=gdal.Open(pth2)
-        temp_tif2 = os.path.join(Project().other_path,'temp2.tif')
-        start2x,start2y=geo2imageRC(ds2.GetGeoTransform(),layer_parent.mask.xy[0],layer_parent.mask.xy[1])
-        end2x,end2y=geo2imageRC(ds2.GetGeoTransform(),layer_parent.mask.xy[2],layer_parent.mask.xy[3])
-        warp(temp_tif2,ds2,srcWin=[start2x,start2y,xsize,ysize])
+        ds2: gdal.Dataset = gdal.Open(pth2)
+        temp_tif2 = os.path.join(Project().other_path, 'temp2.tif')
+        start2x, start2y = geo2imageRC(ds2.GetGeoTransform(
+        ), layer_parent.mask.xy[0], layer_parent.mask.xy[1])
+        end2x, end2y = geo2imageRC(ds2.GetGeoTransform(
+        ), layer_parent.mask.xy[2], layer_parent.mask.xy[3])
+        warp(temp_tif2, ds2, srcWin=[start2x, start2y, xsize, ysize])
         del ds2
         send_message.emit('图像二提取完成')
 
-
-        ds1:gdal.Dataset=gdal.Open(pth1)
+        ds1: gdal.Dataset = gdal.Open(pth1)
         temp_tif1 = os.path.join(Project().other_path, 'temp1.tif')
-        start1x,start1y=geo2imageRC(ds1.GetGeoTransform(),layer_parent.mask.xy[0],layer_parent.mask.xy[1])
-        end1x,end1y=geo2imageRC(ds1.GetGeoTransform(),layer_parent.mask.xy[2],layer_parent.mask.xy[3])
-        warp(temp_tif1,ds1,srcWin=[start1x,start1y,xsize,ysize])
+        start1x, start1y = geo2imageRC(ds1.GetGeoTransform(
+        ), layer_parent.mask.xy[0], layer_parent.mask.xy[1])
+        end1x, end1y = geo2imageRC(ds1.GetGeoTransform(
+        ), layer_parent.mask.xy[2], layer_parent.mask.xy[3])
+        warp(temp_tif1, ds1, srcWin=[start1x, start1y, xsize, ysize])
         del ds1
         send_message.emit('图像一提取完成')
 
-        #运算
+        # 运算
         send_message.emit('开始SH计算.....')
         time.sleep(0.1)
-        out_normal_tif = os.path.join(Project().cmi_path, '{}_{}_cmi.tif'.format(layer_parent.name, int(np.random.rand() * 100000)))
-        SH(temp_tif1,temp_tif2,out_normal_tif)
-        #添加投影
+        out_normal_tif = os.path.join(Project().cmi_path, '{}_{}_cmi.tif'.format(
+            layer_parent.name, int(np.random.rand() * 100000)))
+        SH(temp_tif1, temp_tif2, out_normal_tif)
+        # 添加投影
         send_message.emit('录入投影信息.....')
         time.sleep(0.1)
-        ds=gdal.Open(out_normal_tif,1)
+        ds = gdal.Open(out_normal_tif, 1)
         ds.SetGeoTransform(geo)
         ds.SetProjection(proj)
         del ds

plugins/veg_method/main.py

@@ -3,7 +3,7 @@ from threading import Thread
 from plugins.misc.main import AlgFrontend
 from rscder.gui.actions import ActionManager
 from rscder.plugins.basic import BasicPlugin
-from PyQt5.QtWidgets import QAction, QToolBar,  QMenu, QDialog, QHBoxLayout, QVBoxLayout, QPushButton,QWidget,QLabel,QLineEdit,QPushButton,QComboBox,QDialogButtonBox
+from PyQt5.QtWidgets import QAction, QToolBar,  QMenu, QDialog, QHBoxLayout, QVBoxLayout, QPushButton, QWidget, QLabel, QLineEdit, QPushButton, QComboBox, QDialogButtonBox
 
 from rscder.gui.layercombox import PairLayerCombox
 from rscder.utils.icons import IconInstance
@@ -13,8 +13,9 @@ from thres import THRES
 from misc import table_layer, AlgSelectWidget
 from follow import FOLLOW
 
+
 class VegtationCDMethod(QDialog):
-    def __init__(self,parent=None, alg:AlgFrontend=None):
+    def __init__(self, parent=None, alg: AlgFrontend = None):
         super(VegtationCDMethod, self).__init__(parent)
         self.alg = alg
         self.setWindowTitle('植被变化检测:{}'.format(alg.get_name()))
@@ -23,7 +24,7 @@ class VegtationCDMethod(QDialog):
         self.setMinimumWidth(500)
 
     def initUI(self):
-        #图层
+        # 图层
         self.layer_combox = PairLayerCombox(self)
         layerbox = QHBoxLayout()
         layerbox.addWidget(self.layer_combox)
@@ -42,12 +43,12 @@ class VegtationCDMethod(QDialog):
         self.cancel_button.setIcon(IconInstance().CANCEL)
         self.cancel_button.clicked.connect(self.reject)
         self.cancel_button.setDefault(False)
-        buttonbox=QDialogButtonBox(self)
-        buttonbox.addButton(self.ok_button,QDialogButtonBox.NoRole)
-        buttonbox.addButton(self.cancel_button,QDialogButtonBox.NoRole)
+        buttonbox = QDialogButtonBox(self)
+        buttonbox.addButton(self.ok_button, QDialogButtonBox.NoRole)
+        buttonbox.addButton(self.cancel_button, QDialogButtonBox.NoRole)
         buttonbox.setCenterButtons(True)
 
-        totalvlayout=QVBoxLayout()
+        totalvlayout = QVBoxLayout()
         totalvlayout.addLayout(layerbox)
         totalvlayout.addWidget(self.filter_select)
         if self.param_widget is not None:
@@ -62,6 +63,7 @@ class VegtationCDMethod(QDialog):
 
         self.setLayout(totalvlayout)
 
+
 @FOLLOW.register
 class VegetationCDFollow(AlgFrontend):
 
@@ -71,7 +73,7 @@ class VegetationCDFollow(AlgFrontend):
 
     @staticmethod
     def get_icon():
-        return IconInstance().UNSUPERVISED
+        return IconInstance().VEGETATION
 
     @staticmethod
     def get_widget(parent=None):
@@ -86,7 +88,7 @@ class VegetationCDFollow(AlgFrontend):
         thres_select = AlgSelectWidget(widget, THRES)
         thres_select.setObjectName('thres_select')
 
-        totalvlayout=QVBoxLayout()
+        totalvlayout = QVBoxLayout()
         totalvlayout.addWidget(layer_combox)
         totalvlayout.addWidget(filter_select)
         totalvlayout.addWidget(unsupervised_select)
@@ -98,20 +100,21 @@ class VegetationCDFollow(AlgFrontend):
         return widget
 
     @staticmethod
-    def get_params(widget:QWidget=None):
+    def get_params(widget: QWidget = None):
         if widget is None:
             return dict()
 
         layer_combox = widget.findChild(PairLayerCombox, 'layer_combox')
         filter_select = widget.findChild(AlgSelectWidget, 'filter_select')
-        unsupervised_select = widget.findChild(AlgSelectWidget, 'unsupervised_select')
+        unsupervised_select = widget.findChild(
+            AlgSelectWidget, 'unsupervised_select')
         thres_select = widget.findChild(AlgSelectWidget, 'thres_select')
 
-        layer1=layer_combox.layer1        
+        layer1 = layer_combox.layer1
         pth1 = layer_combox.layer1.path
         pth2 = layer_combox.layer2.path
 
-        falg, fparams =  filter_select.get_alg_and_params()
+        falg, fparams = filter_select.get_alg_and_params()
         cdalg, cdparams = unsupervised_select.get_alg_and_params()
         thalg, thparams = thres_select.get_alg_and_params()
 
@@ -120,27 +123,27 @@ class VegetationCDFollow(AlgFrontend):
 
         return dict(
             layer1=layer1,
-            pth1 = pth1,
-            pth2 = pth2,
-            falg = falg,
-            fparams = fparams,
-            cdalg = cdalg,
-            cdparams = cdparams,
-            thalg = thalg,
-            thparams = thparams,
+            pth1=pth1,
+            pth2=pth2,
+            falg=falg,
+            fparams=fparams,
+            cdalg=cdalg,
+            cdparams=cdparams,
+            thalg=thalg,
+            thparams=thparams,
         )
 
     @staticmethod
     def run_alg(layer1=None,
-            pth1 = None,
-            pth2 = None,
-            falg = None,
-            fparams = None,
-            cdalg = None,
-            cdparams = None,
-            thalg = None,
-            thparams = None,
-            send_message = None):
+                pth1=None,
+                pth2=None,
+                falg=None,
+                fparams=None,
+                cdalg=None,
+                cdparams=None,
+                thalg=None,
+                thparams=None,
+                send_message=None):
 
         if cdalg is None or thalg is None:
             return
@@ -148,21 +151,21 @@ class VegetationCDFollow(AlgFrontend):
         name = layer1.name
 
         if falg is not None:
-            pth1 = falg.run_alg(pth1, name=name, send_message= send_message, **fparams)
-            pth2 = falg.run_alg(pth2, name=name, send_message= send_message, **fparams)
-
-        
-        cdpth = cdalg.run_alg(pth1, pth2, layer1.layer_parent,  send_message= send_message,**cdparams)
-        thpth = thalg.run_alg(cdpth, name=name, send_message= send_message, **thparams)
-
-        table_layer(thpth,layer1,name, send_message)
+            pth1 = falg.run_alg(
+                pth1, name=name, send_message=send_message, **fparams)
+            pth2 = falg.run_alg(
+                pth2, name=name, send_message=send_message, **fparams)
 
+        cdpth = cdalg.run_alg(pth1, pth2, layer1.layer_parent,
+                              send_message=send_message, **cdparams)
+        thpth = thalg.run_alg(
+            cdpth, name=name, send_message=send_message, **thparams)
 
+        table_layer(thpth, layer1, name, send_message)
 
 
 class VegtationPlugin(BasicPlugin):
 
-
     @staticmethod
     def info():
         return {
@@ -178,7 +181,7 @@ class VegtationPlugin(BasicPlugin):
         # ActionManager().veg_menu.addMenu(veg_menu)
 
         for key in VEG_CD.keys():
-            alg:AlgFrontend = VEG_CD[key]
+            alg: AlgFrontend = VEG_CD[key]
             if alg.get_name() is None:
                 name = key
             else:
@@ -190,7 +193,6 @@ class VegtationPlugin(BasicPlugin):
 
             veg_menu.addAction(action)
 
-
     def run_cd(self, alg):
         dialog = VegtationCDMethod(self.mainwindow, alg)
         dialog.show()
@@ -199,14 +201,14 @@ class VegtationPlugin(BasicPlugin):
             t = Thread(target=self.run_cd_alg, args=(dialog,))
             t.start()
 
-    def run_cd_alg(self, w:VegtationCDMethod):
+    def run_cd_alg(self, w: VegtationCDMethod):
 
-        layer1=w.layer_combox.layer1        
+        layer1 = w.layer_combox.layer1
         pth1 = w.layer_combox.layer1.path
         pth2 = w.layer_combox.layer2.path
         name = layer1.layer_parent.name
 
-        falg, fparams =  w.filter_select.get_alg_and_params()
+        falg, fparams = w.filter_select.get_alg_and_params()
         cdalg = w.alg
         cdparams = w.alg.get_params()
         thalg, thparams = w.thres_select.get_alg_and_params()
@@ -215,12 +217,14 @@ class VegtationPlugin(BasicPlugin):
             return
 
         if falg is not None:
-            pth1 = falg.run_alg(pth1, name=name, send_message=self.send_message, **fparams)
-            pth2 = falg.run_alg(pth2, name=name, send_message=self.send_message, **fparams)
+            pth1 = falg.run_alg(
+                pth1, name=name, send_message=self.send_message, **fparams)
+            pth2 = falg.run_alg(
+                pth2, name=name, send_message=self.send_message, **fparams)
 
+        cdpth = cdalg.run_alg(pth1, pth2, layer1.layer_parent,
+                              send_message=self.send_message, **cdparams)
+        thpth = thalg.run_alg(
+            cdpth, name=name, send_message=self.send_message, **thparams)
 
-        cdpth = cdalg.run_alg(pth1, pth2, layer1.layer_parent,  send_message=self.send_message,**cdparams)
-        thpth = thalg.run_alg(cdpth, name=name, send_message=self.send_message, **thparams)
-
-        table_layer(thpth,layer1,name,self.send_message)
-        
+        table_layer(thpth, layer1, name, self.send_message)

plugins/veg_method/scripts/__init__.py

@@ -1,38 +1,43 @@
+from .SH import SH
+from .LHBA import LHBA
+from .OCD import OCD
+from .AHT import AHT
+from .ACD import ACD
+import numpy as np
 from datetime import datetime
 from osgeo import gdal
-import math,os
+import math
+import os
 import time
 from PyQt5 import QtWidgets
 from sklearn.cluster import k_means
 from rscder.utils.geomath import geo2imageRC, imageRC2geo
+from rscder.utils.icons import IconInstance
 from rscder.utils.project import Project, PairLayer
 from misc import Register, AlgFrontend
 
 VEG_CD = Register('植被变化检测方法')
 
-import numpy as np
-from .ACD import ACD
-from .AHT import AHT
-from .OCD import OCD
-from .LHBA import LHBA
-from .SH import SH
 
-def warp(file,ds:gdal.Dataset,srcWin=[0,0,0,0]):
+def warp(file, ds: gdal.Dataset, srcWin=[0, 0, 0, 0]):
     driver = gdal.GetDriverByName('GTiff')
-    xsize=ds.RasterXSize
-    ysize=ds.RasterYSize
-    geo=ds.GetGeoTransform()
-    orj=ds.GetProjection()
-    band=ds.RasterCount
+    xsize = ds.RasterXSize
+    ysize = ds.RasterYSize
+    geo = ds.GetGeoTransform()
+    orj = ds.GetProjection()
+    band = ds.RasterCount
     if os.path.exists(file):
         os.remove(file)
-    out_ds:gdal.Dataset=driver.Create(file, xsize, ysize, band, gdal.GDT_Byte)
+    out_ds: gdal.Dataset = driver.Create(
+        file, xsize, ysize, band, gdal.GDT_Byte)
     out_ds.SetGeoTransform(geo)
     out_ds.SetProjection(orj)
-    for b in range(1,band+1):
-        out_ds.GetRasterBand(b).WriteArray(ds.ReadAsArray(*srcWin,band_list=[b]),*(0,0))
+    for b in range(1, band+1):
+        out_ds.GetRasterBand(b).WriteArray(
+            ds.ReadAsArray(*srcWin, band_list=[b]), *(0, 0))
     del out_ds
 
+
 @VEG_CD.register
 class BasicCD(AlgFrontend):
 
@@ -41,10 +46,14 @@ class BasicCD(AlgFrontend):
         return '差分法'
 
     @staticmethod
-    def run_alg(pth1:str,pth2:str,layer_parent:PairLayer,send_message = None,*args, **kargs):
+    def get_icon():
+        return IconInstance().VEGETATION
 
-        ds1:gdal.Dataset=gdal.Open(pth1)
-        ds2:gdal.Dataset=gdal.Open(pth2)
+    @staticmethod
+    def run_alg(pth1: str, pth2: str, layer_parent: PairLayer, send_message=None, *args, **kargs):
+
+        ds1: gdal.Dataset = gdal.Open(pth1)
+        ds2: gdal.Dataset = gdal.Open(pth2)
 
         cell_size = layer_parent.cell_size
         xsize = layer_parent.size[0]
@@ -56,43 +65,47 @@ class BasicCD(AlgFrontend):
         driver = gdal.GetDriverByName('GTiff')
         out_tif = os.path.join(Project().other_path, 'temp.tif')
         out_ds = driver.Create(out_tif, xsize, ysize, 1, gdal.GDT_Float32)
-        geo=layer_parent.grid.geo
-        proj=layer_parent.grid.proj
+        geo = layer_parent.grid.geo
+        proj = layer_parent.grid.proj
         out_ds.SetGeoTransform(geo)
         out_ds.SetProjection(proj)
 
         max_diff = 0
         min_diff = math.inf
 
-        start1x,start1y=geo2imageRC(ds1.GetGeoTransform(),layer_parent.mask.xy[0],layer_parent.mask.xy[1])
-        end1x,end1y=geo2imageRC(ds1.GetGeoTransform(),layer_parent.mask.xy[2],layer_parent.mask.xy[3])
+        start1x, start1y = geo2imageRC(ds1.GetGeoTransform(
+        ), layer_parent.mask.xy[0], layer_parent.mask.xy[1])
+        end1x, end1y = geo2imageRC(ds1.GetGeoTransform(
+        ), layer_parent.mask.xy[2], layer_parent.mask.xy[3])
 
-        start2x,start2y=geo2imageRC(ds2.GetGeoTransform(),layer_parent.mask.xy[0],layer_parent.mask.xy[1])
-        end2x,end2y=geo2imageRC(ds2.GetGeoTransform(),layer_parent.mask.xy[2],layer_parent.mask.xy[3])
+        start2x, start2y = geo2imageRC(ds2.GetGeoTransform(
+        ), layer_parent.mask.xy[0], layer_parent.mask.xy[1])
+        end2x, end2y = geo2imageRC(ds2.GetGeoTransform(
+        ), layer_parent.mask.xy[2], layer_parent.mask.xy[3])
 
-        for j in range(yblocks + 1):#该改这里了
+        for j in range(yblocks + 1):  # 该改这里了
             if send_message is not None:
                 send_message.emit(f'计算{j}/{yblocks}')
             block_xy1 = (start1x, start1y+j * cell_size[1])
-            block_xy2 = (start2x,start2y+j*cell_size[1])
-            block_xy=(0,j * cell_size[1])
+            block_xy2 = (start2x, start2y+j*cell_size[1])
+            block_xy = (0, j * cell_size[1])
             if block_xy1[1] > end1y or block_xy2[1] > end2y:
                 break
-            block_size=(xsize, cell_size[1])
+            block_size = (xsize, cell_size[1])
             block_size1 = (xsize, cell_size[1])
-            block_size2 = (xsize,cell_size[1])
+            block_size2 = (xsize, cell_size[1])
             if block_xy[1] + block_size[1] > ysize:
                 block_size = (xsize, ysize - block_xy[1])
             if block_xy1[1] + block_size1[1] > end1y:
-                block_size1 = (xsize,end1y - block_xy1[1])
+                block_size1 = (xsize, end1y - block_xy1[1])
             if block_xy2[1] + block_size2[1] > end2y:
                 block_size2 = (xsize, end2y - block_xy2[1])
             block_data1 = ds1.ReadAsArray(*block_xy1, *block_size1)
             block_data2 = ds2.ReadAsArray(*block_xy2, *block_size2)
 
             if band == 1:
-                block_data1 =  block_data1[None, ...]
-                block_data2 =  block_data2[None, ...]
+                block_data1 = block_data1[None, ...]
+                block_data2 = block_data2[None, ...]
             # pdb.set_trace()
             block_diff = block_data1.sum(0) - block_data2.sum(0)
             block_diff = block_diff.astype(np.float32)
@@ -112,8 +125,10 @@ class BasicCD(AlgFrontend):
             send_message.emit('归一化概率中...')
         temp_in_ds = gdal.Open(out_tif)
 
-        out_normal_tif = os.path.join(Project().cmi_path, '{}_{}_cmi.tif'.format(layer_parent.name, int(np.random.rand() * 100000)))
-        out_normal_ds = driver.Create(out_normal_tif, xsize, ysize, 1, gdal.GDT_Byte)
+        out_normal_tif = os.path.join(Project().cmi_path, '{}_{}_cmi.tif'.format(
+            layer_parent.name, int(np.random.rand() * 100000)))
+        out_normal_ds = driver.Create(
+            out_normal_tif, xsize, ysize, 1, gdal.GDT_Byte)
         out_normal_ds.SetGeoTransform(geo)
         out_normal_ds.SetProjection(proj)
         # hist = np.zeros(256, dtype=np.int32)
@@ -141,6 +156,7 @@ class BasicCD(AlgFrontend):
             send_message.emit('差分法计算完成')
         return out_normal_tif
 
+
 @VEG_CD.register
 class LSTS(AlgFrontend):
 
@@ -157,12 +173,12 @@ class LSTS(AlgFrontend):
 
     @staticmethod
     def get_params(widget=None):
-        return dict(n=5, w_size=(3,3))
+        return dict(n=5, w_size=(3, 3))
 
     @staticmethod
-    def run_alg(pth1:str,pth2:str,layer_parent:PairLayer,send_message=None,n=5,w_size=(3,3), *args, **kws):
-        ds1:gdal.Dataset=gdal.Open(pth1)
-        ds2:gdal.Dataset=gdal.Open(pth2)
+    def run_alg(pth1: str, pth2: str, layer_parent: PairLayer, send_message=None, n=5, w_size=(3, 3), *args, **kws):
+        ds1: gdal.Dataset = gdal.Open(pth1)
+        ds2: gdal.Dataset = gdal.Open(pth2)
 
         cell_size = layer_parent.cell_size
         xsize = layer_parent.size[0]
@@ -172,83 +188,90 @@ class LSTS(AlgFrontend):
         yblocks = ysize // cell_size[1]
 
         driver = gdal.GetDriverByName('GTiff')
-        out_tif = os.path.join(Project().other_path, '%d.tif'%(int(datetime.now().timestamp() * 1000)))
+        out_tif = os.path.join(Project().other_path, '%d.tif' % (
+            int(datetime.now().timestamp() * 1000)))
         out_ds = driver.Create(out_tif, xsize, ysize, 1, gdal.GDT_Float32)
-        geo=layer_parent.grid.geo
-        proj=layer_parent.grid.proj
+        geo = layer_parent.grid.geo
+        proj = layer_parent.grid.proj
         out_ds.SetGeoTransform(geo)
         out_ds.SetProjection(proj)
-        pixnum=w_size[0]*w_size[1]
+        pixnum = w_size[0]*w_size[1]
         # send_message.emit('pixnum:'pixnum)
         max_diff = 0
         min_diff = math.inf
-        win_h=w_size[0]//2 #half hight of window 
-        win_w=w_size[1]//2 #half width of window
-        a=[[(i+1)**j for j in range(n+1)] for i in range(pixnum)]
-        A=np.array(a).astype(np.float64)# 
+        win_h = w_size[0]//2  # half hight of window
+        win_w = w_size[1]//2  # half width of window
+        a = [[(i+1)**j for j in range(n+1)] for i in range(pixnum)]
+        A = np.array(a).astype(np.float64)
 
-        k_=np.array(range(1,n+1))
-        df1=np.zeros(pixnum).astype(np.float64)
-        df2=np.zeros(pixnum).astype(np.float64)
+        k_ = np.array(range(1, n+1))
+        df1 = np.zeros(pixnum).astype(np.float64)
+        df2 = np.zeros(pixnum).astype(np.float64)
 
-        start1x,start1y=geo2imageRC(ds1.GetGeoTransform(),layer_parent.mask.xy[0],layer_parent.mask.xy[1])
-        end1x,end1y=geo2imageRC(ds1.GetGeoTransform(),layer_parent.mask.xy[2],layer_parent.mask.xy[3])
+        start1x, start1y = geo2imageRC(ds1.GetGeoTransform(
+        ), layer_parent.mask.xy[0], layer_parent.mask.xy[1])
+        end1x, end1y = geo2imageRC(ds1.GetGeoTransform(
+        ), layer_parent.mask.xy[2], layer_parent.mask.xy[3])
 
-        start2x,start2y=geo2imageRC(ds2.GetGeoTransform(),layer_parent.mask.xy[0],layer_parent.mask.xy[1])
-        end2x,end2y=geo2imageRC(ds2.GetGeoTransform(),layer_parent.mask.xy[2],layer_parent.mask.xy[3])
+        start2x, start2y = geo2imageRC(ds2.GetGeoTransform(
+        ), layer_parent.mask.xy[0], layer_parent.mask.xy[1])
+        end2x, end2y = geo2imageRC(ds2.GetGeoTransform(
+        ), layer_parent.mask.xy[2], layer_parent.mask.xy[3])
 
         for j in range(yblocks + 1):
             if send_message is not None:
                 send_message.emit(f'计算{j}/{yblocks}')
             block_xy1 = (start1x, start1y+j * cell_size[1])
-            block_xy2 = (start2x,start2y+j*cell_size[1])
-            block_xy=(0,j * cell_size[1])
+            block_xy2 = (start2x, start2y+j*cell_size[1])
+            block_xy = (0, j * cell_size[1])
             if block_xy1[1] > end1y or block_xy2[1] > end2y:
                 break
-            block_size=(xsize, cell_size[1])
+            block_size = (xsize, cell_size[1])
             block_size1 = (xsize, cell_size[1])
-            block_size2 = (xsize,cell_size[1])
+            block_size2 = (xsize, cell_size[1])
             if block_xy[1] + block_size[1] > ysize:
                 block_size = (xsize, ysize - block_xy[1])
             if block_xy1[1] + block_size1[1] > end1y:
-                block_size1 = (xsize,end1y - block_xy1[1])
+                block_size1 = (xsize, end1y - block_xy1[1])
             if block_xy2[1] + block_size2[1] > end2y:
                 block_size2 = (xsize, end2y - block_xy2[1])
             block_data1 = ds1.ReadAsArray(*block_xy1, *block_size1)
             block_data2 = ds2.ReadAsArray(*block_xy2, *block_size2)
 
             if band == 1:
-                block_data1 =  block_data1[None, ...]
-                block_data2 =  block_data2[None, ...]
+                block_data1 = block_data1[None, ...]
+                block_data2 = block_data2[None, ...]
             # pdb.set_trace()
             else:
-                block_data1=np.mean(block_data1,0)
-                block_data2=np.mean(block_data2,0)
-            block_diff=np.zeros(block_data1.shape).astype(np.float64)
+                block_data1 = np.mean(block_data1, 0)
+                block_data2 = np.mean(block_data2, 0)
+            block_diff = np.zeros(block_data1.shape).astype(np.float64)
 
-            for i in range(win_h,block_size1[1]-win_h):
-                for j_ in range(win_w,block_size1[0]-win_w):
-                    pix=0
+            for i in range(win_h, block_size1[1]-win_h):
+                for j_ in range(win_w, block_size1[0]-win_w):
+                    pix = 0
 
-                    #get b
+                    # get b
                     # b1=block_data[i+win_h:i+win_h] c in range(j_-win_w,j_+win_w+1)
-                    b1=block_data1[i-win_h:i+win_h+1,j_-win_w:j_+win_w+1]
-                    b2=block_data2[i-win_h:i+win_h+1,j_-win_w:j_+win_w+1]
-                    b1=[b if (r+1)//2 else b[::-1] for r,b in enumerate(b1)]
-                    b2=[b if (r+1)//2 else b[::-1] for r,b in enumerate(b2)]
-                    b1=np.expand_dims(np.concatenate(b1,0),1)
-                    b2=np.expand_dims(np.concatenate(b2,0),1)
+                    b1 = block_data1[i-win_h:i+win_h+1, j_-win_w:j_+win_w+1]
+                    b2 = block_data2[i-win_h:i+win_h+1, j_-win_w:j_+win_w+1]
+                    b1 = [b if (r+1)//2 else b[::-1] for r, b in enumerate(b1)]
+                    b2 = [b if (r+1)//2 else b[::-1] for r, b in enumerate(b2)]
+                    b1 = np.expand_dims(np.concatenate(b1, 0), 1)
+                    b2 = np.expand_dims(np.concatenate(b2, 0), 1)
 
-                    x1=np.squeeze(np.linalg.pinv(A).dot(b1))
-                    x2=np.squeeze(np.linalg.pinv(A).dot(b2))
-                    #df
-                    k_=range(1,n+1)
-                    for pix in range(1,pixnum+1):
-                        df1[pix-1]=x1[1:n+1].dot(np.array([k*(pix**(k-1)) for k in k_]))
-                        df2[pix-1]=x2[1:n+1].dot(np.array([k*(pix**(k-1)) for k in k_]))
+                    x1 = np.squeeze(np.linalg.pinv(A).dot(b1))
+                    x2 = np.squeeze(np.linalg.pinv(A).dot(b2))
+                    # df
+                    k_ = range(1, n+1)
+                    for pix in range(1, pixnum+1):
+                        df1[pix-1] = x1[1:n +
+                                        1].dot(np.array([k*(pix**(k-1)) for k in k_]))
+                        df2[pix-1] = x2[1:n +
+                                        1].dot(np.array([k*(pix**(k-1)) for k in k_]))
 
-                    #distance 欧式距离
-                    block_diff[i][j_]=np.dot(df1-df2,df1-df2)**0.5
+                    # distance 欧式距离
+                    block_diff[i][j_] = np.dot(df1-df2, df1-df2)**0.5
 
             min_diff = min(min_diff, block_diff[block_diff > 0].min())
             max_diff = max(max_diff, block_diff.max())
@@ -263,8 +286,10 @@ class LSTS(AlgFrontend):
             send_message.emit('归一化概率中...')
         temp_in_ds = gdal.Open(out_tif)
 
-        out_normal_tif = os.path.join(Project().cmi_path, '{}_{}_cmi.tif'.format(layer_parent.name, int(np.random.rand() * 100000)))
-        out_normal_ds = driver.Create(out_normal_tif, xsize, ysize, 1, gdal.GDT_Byte)
+        out_normal_tif = os.path.join(Project().cmi_path, '{}_{}_cmi.tif'.format(
+            layer_parent.name, int(np.random.rand() * 100000)))
+        out_normal_ds = driver.Create(
+            out_normal_tif, xsize, ysize, 1, gdal.GDT_Byte)
         out_normal_ds.SetGeoTransform(geo)
         out_normal_ds.SetProjection(proj)
         # hist = np.zeros(256, dtype=np.int32)
@@ -302,10 +327,10 @@ class CVAAlg(AlgFrontend):
         return 'CVA'
 
     @staticmethod
-    def run_alg(pth1:str,pth2:str,layer_parent:PairLayer,send_message = None, *args, **kargs):
+    def run_alg(pth1: str, pth2: str, layer_parent: PairLayer, send_message=None, *args, **kargs):
 
-        ds1:gdal.Dataset=gdal.Open(pth1)
-        ds2:gdal.Dataset=gdal.Open(pth2)
+        ds1: gdal.Dataset = gdal.Open(pth1)
+        ds2: gdal.Dataset = gdal.Open(pth2)
 
         cell_size = layer_parent.cell_size
         xsize = layer_parent.size[0]
@@ -317,45 +342,48 @@ class CVAAlg(AlgFrontend):
         driver = gdal.GetDriverByName('GTiff')
         out_tif = os.path.join(Project().other_path, 'temp.tif')
         out_ds = driver.Create(out_tif, xsize, ysize, 1, gdal.GDT_Float32)
-        geo=layer_parent.grid.geo
-        proj=layer_parent.grid.proj
+        geo = layer_parent.grid.geo
+        proj = layer_parent.grid.proj
         out_ds.SetGeoTransform(geo)
         out_ds.SetProjection(proj)
         max_diff = 0
         min_diff = math.inf
 
+        start1x, start1y = geo2imageRC(ds1.GetGeoTransform(
+        ), layer_parent.mask.xy[0], layer_parent.mask.xy[1])
+        end1x, end1y = geo2imageRC(ds1.GetGeoTransform(
+        ), layer_parent.mask.xy[2], layer_parent.mask.xy[3])
 
-        start1x,start1y=geo2imageRC(ds1.GetGeoTransform(),layer_parent.mask.xy[0],layer_parent.mask.xy[1])
-        end1x,end1y=geo2imageRC(ds1.GetGeoTransform(),layer_parent.mask.xy[2],layer_parent.mask.xy[3])
-
-        start2x,start2y=geo2imageRC(ds2.GetGeoTransform(),layer_parent.mask.xy[0],layer_parent.mask.xy[1])
-        end2x,end2y=geo2imageRC(ds2.GetGeoTransform(),layer_parent.mask.xy[2],layer_parent.mask.xy[3])
+        start2x, start2y = geo2imageRC(ds2.GetGeoTransform(
+        ), layer_parent.mask.xy[0], layer_parent.mask.xy[1])
+        end2x, end2y = geo2imageRC(ds2.GetGeoTransform(
+        ), layer_parent.mask.xy[2], layer_parent.mask.xy[3])
 
         for j in range(yblocks + 1):
             if send_message is not None:
                 send_message.emit(f'计算{j}/{yblocks}')
             block_xy1 = (start1x, start1y+j * cell_size[1])
-            block_xy2 = (start2x,start2y+j*cell_size[1])
-            block_xy=(0,j * cell_size[1])
+            block_xy2 = (start2x, start2y+j*cell_size[1])
+            block_xy = (0, j * cell_size[1])
             if block_xy1[1] > end1y or block_xy2[1] > end2y:
                 break
-            block_size=(xsize, cell_size[1])
+            block_size = (xsize, cell_size[1])
             block_size1 = (xsize, cell_size[1])
-            block_size2 = (xsize,cell_size[1])
+            block_size2 = (xsize, cell_size[1])
             if block_xy[1] + block_size[1] > ysize:
                 block_size = (xsize, ysize - block_xy[1])
             if block_xy1[1] + block_size1[1] > end1y:
-                block_size1 = (xsize,end1y - block_xy1[1])
+                block_size1 = (xsize, end1y - block_xy1[1])
             if block_xy2[1] + block_size2[1] > end2y:
                 block_size2 = (xsize, end2y - block_xy2[1])
             block_data1 = ds1.ReadAsArray(*block_xy1, *block_size1)
             block_data2 = ds2.ReadAsArray(*block_xy2, *block_size2)
 
             if band == 1:
-                block_data1 =  block_data1[None, ...]
-                block_data2 =  block_data2[None, ...]
+                block_data1 = block_data1[None, ...]
+                block_data2 = block_data2[None, ...]
             # pdb.set_trace()
-            block_diff=np.sum((block_data1-block_data2)**2,0)**0.5
+            block_diff = np.sum((block_data1-block_data2)**2, 0)**0.5
             min_diff = min(min_diff, block_diff[block_diff > 0].min())
             max_diff = max(max_diff, block_diff.max())
             out_ds.GetRasterBand(1).WriteArray(block_diff, *block_xy)
@@ -369,8 +397,10 @@ class CVAAlg(AlgFrontend):
             send_message.emit('归一化概率中...')
         temp_in_ds = gdal.Open(out_tif)
 
-        out_normal_tif = os.path.join(Project().cmi_path, '{}_{}_cmi.tif'.format(layer_parent.name, int(np.random.rand() * 100000)))
-        out_normal_ds = driver.Create(out_normal_tif, xsize, ysize, 1, gdal.GDT_Byte)
+        out_normal_tif = os.path.join(Project().cmi_path, '{}_{}_cmi.tif'.format(
+            layer_parent.name, int(np.random.rand() * 100000)))
+        out_normal_ds = driver.Create(
+            out_normal_tif, xsize, ysize, 1, gdal.GDT_Byte)
         out_normal_ds.SetGeoTransform(geo)
         out_normal_ds.SetProjection(proj)
         # hist = np.zeros(256, dtype=np.int32)
@@ -398,6 +428,7 @@ class CVAAlg(AlgFrontend):
             send_message.emit('欧式距离计算完成')
         return out_normal_tif
 
+
 @VEG_CD.register
 class ACDAlg(AlgFrontend):
 
@@ -406,7 +437,7 @@ class ACDAlg(AlgFrontend):
         return 'ACD'
 
     @staticmethod
-    def run_alg(pth1:str,pth2:str,layer_parent:PairLayer,send_message = None, *args, **kargs):
+    def run_alg(pth1: str, pth2: str, layer_parent: PairLayer, send_message=None, *args, **kargs):
 
         if send_message is None:
             class Empty:
@@ -418,39 +449,41 @@ class ACDAlg(AlgFrontend):
 
         xsize = layer_parent.size[0]
         ysize = layer_parent.size[1]
-        geo=layer_parent.grid.geo
-        proj=layer_parent.grid.proj
-        #提取公共部分
+        geo = layer_parent.grid.geo
+        proj = layer_parent.grid.proj
+        # 提取公共部分
         send_message.emit('提取重叠区域数据.....')
 
-        ds2:gdal.Dataset=gdal.Open(pth2)
-        temp_tif2 = os.path.join(Project().other_path,'temp2.tif')
-        start2x,start2y=geo2imageRC(ds2.GetGeoTransform(),layer_parent.mask.xy[0],layer_parent.mask.xy[1])
-        end2x,end2y=geo2imageRC(ds2.GetGeoTransform(),layer_parent.mask.xy[2],layer_parent.mask.xy[3])
-        warp(temp_tif2,ds2,srcWin=[start2x,start2y,xsize,ysize])
+        ds2: gdal.Dataset = gdal.Open(pth2)
+        temp_tif2 = os.path.join(Project().other_path, 'temp2.tif')
+        start2x, start2y = geo2imageRC(ds2.GetGeoTransform(
+        ), layer_parent.mask.xy[0], layer_parent.mask.xy[1])
+        end2x, end2y = geo2imageRC(ds2.GetGeoTransform(
+        ), layer_parent.mask.xy[2], layer_parent.mask.xy[3])
+        warp(temp_tif2, ds2, srcWin=[start2x, start2y, xsize, ysize])
         del ds2
         send_message.emit('图像二提取完成')
 
-
-        ds1:gdal.Dataset=gdal.Open(pth1)
+        ds1: gdal.Dataset = gdal.Open(pth1)
         temp_tif1 = os.path.join(Project().other_path, 'temp1.tif')
-        start1x,start1y=geo2imageRC(ds1.GetGeoTransform(),layer_parent.mask.xy[0],layer_parent.mask.xy[1])
-        end1x,end1y=geo2imageRC(ds1.GetGeoTransform(),layer_parent.mask.xy[2],layer_parent.mask.xy[3])
-        warp(temp_tif1,ds1,srcWin=[start1x,start1y,xsize,ysize])
+        start1x, start1y = geo2imageRC(ds1.GetGeoTransform(
+        ), layer_parent.mask.xy[0], layer_parent.mask.xy[1])
+        end1x, end1y = geo2imageRC(ds1.GetGeoTransform(
+        ), layer_parent.mask.xy[2], layer_parent.mask.xy[3])
+        warp(temp_tif1, ds1, srcWin=[start1x, start1y, xsize, ysize])
         del ds1
         send_message.emit('图像一提取完成')
 
-        
-        
-        #运算
+        # 运算
         send_message.emit('开始ACD计算.....')
         time.sleep(0.1)
-        out_normal_tif = os.path.join(Project().cmi_path, '{}_{}_cmi.tif'.format(layer_parent.name, int(np.random.rand() * 100000)))
-        ACD(temp_tif1,temp_tif2,out_normal_tif)
-        #添加投影
+        out_normal_tif = os.path.join(Project().cmi_path, '{}_{}_cmi.tif'.format(
+            layer_parent.name, int(np.random.rand() * 100000)))
+        ACD(temp_tif1, temp_tif2, out_normal_tif)
+        # 添加投影
         send_message.emit('录入投影信息.....')
         time.sleep(0.1)
-        ds=gdal.Open(out_normal_tif,1)
+        ds = gdal.Open(out_normal_tif, 1)
         ds.SetGeoTransform(geo)
         ds.SetProjection(proj)
         del ds
@@ -466,7 +499,7 @@ class AHTAlg(AlgFrontend):
         return 'AHT'
 
     @staticmethod
-    def run_alg(pth1:str,pth2:str,layer_parent:PairLayer,send_message = None, *args, **kargs):
+    def run_alg(pth1: str, pth2: str, layer_parent: PairLayer, send_message=None, *args, **kargs):
 
         if send_message is None:
             class Empty:
@@ -477,39 +510,41 @@ class AHTAlg(AlgFrontend):
 
         xsize = layer_parent.size[0]
         ysize = layer_parent.size[1]
-        geo=layer_parent.grid.geo
-        proj=layer_parent.grid.proj
-        #提取公共部分
+        geo = layer_parent.grid.geo
+        proj = layer_parent.grid.proj
+        # 提取公共部分
         send_message.emit('提取重叠区域数据.....')
 
-        ds2:gdal.Dataset=gdal.Open(pth2)
-        temp_tif2 = os.path.join(Project().other_path,'temp2.tif')
-        start2x,start2y=geo2imageRC(ds2.GetGeoTransform(),layer_parent.mask.xy[0],layer_parent.mask.xy[1])
-        end2x,end2y=geo2imageRC(ds2.GetGeoTransform(),layer_parent.mask.xy[2],layer_parent.mask.xy[3])
-        warp(temp_tif2,ds2,srcWin=[start2x,start2y,xsize,ysize])
+        ds2: gdal.Dataset = gdal.Open(pth2)
+        temp_tif2 = os.path.join(Project().other_path, 'temp2.tif')
+        start2x, start2y = geo2imageRC(ds2.GetGeoTransform(
+        ), layer_parent.mask.xy[0], layer_parent.mask.xy[1])
+        end2x, end2y = geo2imageRC(ds2.GetGeoTransform(
+        ), layer_parent.mask.xy[2], layer_parent.mask.xy[3])
+        warp(temp_tif2, ds2, srcWin=[start2x, start2y, xsize, ysize])
         del ds2
         send_message.emit('图像二提取完成')
 
-
-        ds1:gdal.Dataset=gdal.Open(pth1)
+        ds1: gdal.Dataset = gdal.Open(pth1)
         temp_tif1 = os.path.join(Project().other_path, 'temp1.tif')
-        start1x,start1y=geo2imageRC(ds1.GetGeoTransform(),layer_parent.mask.xy[0],layer_parent.mask.xy[1])
-        end1x,end1y=geo2imageRC(ds1.GetGeoTransform(),layer_parent.mask.xy[2],layer_parent.mask.xy[3])
-        warp(temp_tif1,ds1,srcWin=[start1x,start1y,xsize,ysize])
+        start1x, start1y = geo2imageRC(ds1.GetGeoTransform(
+        ), layer_parent.mask.xy[0], layer_parent.mask.xy[1])
+        end1x, end1y = geo2imageRC(ds1.GetGeoTransform(
+        ), layer_parent.mask.xy[2], layer_parent.mask.xy[3])
+        warp(temp_tif1, ds1, srcWin=[start1x, start1y, xsize, ysize])
         del ds1
         send_message.emit('图像一提取完成')
 
-        
-        
-        #运算
+        # 运算
         send_message.emit('开始AHT计算.....')
         time.sleep(0.1)
-        out_normal_tif = os.path.join(Project().cmi_path, '{}_{}_cmi.tif'.format(layer_parent.name, int(np.random.rand() * 100000)))
-        AHT(temp_tif1,temp_tif2,out_normal_tif)
-        #添加投影
+        out_normal_tif = os.path.join(Project().cmi_path, '{}_{}_cmi.tif'.format(
+            layer_parent.name, int(np.random.rand() * 100000)))
+        AHT(temp_tif1, temp_tif2, out_normal_tif)
+        # 添加投影
         send_message.emit('录入投影信息.....')
         time.sleep(0.1)
-        ds=gdal.Open(out_normal_tif,1)
+        ds = gdal.Open(out_normal_tif, 1)
         ds.SetGeoTransform(geo)
         ds.SetProjection(proj)
         del ds
@@ -525,7 +560,7 @@ class OCDAlg(AlgFrontend):
         return 'OCD'
 
     @staticmethod
-    def run_alg(pth1:str,pth2:str,layer_parent:PairLayer,send_message = None, *args, **kargs):
+    def run_alg(pth1: str, pth2: str, layer_parent: PairLayer, send_message=None, *args, **kargs):
 
         if send_message is None:
             class Empty:
@@ -536,45 +571,48 @@ class OCDAlg(AlgFrontend):
 
         xsize = layer_parent.size[0]
         ysize = layer_parent.size[1]
-        geo=layer_parent.grid.geo
-        proj=layer_parent.grid.proj
-        #提取公共部分
+        geo = layer_parent.grid.geo
+        proj = layer_parent.grid.proj
+        # 提取公共部分
         send_message.emit('提取重叠区域数据.....')
 
-        ds2:gdal.Dataset=gdal.Open(pth2)
-        temp_tif2 = os.path.join(Project().other_path,'temp2.tif')
-        start2x,start2y=geo2imageRC(ds2.GetGeoTransform(),layer_parent.mask.xy[0],layer_parent.mask.xy[1])
-        end2x,end2y=geo2imageRC(ds2.GetGeoTransform(),layer_parent.mask.xy[2],layer_parent.mask.xy[3])
-        warp(temp_tif2,ds2,srcWin=[start2x,start2y,xsize,ysize])
+        ds2: gdal.Dataset = gdal.Open(pth2)
+        temp_tif2 = os.path.join(Project().other_path, 'temp2.tif')
+        start2x, start2y = geo2imageRC(ds2.GetGeoTransform(
+        ), layer_parent.mask.xy[0], layer_parent.mask.xy[1])
+        end2x, end2y = geo2imageRC(ds2.GetGeoTransform(
+        ), layer_parent.mask.xy[2], layer_parent.mask.xy[3])
+        warp(temp_tif2, ds2, srcWin=[start2x, start2y, xsize, ysize])
         del ds2
         send_message.emit('图像二提取完成')
 
-
-        ds1:gdal.Dataset=gdal.Open(pth1)
+        ds1: gdal.Dataset = gdal.Open(pth1)
         temp_tif1 = os.path.join(Project().other_path, 'temp1.tif')
-        start1x,start1y=geo2imageRC(ds1.GetGeoTransform(),layer_parent.mask.xy[0],layer_parent.mask.xy[1])
-        end1x,end1y=geo2imageRC(ds1.GetGeoTransform(),layer_parent.mask.xy[2],layer_parent.mask.xy[3])
-        warp(temp_tif1,ds1,srcWin=[start1x,start1y,xsize,ysize])
+        start1x, start1y = geo2imageRC(ds1.GetGeoTransform(
+        ), layer_parent.mask.xy[0], layer_parent.mask.xy[1])
+        end1x, end1y = geo2imageRC(ds1.GetGeoTransform(
+        ), layer_parent.mask.xy[2], layer_parent.mask.xy[3])
+        warp(temp_tif1, ds1, srcWin=[start1x, start1y, xsize, ysize])
         del ds1
         send_message.emit('图像一提取完成')
 
-        
-        
-        #运算
+        # 运算
         send_message.emit('开始OCD计算.....')
         time.sleep(0.1)
-        out_normal_tif = os.path.join(Project().cmi_path, '{}_{}_cmi.tif'.format(layer_parent.name, int(np.random.rand() * 100000)))
-        OCD(temp_tif1,temp_tif2,out_normal_tif,Project().other_path)
-        #添加投影
+        out_normal_tif = os.path.join(Project().cmi_path, '{}_{}_cmi.tif'.format(
+            layer_parent.name, int(np.random.rand() * 100000)))
+        OCD(temp_tif1, temp_tif2, out_normal_tif, Project().other_path)
+        # 添加投影
         send_message.emit('录入投影信息.....')
         time.sleep(0.1)
-        ds=gdal.Open(out_normal_tif,1)
+        ds = gdal.Open(out_normal_tif, 1)
         ds.SetGeoTransform(geo)
         ds.SetProjection(proj)
         del ds
 
         return out_normal_tif
 
+
 @VEG_CD.register
 class LHBAAlg(AlgFrontend):
 
@@ -583,7 +621,7 @@ class LHBAAlg(AlgFrontend):
         return 'LHBA'
 
     @staticmethod
-    def run_alg(pth1:str,pth2:str,layer_parent:PairLayer,send_message = None, *args, **kargs):
+    def run_alg(pth1: str, pth2: str, layer_parent: PairLayer, send_message=None, *args, **kargs):
 
         if send_message is None:
             class Empty:
@@ -592,40 +630,43 @@ class LHBAAlg(AlgFrontend):
                     print(args)
             send_message = Empty()
 
-
         xsize = layer_parent.size[0]
         ysize = layer_parent.size[1]
-        geo=layer_parent.grid.geo
-        proj=layer_parent.grid.proj
-        #提取公共部分
+        geo = layer_parent.grid.geo
+        proj = layer_parent.grid.proj
+        # 提取公共部分
         send_message.emit('提取重叠区域数据.....')
 
-        ds2:gdal.Dataset=gdal.Open(pth2)
-        temp_tif2 = os.path.join(Project().other_path,'temp2.tif')
-        start2x,start2y=geo2imageRC(ds2.GetGeoTransform(),layer_parent.mask.xy[0],layer_parent.mask.xy[1])
-        end2x,end2y=geo2imageRC(ds2.GetGeoTransform(),layer_parent.mask.xy[2],layer_parent.mask.xy[3])
-        warp(temp_tif2,ds2,srcWin=[start2x,start2y,xsize,ysize])
+        ds2: gdal.Dataset = gdal.Open(pth2)
+        temp_tif2 = os.path.join(Project().other_path, 'temp2.tif')
+        start2x, start2y = geo2imageRC(ds2.GetGeoTransform(
+        ), layer_parent.mask.xy[0], layer_parent.mask.xy[1])
+        end2x, end2y = geo2imageRC(ds2.GetGeoTransform(
+        ), layer_parent.mask.xy[2], layer_parent.mask.xy[3])
+        warp(temp_tif2, ds2, srcWin=[start2x, start2y, xsize, ysize])
         del ds2
         send_message.emit('图像二提取完成')
 
-
-        ds1:gdal.Dataset=gdal.Open(pth1)
+        ds1: gdal.Dataset = gdal.Open(pth1)
         temp_tif1 = os.path.join(Project().other_path, 'temp1.tif')
-        start1x,start1y=geo2imageRC(ds1.GetGeoTransform(),layer_parent.mask.xy[0],layer_parent.mask.xy[1])
-        end1x,end1y=geo2imageRC(ds1.GetGeoTransform(),layer_parent.mask.xy[2],layer_parent.mask.xy[3])
-        warp(temp_tif1,ds1,srcWin=[start1x,start1y,xsize,ysize])
+        start1x, start1y = geo2imageRC(ds1.GetGeoTransform(
+        ), layer_parent.mask.xy[0], layer_parent.mask.xy[1])
+        end1x, end1y = geo2imageRC(ds1.GetGeoTransform(
+        ), layer_parent.mask.xy[2], layer_parent.mask.xy[3])
+        warp(temp_tif1, ds1, srcWin=[start1x, start1y, xsize, ysize])
         del ds1
         send_message.emit('图像一提取完成')
 
-        #运算
+        # 运算
         send_message.emit('开始LHBA计算.....')
         time.sleep(0.1)
-        out_normal_tif = os.path.join(Project().cmi_path, '{}_{}_cmi.tif'.format(layer_parent.name, int(np.random.rand() * 100000)))
-        LHBA(temp_tif1,temp_tif2,out_normal_tif)
-        #添加投影
+        out_normal_tif = os.path.join(Project().cmi_path, '{}_{}_cmi.tif'.format(
+            layer_parent.name, int(np.random.rand() * 100000)))
+        LHBA(temp_tif1, temp_tif2, out_normal_tif)
+        # 添加投影
         send_message.emit('录入投影信息.....')
         time.sleep(0.1)
-        ds=gdal.Open(out_normal_tif,1)
+        ds = gdal.Open(out_normal_tif, 1)
         ds.SetGeoTransform(geo)
         ds.SetProjection(proj)
         del ds
@@ -640,7 +681,7 @@ class SHAlg(AlgFrontend):
         return 'SH'
 
     @staticmethod
-    def run_alg(pth1:str,pth2:str,layer_parent:PairLayer,send_message = None, *args, **kargs):
+    def run_alg(pth1: str, pth2: str, layer_parent: PairLayer, send_message=None, *args, **kargs):
 
         if send_message is None:
             class Empty:
@@ -649,41 +690,43 @@ class SHAlg(AlgFrontend):
                     print(args)
             send_message = Empty()
 
-
-
         xsize = layer_parent.size[0]
         ysize = layer_parent.size[1]
-        geo=layer_parent.grid.geo
-        proj=layer_parent.grid.proj
-        #提取公共部分
+        geo = layer_parent.grid.geo
+        proj = layer_parent.grid.proj
+        # 提取公共部分
         send_message.emit('提取重叠区域数据.....')
 
-        ds2:gdal.Dataset=gdal.Open(pth2)
-        temp_tif2 = os.path.join(Project().other_path,'temp2.tif')
-        start2x,start2y=geo2imageRC(ds2.GetGeoTransform(),layer_parent.mask.xy[0],layer_parent.mask.xy[1])
-        end2x,end2y=geo2imageRC(ds2.GetGeoTransform(),layer_parent.mask.xy[2],layer_parent.mask.xy[3])
-        warp(temp_tif2,ds2,srcWin=[start2x,start2y,xsize,ysize])
+        ds2: gdal.Dataset = gdal.Open(pth2)
+        temp_tif2 = os.path.join(Project().other_path, 'temp2.tif')
+        start2x, start2y = geo2imageRC(ds2.GetGeoTransform(
+        ), layer_parent.mask.xy[0], layer_parent.mask.xy[1])
+        end2x, end2y = geo2imageRC(ds2.GetGeoTransform(
+        ), layer_parent.mask.xy[2], layer_parent.mask.xy[3])
+        warp(temp_tif2, ds2, srcWin=[start2x, start2y, xsize, ysize])
         del ds2
         send_message.emit('图像二提取完成')
 
-
-        ds1:gdal.Dataset=gdal.Open(pth1)
+        ds1: gdal.Dataset = gdal.Open(pth1)
         temp_tif1 = os.path.join(Project().other_path, 'temp1.tif')
-        start1x,start1y=geo2imageRC(ds1.GetGeoTransform(),layer_parent.mask.xy[0],layer_parent.mask.xy[1])
-        end1x,end1y=geo2imageRC(ds1.GetGeoTransform(),layer_parent.mask.xy[2],layer_parent.mask.xy[3])
-        warp(temp_tif1,ds1,srcWin=[start1x,start1y,xsize,ysize])
+        start1x, start1y = geo2imageRC(ds1.GetGeoTransform(
+        ), layer_parent.mask.xy[0], layer_parent.mask.xy[1])
+        end1x, end1y = geo2imageRC(ds1.GetGeoTransform(
+        ), layer_parent.mask.xy[2], layer_parent.mask.xy[3])
+        warp(temp_tif1, ds1, srcWin=[start1x, start1y, xsize, ysize])
         del ds1
         send_message.emit('图像一提取完成')
 
-        #运算
+        # 运算
         send_message.emit('开始SH计算.....')
         time.sleep(0.1)
-        out_normal_tif = os.path.join(Project().cmi_path, '{}_{}_cmi.tif'.format(layer_parent.name, int(np.random.rand() * 100000)))
-        SH(temp_tif1,temp_tif2,out_normal_tif)
-        #添加投影
+        out_normal_tif = os.path.join(Project().cmi_path, '{}_{}_cmi.tif'.format(
+            layer_parent.name, int(np.random.rand() * 100000)))
+        SH(temp_tif1, temp_tif2, out_normal_tif)
+        # 添加投影
         send_message.emit('录入投影信息.....')
         time.sleep(0.1)
-        ds=gdal.Open(out_normal_tif,1)
+        ds = gdal.Open(out_normal_tif, 1)
         ds.SetGeoTransform(geo)
         ds.SetProjection(proj)
         del ds

rscder/utils/icons.py

@@ -2,6 +2,7 @@ from PyQt5.QtGui import QIcon
 from PyQt5.QtCore import QObject
 from .misc import singleton
 
+
 @singleton
 class IconInstance(QObject):
 
@@ -46,6 +47,10 @@ class IconInstance(QObject):
         self.RASTER = QIcon('./icons/影像.png')
         self.VEGETATION = QIcon('./icons/植被变化.png')
         self.NOISE = QIcon('./icons/噪声处理.png')
+        self.ARITHMETIC1 = QIcon('./icons/Algorithm_icon/功能-01.png')
+        self.ARITHMETIC2 = QIcon('./icons/Algorithm_icon/功能-02.png')
+        self.ARITHMETIC3 = QIcon('./icons/Algorithm_icon/功能-03.png')
+        self.ARITHMETIC3.QSize()
 
         self.DATA_LOAD = QIcon('./icons/数据加载.png')
 

test-data/test01/test01.prj

@@ -0,0 +1,22 @@
+cell_size:
+- 100
+- 100
+layers:
+- enable: true
+  layers: []
+  name: AAA.-BBB.
+  pth1: E:/xhong/CVEOdemo/fourth/rscder/test-data/AAA.tif
+  pth2: E:/xhong/CVEOdemo/fourth/rscder/test-data/BBB.tif
+  style_info1:
+    NIR: 4
+    b: 3
+    g: 2
+    r: 1
+  style_info2:
+    NIR: 4
+    b: 3
+    g: 2
+    r: 1
+max_memory: 100
+max_threads: 4
+root: E:\xhong\CVEOdemo\fourth\rscder\test-data\test01