Upload 4 files

app.py

@@ -0,0 +1,191 @@
+# %%
+import gradio as gr
+from sklearn import preprocessing
+import collections
+import SimpleITK as sitk
+from radiomics import featureextractor
+import os
+import numpy as np
+from sklearn.preprocessing import StandardScaler
+
+# %%
+
+
+def resize_image_itk(itkimage, newSize, resamplemethod=sitk.sitkLinear):
+
+    resampler = sitk.ResampleImageFilter()
+    originSize = itkimage.GetSize()  # 原来的体素块尺寸
+    # print(originSize)
+    originSpacing = itkimage.GetSpacing()
+    newSize = np.array(newSize, float)
+    factor = originSize / newSize
+    newSpacing = originSpacing * factor
+    newSize = newSize.astype(np.int0)  # spacing肯定不能是整数
+    resampler.SetReferenceImage(itkimage)  # 需要重新采样的目标图像
+    resampler.SetSize(newSize.tolist())
+    resampler.SetOutputSpacing(newSpacing.tolist())
+    resampler.SetTransform(sitk.Transform(3, sitk.sitkIdentity))
+    resampler.SetInterpolator(resamplemethod)
+    itkimgResampled = resampler.Execute(itkimage)  # 得到重新采样后的图像
+    # print(itkimgResampled.GetSize())
+
+    return itkimgResampled
+
+
+def load_image(img):
+
+    # imgfilePath = os.path.join(img_path, img_name)
+    imgfilePath = img
+    if not os.path.isfile(imgfilePath):
+        print('Error: IMAGE DIR READ FAILED!')
+
+    # mskfilePath = imgfilePath + '.img'
+    '''
+    # 读取.dcm Series
+    reader = sitk.ImageSeriesReader()
+    dcm_series = reader.GetGDCMSeriesFileNames(imgfilePath)
+    reader.SetFileNames(dcm_series)
+    image = reader.Execute()
+    mask = sitk.ReadImage(mskfilePath)
+    '''
+    # 读取.png或.jpeg图像——可在此处更换读取IO适应不同格式图像
+    if imgfilePath[-4:] == '.png':
+        image = sitk.ReadImage(
+            imgfilePath, imageIO="PNGImageIO", outputPixelType=sitk.sitkInt16)
+    else:
+        image = sitk.ReadImage(
+            imgfilePath, imageIO="JPEGImageIO", outputPixelType=sitk.sitkInt16)
+
+    # resize_img = resize_image_itk(image, newSize=(512, 512))
+
+    # img_array = sitk.GetArrayFromImage(resize_img)
+
+    return image  # np.asarray(image)
+
+
+def feature_extractor(img):
+
+    image = load_image(img)
+    params = 'settings.yaml'
+    if os.path.isfile(params):
+        extractor = featureextractor.RadiomicsFeatureExtractor(
+            params)
+
+    else:
+        settings = {}
+        settings['binWidth'] = 25
+        settings['resampledPixelSpacing'] = [3, 3, 3]
+        settings['interpolator'] = sitk.sitkBSpline
+        settings['enableCExtensions'] = True
+
+        extractor = featureextractor.RadiomicsFeatureExtractor(**settings)
+
+    headers = None
+    featureVector = collections.OrderedDict()
+
+    # image = sitk.GetImageFromArray(img_array)
+    img_array = sitk.GetArrayFromImage(image)
+    mask = sitk.GetImageFromArray(np.ones_like(img_array), isVector=True)
+
+    mask.CopyInformation(image)
+
+    row = []
+    # try:
+    featureVector.update(extractor.execute(
+        image, mask, label=1))  # 提取特征ROI区域 label=1,2,3,4
+    if headers is None:
+        headers = list(featureVector.keys())  # [22:]
+
+    for h in headers:
+        row.append(featureVector.get(h, "N/A"))
+    # except Exception:
+    #     print('Error: FEATURE EXTRACTION FAILED!')
+
+    return np.array(row[22:])
+
+
+def tansig(x):
+    return (2/(1+np.exp(-2*x)))-1
+
+
+def to_proba(output):
+    output = output-np.min(output)
+    ret = (output-np.min(output))/(np.max(output)-np.min(output))
+    return ret
+
+
+def softmax(x):
+    x = x-np.min(x)
+    ex = np.exp(x)
+    return ex/ex.sum()
+
+
+labels = ['covid', 'nofindings', 'pneumonia']
+
+
+def predict(test_img):
+
+    params = np.load('params.npz')
+    N1 = params['N1']
+    N2 = params['N2']
+    Beta1OfEachWindow = params['Beta1OfEachWindow']
+    ymax = params['ymax']
+    ymin = params['ymin']
+    minOfEachWindow = params['minOfEachWindow']
+    distOfMaxAndMin = params['distOfMaxAndMin']
+    weightOfEnhanceLayer = params['weightOfEnhanceLayer']
+    parameterOfShrink = params['parameterOfShrink']
+    OutputWeight = params['OutputWeight']
+
+    test_x = feature_extractor(test_img).reshape(1, -1)
+    scaler = StandardScaler()
+    test_x = scaler.fit_transform(test_x)
+    print(test_x.shape)
+    # test_x = np.expand_dims(test_x, axis=0)
+    # print(test_x.shape)
+    test_x = preprocessing.scale(test_x, axis=1)
+
+    FeatureOfInputDataWithBiasTest = np.hstack(
+        [test_x, 0.1 * np.ones((test_x.shape[0], 1))])
+    OutputOfFeatureMappingLayerTest = np.zeros(
+        [test_x.shape[0],  N2 * N1])
+
+    for i in range(N2):
+        outputOfEachWindowTest = np.dot(
+            FeatureOfInputDataWithBiasTest,  Beta1OfEachWindow[i])
+        OutputOfFeatureMappingLayerTest[:,  N1*i: N1*(i+1)] = (ymax - ymin)*(
+            outputOfEachWindowTest - minOfEachWindow[i]) / distOfMaxAndMin[i] - ymin
+
+    InputOfEnhanceLayerWithBiasTest = np.hstack(
+        [OutputOfFeatureMappingLayerTest, 0.1 * np.ones((OutputOfFeatureMappingLayerTest.shape[0], 1))])
+    tempOfOutputOfEnhanceLayerTest = np.dot(
+        InputOfEnhanceLayerWithBiasTest,  weightOfEnhanceLayer)
+
+    OutputOfEnhanceLayerTest = tansig(
+        tempOfOutputOfEnhanceLayerTest * parameterOfShrink)
+
+    InputOfOutputLayerTest = np.hstack(
+        [OutputOfFeatureMappingLayerTest, OutputOfEnhanceLayerTest])
+
+    OutputOfTest = np.dot(InputOfOutputLayerTest,  OutputWeight)
+    # print(OutputOfTest.shape)
+    OutputOfTest = np.squeeze(OutputOfTest)
+    proba = OutputOfTest  # softmax(OutputOfTest)
+    confidences = {labels[i]: float(proba[i]) for i in range(3)}
+    # np.argmax(OutputOfTest, axis=1)  # np.array(OutputOfTest)
+    return confidences
+
+
+# %%
+# pth = '01E392EE-69F9-4E33-BFCE-E5C968654078.jpeg'
+# predict(pth)
+
+# %%
+
+demo = gr.Interface(fn=predict,
+                    inputs=gr.Image(type="filepath"),
+                    outputs=gr.Label()
+                    )
+demo.launch(share=False)
+
+# %%

params.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1eccc3eea4d4ee28bdb68bcb253f2ebf5f8545ce97685dc26a043d731cda911a
+size 135798

requirements.txt

@@ -0,0 +1,6 @@
+gradio==3.22.1
+numpy==1.21.6
+pyradiomics==3.0.1
+radiomics==0.1
+scikit_learn==1.2.2
+SimpleITK==2.2.1

settings.yaml

@@ -0,0 +1,83 @@
+# This is an example of settings that can be used as a starting point for analyzing CT data. This is only intended as a
+# starting point and is not likely to be the optimal settings for your dataset. Some points in determining better values
+# are added as comments where appropriate
+
+# When adapting and using these settings for an analysis, be sure to add the PyRadiomics version used to allow you to
+# easily recreate your extraction at a later timepoint:
+
+# #############################  Extracted using PyRadiomics version: <version>  ######################################
+
+imageType:
+  Original: {}
+  #LoG:
+  #  sigma: [1.0, 2.0] #, 3.0, 4.0, 5.0] # If you include sigma values >5, remember to also increase the padDistance.
+  Wavelet: {}
+
+featureClass:
+  # redundant Compactness 1, Compactness 2 an Spherical Disproportion features are disabled by default, they can be
+  # enabled by specifying individual feature names (as is done for glcm) and including them in the list.
+  #shape:
+  firstorder:
+  glcm: # Disable SumAverage by specifying all other GLCM features available
+    - "Autocorrelation"
+    - "JointAverage"
+    - "ClusterProminence"
+    - "ClusterShade"
+    - "ClusterTendency"
+    - "Contrast"
+    - "Correlation"
+    - "DifferenceAverage"
+    - "DifferenceEntropy"
+    - "DifferenceVariance"
+    - "JointEnergy"
+    - "JointEntropy"
+    - "Imc1"
+    - "Imc2"
+    - "Idm"
+    - "Idmn"
+    - "Id"
+    - "Idn"
+    - "InverseVariance"
+    - "MaximumProbability"
+    - "SumEntropy"
+    - "SumSquares"
+  #glrlm:
+  #glszm:
+  gldm:
+
+setting:
+  # Normalization:
+  # most likely not needed, CT gray values reflect absolute world values (HU) and should be comparable between scanners.
+  # If analyzing using different scanners / vendors, check if the extracted features are correlated to the scanner used.
+  # If so, consider enabling normalization by uncommenting settings below:
+  #normalize: true
+  #normalizeScale: 500  # This allows you to use more or less the same bin width.
+
+  # Resampling:
+  # Usual spacing for CT is often close to 1 or 2 mm, if very large slice thickness is used,
+  # increase the resampled spacing.
+  # On a side note: increasing the resampled spacing forces PyRadiomics to look at more coarse textures, which may or
+  # may not increase accuracy and stability of your extracted features.
+  #interpolator: "sitkBSpline"
+  #resampledPixelSpacing: [1, 1]
+  # padDistance: 10 # Extra padding for large sigma valued LoG filtered images
+
+  # Mask validation:
+  # correctMask and geometryTolerance are not needed, as both image and mask are resampled, if you expect very small
+  # masks, consider to enable a size constraint by uncommenting settings below:
+  #minimumROIDimensions: 2
+  #minimumROISize: 50
+
+  # Image discretization:
+  # The ideal number of bins is somewhere in the order of 16-128 bins. A possible way to define a good binwidt is to
+  # extract firstorder:Range from the dataset to analyze, and choose a binwidth so, that range/binwidth remains approximately
+  # in this range of bins.
+  binWidth: 25
+
+  # first order specific settings:
+  #voxelArrayShift: 1000 # Minimum value in HU is -1000, shift +1000 to prevent negative values from being squared.
+
+  # Misc:
+  # default label value. Labels can also be defined in the call to featureextractor.execute, as a commandline argument,
+  # or in a column "Label" in the input csv (batchprocessing)
+  label: 1