• 病理图像反卷积

    目录

    介绍

    环境

    运行步骤

    OpticalDensity.py

     hsd.py

     ColorDeconvolution.py

     一共会有6张图的结果，最后一张是原图：

     最后

    源代码： 

    介绍

    颜色反卷积算法的设计针对RGB摄像机获取的颜色信息，基于免疫组化技术使用的染色剂RGB分量光的特异性吸收，分别计算每种染色剂对图像的作用效果。免疫组织化学图像处理通常用的染色包括DAB、H&E。

    颜色反卷积可应用于H-DAB图像和组织病理学中常用的染色剂（H-E,H AEC,FAST Red，DAB），广泛应用于免疫组化染色图像颜色分离。

    环境

    #### Language de programmation : Python 2.7
    #### Libs : numpy, matplotlib, sikit-learn, PySide, OpenCV2

    运行步骤

    1.运行ColorDeconvolution.py或者hsd.py，可以生成反卷积后的图像（一共有6个图），依据情况选择结果。
    2.得到的HSI_Teinte_t1.png图像，灰度值比较低，在PS里面先用：图像-调整-曲线-自动，增加灰度值，再图像-调整-反相

    • 一共三个文件，放在一个文件夹即可

    OpticalDensity.py

    1. import numpy as np
    2. from matplotlib import pyplot as plt
    3.  
    4. def rgb_2_od(img):
    5.     s = img.shape
    6.     od = np.zeros(s)
    7.     if (len(img)==3):
    8.         for i in range(s[0]):
    9.             for j in range(s[1]):
    10.                 for k in range(s[2]):
    11.                     if img[i, j, k] != 0:
    12.                         od[i, j, k] = np.log10(img[i, j, k])
    13.     else:
    14.         for i in range(s[0]):
    15.             for j in range(s[1]):
    16.                 od[i, j] = np.log10(img[i, j])
    17.     plt.title("Espace OD")
    18.     plt.imshow(od)
    19.     plt.show()
    20.     return od
    21. def rgb_2_od2(img):
    22.     s = img.shape
    23.     od = np.zeros(s)
    24.     if (len(img)==3):
    25.         for i in range(s[0]):
    26.             for j in range(s[1]):
    27.                 for k in range(s[2]):
    28.                     if img[i, j, k] != 0:
    29.                         od[i, j, k] = np.log10(img[i, j, k])
    30.     else:
    31.         for i in range(s[0]):
    32.             for j in range(s[1]):
    33.                 od[i, j] = np.log10(img[i, j])
    34.     return od
    35.  
    36. if __name__ == "__main__":
    37.     # reading the image
    38.     # path="Tumor_CD31_LoRes.png"
    39.     path = "../DataSet/BreastCancerCell_dataset/ytma10_010704_benign1_ccd.tif"
    40.     img = plt.imread(path)
    41.     img = img[:, :, 0:3].astype(np.double)
    42.  
    43.     rgb_2_od(img)

     hsd.py

    1. #coding:  utf-8
    2. import numpy as np
    3. import matplotlib.pyplot as plt
    4. import OpticalDensity as od
    5. from sklearn.cluster import KMeans
    6. from matplotlib import cm
    7. import cv2
    8. from PIL import Image
    9.  
    10. class HSD:
    11.     def __init__(self, img,path,type):
    12.         """
    13.         :param img: image en entrer pour changer d'espace de couleur
    14.             chroma : matrice de chromaticité. de dimension
    15.                     [
    16.                      l: nbr de ligne ,
    17.                      c: nbr de colone,
    18.                      d: dimension 2 qui represente les coordonée chromatique
    19.                     ]
    20.         :fonctions :
    21.             - rgb_2_gray : transfomé en gris
    22.             - chromaticite : calculer les coordonnées chromatiques
    23.             - calcule_HSI : calculer le nouvel espace Hue Saturation Intensity
    24.         """
    25.         self.img_0 = img
    26.         self.img_hsi = None
    27.         self.chroma = None
    28.         self.imgReconstruite=None
    29.         self.intensity=None
    30.         self.path=path
    31.         self.path2="../Color-Deconvolution/Resultat"
    32.         self.type=type
    33.         self.imageBinariser=None
    34.  
    35.     def getRed(self):
    36.         return self.img_0[:,:,0]
    37.  
    38.     def getGreen(self):
    39.         return self.img_0[:,:,1]
    40.  
    41.     def getBlue(self):
    42.         return self.img_0[:,:,2]
    43.  
    44.     def GlobalIntensity(self):
    45.         self.intensity = np.zeros([self.img_0.shape[0], self.img_0.shape[1]])
    46.         for i in range(self.img_0.shape[0]):
    47.             for j in range(self.img_0.shape[1]):
    48.                 self.intensity[i, j] = (self.getRed()[i,j]+ self.getGreen()[i,j] + self.getBlue()[i,j]) / 3
    49.  
    50.     def RGB_2_GRAY(self):
    51.         [l, c, d] = self.img_0.shape
    52.         gray = np.zeros([l, c])
    53.         for i in range(l):
    54.             for j in range(c):
    55.                 gray[i, j] = sum(self.img_0[i, j])/3
    56.         return gray
    57.  
    58.     def chromaticite(self):
    59.         [l, c, d] = self.img_0.shape
    60.         gray = self.RGB_2_GRAY()
    61.         self.chroma = np.zeros([l, c, 2])
    62.         for i in range(l):
    63.             for j in range(c):
    64.  
    65.                 self.chroma[i, j ,0] = (self.img_0[i, j, 0] / gray[i, j]) - 1 if (gray[i, j] - 1) != 0 else 0
    66.                 self.chroma[i, j, 1] = (self.img_0[i, j, 1] - self.img_0[i, j, 2]) / (gray[i, j] * np.sqrt(3)) if (gray[i, j] * np.sqrt(3)) !=0 else 0
    67.  
    68.  
    69.     def calcule_HSI(self):
    70.         [l, c, d] = self.img_0.shape
    71.         gray = self.RGB_2_GRAY()
    72.         self.img_hsi = np.zeros([l, c, 3])
    73.         self.img_hsi[:, :, 2] = gray
    74.         for i in range(l):
    75.             for j in range(c):
    76.                 self.img_hsi[i, j, 0] = self.getHue2(self.chroma[i, j, 0], self.chroma[i, j ,1])
    77.                 self.img_hsi[i, j, 1] = self.getSaturation2(self.chroma[i, j ,0], self.chroma[i, j ,1])
    78.  
    79.     def getSaturation2(self, cx, cy):
    80.         return np.sqrt(np.square(cx)+np.square(cy))
    81.  
    82.     def getHue2(self, cx, cy):
    83.         return 0 if cx==0 else np.arctan(cy/cx)
    84.  
    85.     def getCX(self,hue,saturation):
    86.         return saturation*np.cos(hue)
    87.  
    88.     def getCY(self,hue,saturation):
    89.         return saturation*np.sin(hue)
    90.     # plotHSD permet de afficher les images de chaque canal de la hsd en gray
    91.     def plotHSD(self):
    92.         plt.subplot(1,3,1)
    93.         plt.imshow(self.img_hsi[:,:,0], cmap="gray")
    94.  
    95.         plt.subplot(1,3,2)
    96.         plt.imshow(self.img_hsi[:, :, 1], cmap="gray")
    97.  
    98.         plt.subplot(1, 3, 3)
    99.         plt.imshow(self.img_hsi[:, :, 2], cmap="gray")
    100.         plt.show()
    101.     # Afficher le plot manuellement selon les valeurs de chroma
    102.     def plotHS(self,Z):
    103.         for i in range(Z.shape[0]):
    104.             for j in range(Z.shape[1]):
    105.                 if Z[i][j]==0:
    106.                     c1 = plt.scatter(self.chroma[i,j,0], self.chroma[i,j, 1], c='r', marker='+')
    107.                 elif Z[i][j]==1:
    108.                     c2 = plt.scatter(self.chroma[i, j, 0], self.chroma[i, j, 1], c='b', marker='o')
    109.                 elif Z[i][j]==2:
    110.                     c3 = plt.scatter(self.chroma[i, j, 0], self.chroma[i, j, 1], c='g', marker='*')
    111.                 elif Z[i][j]==3:
    112.                     c4 = plt.scatter(self.chroma[i, j, 0], self.chroma[i, j, 1], c='black', marker='l')
    113.  
    114.         plt.legend([c1, c2, c3], ['Cluster 0', 'Cluster 1','Cluster 2'])
    115.         plt.title('K-means clusters into 3 clusters')
    116.         plt.show()
    117.  
    118.     def plotHS2(self,Z):
    119.         Z=np.reshape(Z,(self.chroma.shape[0]*self.chroma.shape[1],1))
    120.         print (Z.shape)
    121.         c1=0
    122.         vec = np.reshape(self.chroma, (self.chroma.shape[0] * self.chroma.shape[1], 2))
    123.         vec1 = []
    124.         vec2 = []
    125.         vec3 = []
    126.         for i in range(Z.shape[0]):
    127.             if Z[i]==0:
    128.                 vec1.append(vec[i])
    129.             elif Z[i]==1:
    130.                 vec2.append(vec[i])
    131.             elif Z[i]==2:
    132.                 vec3.append(vec[i])
    133.         # print len(vec1)
    134.  
    135.         c1 = plt.scatter(vec1[1:,0], vec1[1:,1], c='r', marker='+')
    136.  
    137.         c2 = plt.scatter(vec2[1:,0], vec2[1:,1], c='g', marker='o')
    138.  
    139.         c3 = plt.scatter(vec3[1:,0], vec3[1:,1], c='b', marker='*')
    140.         plt.legend([c1, c2, c3], ['Cluster 0', 'Cluster 1', 'Cluster 2'])
    141.         plt.title('K-means clusters into 3 clusters')
    142.         plt.show()
    143.         print ("finish")
    144.  
    145.  
    146.     def Kmeans(self,cluster):
    147.         np.random.seed(42)
    148.         vec=np.reshape(self.chroma, (self.chroma.shape[0]*self.chroma.shape[1],2))
    149.         kmeans = KMeans(n_clusters=cluster, random_state=0)
    150.         kmeans.fit(vec)
    151.         kmeans.labels_=np.reshape(kmeans.labels_,(self.chroma.shape[0],self.chroma.shape[1]))
    152.         Z=np.reshape(kmeans.labels_,self.chroma.shape[0]*self.chroma.shape[1],2)
    153.         Z=np.reshape(Z[:100],(10,10))
    154.         return Z
    155.  
    156.     def Kmeans2(self,cluster):
    157.         np.random.seed(42)
    158.         vec=np.reshape(self.chroma, (self.chroma.shape[0]*self.chroma.shape[1],2))
    159.         kmeans = KMeans(n_clusters=cluster, random_state=0)
    160.         kmeans.fit(vec)
    161.         plt.scatter(vec[:1000, 0], vec[:1000, 1], c=kmeans.labels_[:1000])
    162.         plt.show()
    163.  
    164.     def binarisation(self):
    165.  
    166.         # Otsu's thresholding after Gaussian filtering
    167.         # il faut lui donner image self.imgReconstruite et binariser chaque canal hue saturation et density
    168.  
    169.  
    170.         blur1 = cv2.GaussianBlur((self.imgReconstruite[:, :, 0]*255).astype(np.uint8), (5, 5), 0)
    171.         ret1, th1 = cv2.threshold(blur1, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
    172.  
    173.  
    174.         blur2 = cv2.GaussianBlur((self.imgReconstruite[:, :, 1]*255).astype(np.uint8), (5, 5), 0)
    175.         ret2, th2 = cv2.threshold(blur2, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
    176.  
    177.         blur3 = cv2.GaussianBlur((self.imgReconstruite[:, :, 2]*255).astype(np.uint8), (5, 5), 0)
    178.         ret3, th3 = cv2.threshold(blur3, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
    179.  
    180.         plt.subplot(1,3,1)
    181.         plt.title("hue")
    182.         plt.imshow(th1,cmap="gray")
    183.         plt.subplot(1, 3, 2)
    184.         plt.title("Saturation")
    185.         plt.imshow(th2,cmap="gray")
    186.         plt.subplot(1, 3, 3)
    187.         plt.title(self.type)
    188.         plt.imshow(th3,cmap="gray")
    189.  
    190.  
    191.         plt.show()
    192.         self.saveOpencv(th1,"Hue_Binariser.png")
    193.         self.saveOpencv(th2, "Saturation_Binariser.png")
    194.         self.saveOpencv(th3, "Intensity_Binariser.png")
    195.         return th3
    196.  
    197.     def recontructionToRGB(self):
    198.         #Calcul de intensity global de chaque pixel on en a besoin pour la reconstruction
    199.         self.GlobalIntensity()
    200.         [l,c,d]=self.img_hsi.shape
    201.         self.imgReconstruite=np.zeros([l,c,3])
    202.         for i in range(l):
    203.             for j in range(c):
    204.                 cx = self.getCX(self.img_hsi[i, j, 0],self.img_hsi[i, j, 1])
    205.                 cy = self.getCY(self.img_hsi[i, j, 0],self.img_hsi[i, j, 1])
    206.  
    207.                 self.imgReconstruite[i, j, 0] = self.intensity[i, j] * (cx + 1)
    208.                 self.imgReconstruite[i, j, 1] = 0.5 * self.intensity[i, j] * (2 - cx - np.sqrt(3) * cy)
    209.                 self.imgReconstruite[i, j, 2] = 0.5 * self.intensity[i, j] * (2 - cx - np.sqrt(3) * cy)
    210.  
    211.         plt.subplot(2,3,1)
    212.         plt.title("hue")
    213.         plt.imshow(self.imgReconstruite[:, :, 0], cmap="gray")
    214.  
    215.         # self.saveOpencv((self.imgReconstruite[:, :, 0]*255).astype(np.uint8), "HSI_Teinte.png")
    216.         cv2.imwrite("HSI_Teinte.png",(self.imgReconstruite[:,:,0]*255).astype(np.uint8))
    217.         #plt.colorbar(ticks=[0, 60, 120, 179], orientation='horizontal', cmap=cm.hsv)
    218.  
    219.         plt.subplot(2,3,2)
    220.         plt.title("saturation")
    221.         plt.imshow(self.imgReconstruite[:, :, 1], cmap="gray")
    222.  
    223.         # save HSI
    224.         cv2.imwrite("HSI_Saturation.png",(self.imgReconstruite[:,:,1]*255).astype(np.uint8))
    225.         # self.saveOpencv((self.imgReconstruite[:, :, 1]*255).astype(np.uint8), "HSI_Saturation.png")
    226.  
    227.         plt.subplot(2,3,3)
    228.         plt.title(self.type)
    229.         plt.imshow(self.imgReconstruite[:, :, 2], cmap="gray")
    230.  
    231.         # save HSD
    232.         #self.savePillow((self.imgReconstruite[:,:,2]*255).astype(np.uint8), self.path+"HSD_Density.tif")
    233.         cv2.imwrite("HSI_Density.png",(self.imgReconstruite[:,:,2]*255).astype(np.uint8))
    234.         # self.saveOpencv((self.imgReconstruite[:,:,2]*255).astype(np.uint8), "HSI_Density.png")
    235.  
    236.  
    237.         #img = Image.fromarray(self.img_0[:, :, 0])
    238.         #img.save(self.path + "img.tif")
    239.  
    240.         plt.show()
    241.  
    242.     def saveOpencv(self,img,path):
    243.         cv2.imwrite(self.path2+"/"+self.path[19:]+"/"+path, img)
    244.  
    245.     def savePillow(self,img,path):
    246.         img_to_save = Image.fromarray(img)
    247.         img_to_save.save(self.path2+"/"+self.path[19:]+"/"+path)
    248.  
    249.  
    250.  
    251. if __name__ == "__main__":
    252.     # reading the image
    253.     # path="Tumor_CD31_LoRes.png"
    254.     #path = "../DataSet/BreastCancerCell_dataset/ytma10_010704_benign1_ccd.tif"
    255.  
    256.     # path = "../DataSet_Lomenie/tumor.png"
    257.     path="t2.png"
    258.     img = plt.imread(path)
    259.     img = img[:, :, 0:3].astype(np.double)
    260.     od=od.rgb_2_od2(img)
    261.  
    262.     # hsi
    263.     h = HSD(od, path, "Density")
    264.     h.chromaticite()
    265.     h.calcule_HSI()
    266.     # h.Kmeans2(3)
    267.     # h.plotHS(Z)
    268.     h.recontructionToRGB()
    269.     h.binarisation()
    270.

     ColorDeconvolution.py

    1. #!/usr/bin/python
    2.  
    3. import matplotlib.pyplot as plt
    4. import numpy as np
    5. import cv2
    6. from PIL import Image
    7. import hsd
    8.  
    9. from matplotlib import cm
    10.  
    11. class ColorDeconvolution:
    12.     def __init__(self, img,path):
    13.         self.img_0 = img
    14.         self.stains = None
    15.         self.od = None
    16.         self.path=path
    17.         self.path2 = "autodl-tmp/color-deconv/Color-Deconvolution/Resultat"
    18.  
    19.     def getStains(self):
    20.         return self.stains
    21.  
    22.     def setImage(self, img):
    23.         if img != None:
    24.             self.img_0 = img
    25.  
    26.     def RGB_2_OD(self):
    27.         [l, c, d] = self.img_0.shape
    28.         self.od = np.zeros([l, c, d])
    29.         for i in range(l):
    30.             for j in range(c):
    31.                 for k in range(d):
    32.                     if self.img_0[i,j,k] != 0 :
    33.                         self.od[i,j,k] = np.log(self.img_0[i, j, k])
    34.         return self.od
    35.  
    36.     def norm(self, vector):
    37.         n = 0
    38.         for i in vector:
    39.             n = n + np.square(i)
    40.         return np.sqrt(n)
    41.  
    42.     def separateStain(self):
    43.  
    44.         # He = [0.65; 0.70; 0.29];
    45.         # Eo = [0.07; 0.99; 0.11];
    46.         # DAB = [0.27; 0.57; 0.78];
    47.  
    48.         He = np.array([0.6500286, 0.704031, 0.2860126])  # Hematoxylin
    49.         Eo = np.array([0.07, 0.99, 0.11])  # Eosine
    50.         DAB = np.array([0.26814753, 0.57031375, 0.77642715])  # DAB
    51.         Res = np.array([0.7110272, 0.42318153, 0.5615672])  # residual
    52.  
    53.     
    54.         HDABtoRGB = np.array([He / self.norm(He), Eo / self.norm(Eo), DAB / self.norm(DAB)])
    55.         RGBtoHDAB = np.linalg.inv(HDABtoRGB)
    56.  
    57.  
    58.         [l,c,d] = self.img_0.shape
    59.         self.stains = np.zeros([l, c, d])
    60.         for i in range(l):
    61.             for j in range(c):
    62.                 a = np.dot(self.od[i, j], RGBtoHDAB)
    63.                 b=self.od[i,j]
    64.                 self.stains[i, j, 0] = a[0]
    65.                 self.stains[i, j, 1] = a[1]
    66.                 self.stains[i, j, 2] = a[2]
    67.         return self.stains
    68.     # this methods shows the differents stains of each canal for the method of colorDeconvolution
    69.     def binarisation(self,image):
    70.  
    71.         # Otsu's thresholding after Gaussian filtering
    72.         blur = cv2.GaussianBlur(image, (5, 5), 0)
    73.         ret3, th3 = cv2.threshold(blur, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
    74.         return th3
    75.     def showStains(self):
    76.  
    77.         plt.subplot(1, 4, 1)
    78.         plt.title("original")
    79.         plt.imshow(self.img_0)
    80.  
    81.         plt.subplot(1, 4, 2)
    82.         plt.title('Hematoxylin')
    83.         plt.imshow(self.stains[:, :, 0], cmap="gray")
    84.         cv2.imwrite("colorDeconvolution_Hematoxylin.png",(self.stains[:, :, 0]*255).astype(np.uint8))
    85.         # self.saveOpencv((self.stains[:, :, 0]*255).astype(np.uint8), " colorDeconvolution_Hematoxylin.tif")
    86.  
    87.  
    88.         plt.subplot(1, 4, 3)
    89.         plt.title('Eosine')
    90.         plt.imshow(self.stains[:, :, 1], cmap="gray")
    91.         cv2.imwrite("colorDeconvolution_Eosin.png",(self.stains[:, :, 1]*255).astype(np.uint8))
    92.         # self.saveOpencv((self.stains[:, :, 1]*255).astype(np.uint8), " colorDeconvolution_Eosin.tif")
    93.  
    94.         plt.subplot(1, 4, 4)
    95.         plt.title('DAB')
    96.         plt.imshow(self.stains[:, :, 2], cmap="gray")
    97.         cv2.imwrite(" colorDeconvolution_DAB.png",(self.stains[:, :, 2]*255).astype(np.uint8))
    98.         # self.saveOpencv((self.stains[:, :, 2]*255).astype(np.uint8)," colorDeconvolution_DAB.tif")
    99.  
    100.         plt.show()
    101.         self.binarisation()
    102.  
    103.  
    104.     def saveOpencv(self,img,path):
    105.         cv2.imwrite(self.path2 + "/" + self.path[19:] + "/" + path, img)
    106.  
    107.     def savePillow(self,img,path):
    108.         img_to_save = Image.fromarray(img)
    109.         img_to_save.save(path)
    110.  
    111.     def binarisation(self):
    112.         # Otsu's thresholding after Gaussian filtering
    113.         # il faut lui donner image self.imgReconstruite et binariser chaque canal hue saturation et density
    114.  
    115.  
    116.         blur1 = cv2.GaussianBlur((self.stains[:, :, 0] * 255).astype(np.uint8), (5, 5), 0)
    117.         ret1, th1 = cv2.threshold(blur1, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
    118.  
    119.         blur2 = cv2.GaussianBlur((self.stains[:, :, 1] * 255).astype(np.uint8), (5, 5), 0)
    120.         ret2, th2 = cv2.threshold(blur2, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
    121.  
    122.         blur3 = cv2.GaussianBlur((self.stains[:, :, 2] * 255).astype(np.uint8), (5, 5), 0)
    123.         ret3, th3 = cv2.threshold(blur3, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
    124.  
    125.         plt.subplot(1, 3, 1)
    126.         plt.title("Hematoxyline")
    127.         plt.imshow(th1,cmap="gray")
    128.         plt.subplot(1, 3, 2)
    129.         plt.title("Eosine")
    130.         plt.imshow(th2,cmap="gray")
    131.         plt.subplot(1, 3, 3)
    132.         plt.title("DAB")
    133.         plt.imshow(th3,cmap="gray")
    134.  
    135.         plt.show()
    136.         self.saveOpencv(th1, "Hematoxyline.png")
    137.         self.saveOpencv(th2, "Eosine.png")
    138.         self.saveOpencv(th3, "DAB.png")
    139.         return th3
    140.  
    141.     def saveOpencv(self,img, path):
    142.         cv2.imwrite(self.path2 + "/" + self.path[19:] + "/" + path, img)
    143.  
    144. if __name__=="__main__":
    145.  
    146.     # path="../DataSet_Lomenie/arn2.tif"
    147.     path = "t2.png"
    148.     img = plt.imread(path)
    149.     img = img[:, :, 0:3]
    150.  
    151.  
    152.     # deconvolution de couleur
    153.     satin = ColorDeconvolution(img,path)
    154.     satin.RGB_2_OD()
    155.     image=satin.separateStain()
    156.     satin.showStains()
    157.  
    158.

     一共会有6张图的结果，最后一张是原图：

     

     

     最后

    看起来是倒数第二张图结果比较好，最后在PS里面先用：图像-调整-曲线-自动，增加灰度值，再图像-调整-反相，得到我们需要的结果：

    源代码： 

    病理图像颜色反卷积，颜色反卷积可应用于H-DAB图像和组织病理学中常用的染色剂（H-E,HAEC,FASTRed，DAB）-深度学习文档类资源-CSDN下载介绍颜色反卷积算法的设计针对RGB摄像机获取的颜色信息，基于免疫组化技术使用的染色剂RGB分量光的更多下载资源、学习资料请访问CSDN下载频道.https://download.csdn.net/download/weixin_42934729/86438199

  • 相关阅读:
    [MT8766][Android12] 使用谷歌LPA实现ESIM功能的流程
    php解析html类库simple_html_dom（3）
    2.4GHz、DA14530-00000FX2射频收发器/LSM6DSOTR 6 轴运动传感器/SKY66423-11射频前端 860MHz 至 930MHz
    node-sass安装不上的问题
    pytest测试框架使用基础07 fixture—parametrize获取参数的几种常用形式
    一个Python中优雅的数据分块方法
    如何搭建测试环境？（详解）
    算法训练营第十三天 | 239. 滑动窗口最大值、347.前 K 个高频元素
    银行互联网类业务基于分布式存储的架构设计与实施运维分享
    Plant Simulation 与Web交互 V3.0工具
  • 原文地址：https://blog.csdn.net/weixin_42934729/article/details/126486336