医疗影像的图像处理基础

Good

医疗影像的图像处理基础

介绍

在第一个任务中，我们将实现并应用一些基本的图像处理技术，以此来熟悉一些医学影像数据。
特别是我们将使用以下数据：

• mammography (breast, 2D)
  
• histopathology (colon, 2D)
  
• chest CT (lungs, 3D)
  

将实现下面的技术:

• 将原始的乳腺X片数据转为灰度图片
  
• 用直方图匹配对病历切片图像归一化
  

Libraries

首先导入我们这个任务所需要的库文件

1. import requests
2. import zipfile
3. from tqdm import tnrange, tqdm_notebook
4. import os
5. import SimpleITK as sitk
6. import matplotlib
7. import matplotlib.pyplot as plt
8. from matplotlib import cm
9. %matplotlib inline
10. import numpy as np
11. from PIL import Image
12. import dicom
13. from IPython import display
14. import time
15. from mpl_toolkits.mplot3d import Axes3D
16. import copy
17. matplotlib.rcParams['figure.figsize'] = (20, 17)
18. import scipy.signal

复制代码

乳腺X光片灰度图变换

第一项任务包括从乳腺X光片机获取的原始数据,重建灰度乳腺X光图像。 必须采用几个步骤来重建灰度图像，从而使得放射科医生可以阅读这些图像，目的是检测肿瘤，肿块，囊肿，微钙化。
读取图片列表

1. # raw and gray-level data in ITK format
2. raw_img_filename = './assignment_1/raw_mammography.mhd'
3. out_img_filename = './assignment_1/processed_mammography.mhd'
5. # read ITK files using SimpleITK
6. raw_img = sitk.ReadImage(raw_img_filename)
7. out_img = sitk.ReadImage(out_img_filename)
9. # print image information
10. print('image size: {}'.format(raw_img.GetSize()))
11. print('image origin: {}'.format(raw_img.GetOrigin()))
12. print('image spacing: {}'.format(raw_img.GetSpacing()))
13. print('image width: {}'.format(raw_img.GetWidth()))
14. print('image height: {}'.format(raw_img.GetHeight()))
15. print('image depth: {}'.format(raw_img.GetDepth()))

复制代码

1. image size: (2560, 3328)
2. image origin: (0.0, 0.0)
3. image spacing: (0.07000000029802322, 0.07000000029802322)
4. image width: 2560
5. image height: 3328
6. image depth: 0

复制代码

**Question:** 图片的像素大小? Answer: 原始的图片的分辨率2560x3328 (长x宽)是像素的总和.
将ITK图像转为Numpy数组

为了便于操作数据，可以方便地将其转换为numpy格式，可以使用numpy库进行转换，并且可以使用pylab/matplotlib库来可视化数据。
可以参考链接 http://insightsoftwareconsortium.github.io/SimpleITK-Notebooks/Python_html/01_Image_Basics.html 来找到合适的函数将图片转为numpy。

• out_np: should contain the numpy array from out_img
  
• raw_np: should contain the numpy array from raw_img
  

提示: 如果你不熟悉Numpy函数，可参考下面的小教程：
http://cs231n.github.io/python-numpy-tutorial/

1. # convert the ITK image into numpy format
2. # >> YOUR CODE HERE <<<
3. out_np = sitk.GetArrayFromImage(out_img)
4. raw_np = sitk.GetArrayFromImage(raw_img)

复制代码

1. assert(out_np is not None),"out_np cannot be None"
2. assert(raw_np is not None),"raw_np cannot be None"
4. # visualize the two numpy arrays
5. plt.subplot(1,2,1)
6. plt.imshow(raw_np, cmap='gray')
7. plt.title('raw data')
8. plt.subplot(1,2,2)
9. plt.imshow(out_np, cmap='gray')
10. plt.title('gray-level data (target)')
11. plt.show()

复制代码

1. def sitk_show(img, title=None, margin=0.0, dpi=40):
2.     nda = sitk.GetArrayFromImage(img)
3.     #spacing = img.GetSpacing()
4.     figsize = (1 + margin) * nda.shape[0] / dpi, (1 + margin) * nda.shape[1] / dpi
5.     #extent = (0, nda.shape[1]*spacing[1], nda.shape[0]*spacing[0], 0)
6.     extent = (0, nda.shape[1], nda.shape[0], 0)
7.     fig = plt.figure(figsize=figsize, dpi=dpi)
8.     ax = fig.add_axes([margin, margin, 1 - 2*margin, 1 - 2*margin])
10.     plt.set_cmap("gray")
11.    
12.     ax.imshow(nda,extent=extent,interpolation=None)
13.    
14.     if title:
15.         plt.title(title)
16.    
17.     plt.show()

复制代码

图像预处理技术——CLAHE

• 限制对比度自适应直方图均衡(CLAHE算法)是一种效果较好的均衡算法
  
• 与普通的自适应直方图均衡相比，CLAHE的 不同地方在于直方图修剪过程，用修剪后的 直方图均衡图像时，图像对比度会更自然。
  

CLAHE算法步骤

• 图像分块，以块为单位，先计算直方图，然后修剪直方图，最后均衡;
  
• 遍历、操作各个图像块，进行块间双线性插值;
  
• 与原图做图层滤色混合操作。(可选)
  

1. import cv2

复制代码

1. # raw and gray-level data in ITK format
2. raw = cv2.imread('1.png', 0)
3. equ = cv2.equalizeHist(raw)  # 应用全局直方图均衡化
5. clahe = cv2.createCLAHE(clipLimit=100, tileGridSize=(8, 8))  # 自适应均衡化，参数可选
6. cl1 = clahe.apply(raw)
8. # visualize the two numpy arrays
9. plt.subplot(3,1,1)
10. plt.imshow(raw, cmap='gray')
11. plt.title('raw data')
12. plt.subplot(3,1,2)
13. plt.imshow(equ, cmap='gray')
14. plt.title('equ data')
15. plt.subplot(3,1,3)
16. plt.imshow(cl1, cmap='gray')
17. plt.title('clahe data')
18. plt.show()

复制代码

常用的图像处理

将一张原始图片转换为一张灰度图片，需要实现下面3个主要步骤：

• 对数变换
  
• 图像强度反转
  
• 对比度拉伸
  
  
  
  

对数变换

1. # logarithmic transformation
2. # >> YOUR CODE HERE <<<
3. # The mu and d actually stand for depth and intensitiy in the scan
4. # It does not have to be incorporated into the calculations
5. print(raw_np)
6. mammo_log = np.log(raw_np + 1)
7. mammo_log = mammo_log *(255/np.max(mammo_log))
8. print("Lowest value in mammo_log:" + str(np.min(mammo_log)))
9. print("Highest value in mammo_log:" + str(np.max(mammo_log)))
10. print(mammo_log)

复制代码

1. [[163********6383 ... 163********6383]
2. [163********6383 ... 163********6383]
3. [163********6383 ... 163********6383]
4. ...
5. [ 8832  8832  8832 ...  8832  8832  8832]
6. [ 8832  8832  8832 ...  8832  8832  8832]
7. [ 8832  8832  8832 ...  8832  8832  8832]]
8. Lowest value in mammo_log:0.0
9. Highest value in mammo_log:255.0
10. [[255.     255.     255.     ... 255.     255.     255.    ]
11. [255.     255.     255.     ... 255.     255.     255.    ]
12. [255.     255.     255.     ... 255.     255.     255.    ]
13. ...
14. [238.7654 238.7654 238.7654 ... 238.7654 238.7654 238.7654]
15. [238.7654 238.7654 238.7654 ... 238.7654 238.7654 238.7654]
16. [238.7654 238.7654 238.7654 ... 238.7654 238.7654 238.7654]]

复制代码

1. assert(mammo_log is not None),"mammo_log cannot be None"
3. # visualize the result
4. plt.imshow(mammo_log, cmap='gray')
5. plt.title('after logaritmic transformation')

复制代码

1. Text(0.5,1,'after logaritmic transformation')

复制代码

图像强度反转

1. # intensity inversion
2. # >> YOUR CODE HERE <<<
4. # In order to make np.invert work, we have to convert floats to ints
5. # mammo_inv = np.invert(mammo_log.astype(int))
6. # numpy invert is a elementwise operation. The TA told us that we should invert the values by ourself.
7. mammo_inv = (mammo_log-np.max(mammo_log))*-1
8. print("Lowest value in mammo_inv:" + str(np.min(mammo_inv)))
9. print("Highest value in mammo_inv:" + str(np.max(mammo_inv)))

复制代码

1. Lowest value in mammo_inv:-0.0
2. Highest value in mammo_inv:255.0

复制代码

1. assert(mammo_inv is not None),"mammo_inv cannot be None"
3. # visualize the result
4. plt.imshow(mammo_inv, cmap='gray')
5. plt.title('after intensity inversion')

复制代码

1. Text(0.5,1,'after intensity inversion')

复制代码

对比度拉伸

为了应用对比度拉伸操作，我们首先定义一般的对比度拉伸功能。 输入应至少为:

• 输入信号，
  
• 窗口范围值p0和pk。
  注意：最终结果不应包含大于pk或低于p0的强度值。
  

1. # contrast stretching
2. def contrast_stretching(x, p0, pk, q0=0., qk=255.):
3.     # >>> YOUR CODE HERE <<<
4.     x_cs = (x-p0)/(pk-p0)
5.     x_cs[x_cs<=0] = 0 # Clipping, suggested by TA
6.     x_cs[x_cs>1]  = 1 # Clipping, suggested by TA
7.     x_cs = q0 + (qk - q0) * x_cs
8.     return x_cs

复制代码

现在我们可以应用对比度拉伸并可视化结果。

1. # plotting histogram to choose proper boundaries (p0, pk)
2. hist, bin_edges = np.histogram(mammo_inv, bins=500, range=[75, 110])
3. plt.bar(bin_edges[:-1], hist, width = 1)
4. plt.xlim(min(bin_edges), max(bin_edges))
5. plt.show()   
7. # pick proper values for p0 and pk
8. p0 = 85
9. pk = 100
11. assert(p0 is not None),"p0 cannot be None"
12. assert(pk is not None),"pk cannot be None"

复制代码

1. mammo_cs = contrast_stretching(mammo_inv, p0, pk)
2. assert(mammo_cs is not None),"mammo_cs can not be None"
4. # visualize the result
5. plt.imshow(mammo_cs, cmap='gray')
6. plt.show()

复制代码

您会注意到此阶段的结果已经比您开始的原始数据更具可读性。 然而，结果仍然不如乳腺X光片厂商提供的效果好。 为了检查两者的差异，我们将在反转后（对比度拉伸之前），对比度拉伸之后和目标拉伸之后的结果和可视化乳腺X光片厂商处理图的直方图进行比较。

1. # visualize and compare histograms
2. plt.subplot(1,3,1)
3. plt.hist(mammo_inv.flatten(), 100)
4. plt.title('before contrast stretching')
5. plt.subplot(1,3,2)
6. plt.hist(mammo_cs.flatten(), 100)
7. plt.title('after contrast stretching')
8. plt.subplot(1,3,3)
9. plt.hist(out_np.flatten(), 100)
10. plt.title('target')
11. plt.show()

复制代码

**Question:** 你是如何定义p0和pk的值的？ 当这些参数发生变化时，结果会改变多少？ 你能看一下柱状图吗？ 答案：通过绘制倒置图像的直方图，我们寻找一般峰值并隔离每个峰值，并将它们用于对比度拉伸的候选参数。 在分离并尝试了三个不同的峰值之后，我们确定了85到100之间的范围，因为它产生了与厂商处理图片的效果。 0和30左右的第一个峰值仅产生前景和背景之间的分离，因此不是我们正在寻找的解决参数。 如果更改这些参数，则只需将要合并的范围限制为对比度拉伸过程。 这些参数的微小变化可能导致具有不同细节水平的不同图像。 因此，直方图是隔离对比度拉伸的参数选择的有用工具。
直方图均衡/匹配

对比度拉伸的步骤可以用直方图均衡来代替。 通过这种方式，我们假设目标图像是已知的，我们将从中学习一些强度值对应函数，称为查找表（LUT）。 LUT是一个表格，其条目对应于输入图像中的所有可能值，并且每个值都映射到输出值，目的是模仿目标图像的强度分布，在我们的案例中是乳腺X光片供应商处理结果。
实现一个函数，该函数将直方图作为输入进行变换，并使用目标直方图并返回LUT。

1. # function to do histogram matching
3. def get_histogram_matching_lut(h_input, h_template):
4.     ''' h_input: histogram to transfrom, h_template: reference'''
5.     if len(h_input) != len(h_template):
6.         print('histograms length mismatch!')
7.         return False
8.    
9.     # >> YOUR CODE HERE <<
10.     LUT = np.zeros(len(h_input))
11.     H_input = np.cumsum(h_input) # Cumulative distribution of h_input
12.     H_template = np.cumsum(h_template) # Cumulative distribution of h_template
13.    
14.     for i in range(len(H_template)):
15.         input_index = H_input[i]
16.         new_index = (np.abs(H_template-input_index)).argmin()
17.         LUT[i] = new_index
18.    
19.     return LUT, H_input, H_template

复制代码

现在已经实现了函数get_histogram_matching_lut（），你可以执行下一个使用它的单元格，并可视化使用直方图匹配转换的乳腺X光片图像的结果。

1. # rescale images between [0,1]
2. out_np = out_np.astype(float)
3. mammo_inv_norm = (mammo_inv - mammo_inv.flatten().min())/(mammo_inv.flatten().max() - mammo_inv.flatten().min())
4. mammo_out_norm = (out_np - out_np.flatten().min())/(out_np.flatten().max() - out_np.flatten().min())
6. n_bins = 4000 # define the number of bins
7. hist_inv = np.histogram(mammo_inv_norm, bins=np.linspace(0., 1., n_bins+1))
8. hist_out = np.histogram(mammo_out_norm, bins=np.linspace(0., 1., n_bins+1))
10. # compute LUT
11. LUT,H_input,H_template = get_histogram_matching_lut(hist_inv[0], hist_out[0])
12. assert(LUT        is not None),"LUT cannot be None"
13. assert(H_input    is not None),"H_input cannot be None"
14. assert(H_template is not None),"H_template cannot be None"
16. # histograms before matching
17. plt.suptitle('BEFORE HISTOGRAM MATCHING')
18. plt.subplot(1,2,1); plt.hist(mammo_inv_norm.flatten())
19. plt.title('histogram input')
20. plt.subplot(1,2,2); plt.hist(mammo_out_norm.flatten())
21. plt.title('histogram target')
22. plt.show()
24. # plot cumulative histogram
25. plt.suptitle('CUMULATIVE HISTOGRAMS')
26. plt.subplot(1,2,1); plt.plot(H_input)
27. plt.title('cumulative histogram input')
28. plt.subplot(1,2,2); plt.plot(H_template)
29. plt.title('cumulative histogram target')
30. plt.show()   
31.    
32. # apply histogram matching
33. mammo_lut = LUT[(mammo_inv_norm * (n_bins-1)).astype(int)]
35. # visual result
36. plt.suptitle('VISUAL RESULT')
37. plt.subplot(1,2,1); plt.imshow(mammo_lut.squeeze(), cmap='gray')
38. plt.title('converted image')
39. plt.subplot(1,2,2); plt.imshow(out_np, cmap='gray')
40. plt.title('target')
41. plt.show()
43. # histograms after matching
44. plt.suptitle('AFTER HISTOGRAM MATCHING')
45. plt.subplot(1,2,1)
46. plt.hist(mammo_lut.flatten())
47. plt.subplot(1,2,2)
48. plt.hist(out_np.flatten())
49. plt.show()

复制代码

Question:
你是如何选择用于进行直方图匹配的分箱数？ 结果是否取决于分箱的数量？
从目标直方图中获取总分箱数的大小。 似乎结果实际上并不依赖于分箱的数量，因为转换后的图像不会发生变化（很多）。
病理切片的归一化(直方图匹配)

                               
登录/注册后可看大图

在上一个练习中，我们实现了直方图匹配功能，并使用它来使给定的乳腺X光片图像适应给定的目标图像。在这种情况下，目标是增强原始乳腺X光片数据中的相关信息，并使其作为灰度图像更利于查看。
相同的技术可以应用于数字病理学领域，但是为了解决不同的问题，图像中的染色剂的可变性。
在病理学中，切割组织样品并用特定染料染色，以增强与诊断相关的一些组织。最常用的染色称为Hematoxylyn和Eosin（H＆E），常规用于诊断目的。
H＆E的问题在于，在一周的不同日期进行染色时，实验室中的染色变异很大，甚至在同一实验室也是如此。这是因为最终结果很大程度上取决于染料的类型和密度以及组织实际暴露于染色剂的时间。
右边的例子是从公开可用的数据集（https://zenodo.org/record/53169#.WJRAC_krIuU） 中提取的结肠直肠癌组织样本的图像，其中HE染色图像的外观，主要是颜色是不同的。
直方图匹配是一种可以帮助解决这个问题的技术，因为我们可以考虑通过独立处理每个通道来调整每个通道（R，G，B）的颜色分布。
使用数字病理切片图像时，值得注意的是图像大小通常很大。典型的组织病理学图像是千兆像素图像，大约100,000 x 100,000像素。但是，为了简单起见，在此任务中，我们将仅使用5000x5000像素的图块。
加载病历切片的数据

1. # load data
2. HE1 = np.asarray(Image.open('./assignment_1/CRC-Prim-HE-05_APPLICATION.tif'))
3. HE2 = np.asarray(Image.open('./assignment_1/CRC-Prim-HE-10_APPLICATION.tif'))
5. print(HE1.shape)
6. print(HE2.shape)
8. plt.subplot(1,2,1); plt.imshow(HE1); plt.title('HE1')
9. plt.subplot(1,2,2); plt.imshow(HE2); plt.title('HE2')

复制代码

1. (5000, 5000, 3)
2. (5000, 5000, 3)
8. Text(0.5,1,'HE2')

复制代码

染色剂归一化

基于直方图匹配，基于以下定义实现染色剂标准化功能。

1. def stain_normalization(input_img, target_img, n_bins=100):
2.     """ Stain normalization based on histogram matching. """
3.    
4.     print("Lowest value in input_img:" + str(np.min(input_img)))
5.     print("Highest value in input_img:" + str(np.max(input_img)))
6.    
7.     print("Lowest value in target_img:" + str(np.min(target_img)))
8.     print("Highest value in target_img:" + str(np.max(target_img)))
9.    
10.     normalized_img = np.zeros(input_img.shape)
11.    
12.     input_img = input_img.astype(float) # otherwise we get a complete yellow image
13.     target_img = target_img.astype(float) # otherwise we get a complete blue image
14.    
15.     # Used resource: https://stackoverflow.com/a/42463602
16.     # normalize input_img
17.     input_img_min = input_img.min(axis=(0, 1), keepdims=True)
18.     input_img_max = input_img.max(axis=(0, 1), keepdims=True)
19.     input_norm = (input_img - input_img_min)/(input_img_max - input_img_min)
20.    
21.     # normalize target_img
22.     target_img_min = target_img.min(axis=(0, 1), keepdims=True)
23.     target_img_max = target_img.max(axis=(0, 1), keepdims=True)
24.     target_norm = (target_img - target_img_min)/(target_img_max - target_img_min)
25.    
26.     # Go through all three channels
27.     for i in range(3):
28.         input_hist = np.histogram(input_norm[:,:,i], bins=np.linspace(0, 1, n_bins + 1))
29.         target_hist = np.histogram(target_norm[:,:,i], bins=np.linspace(0, 1, n_bins + 1))
30.         LUT, H_input, H_template = get_histogram_matching_lut(input_hist[0],target_hist[0])
31.         normalized_img[:,:,i] = LUT[(input_norm[:,:,i] * (n_bins - 1)).astype(int)]
32.    
33.     normalized_img = normalized_img / n_bins
34.    
35.     return normalized_img

复制代码

现在我们可以使用实现的函数进行染色剂归一化并查看实际结果。

1. # transform HE1 to match HE2
2. HE1_norm = stain_normalization(HE1, HE2);
3. assert(HE1_norm is not None),"HE1_norm can not be None"
5. plt.subplot(1,3,1)
6. plt.imshow(HE1); plt.title('HE1 before normalization')
7. plt.subplot(1,3,2)
8. plt.imshow(HE1_norm); plt.title('HE1 after normalization')
9. plt.subplot(1,3,3)
10. plt.imshow(HE2); plt.title('target')
11. plt.show()
13. # transform HE2 to match HE1
14. HE2_norm = stain_normalization(HE2, HE1);
15. plt.subplot(1,3,1); plt.imshow(HE2)
16. plt.title('HE2 before normalization')
17. plt.subplot(1,3,2); plt.imshow(HE2_norm)
18. plt.title('HE2 after normalization')
19. plt.subplot(1,3,3); plt.imshow(HE1)
20. plt.title('target')
21. plt.show()

复制代码

1. Lowest value in input_img:0
2. Highest value in input_img:255
3. Lowest value in target_img:0
4. Highest value in target_img:255

复制代码

1. Lowest value in input_img:0
2. Highest value in input_img:255
3. Lowest value in target_img:0
4. Highest value in target_img:255

复制代码

来源：https://blog.csdn.net/myboyliu2007/article/details/85112421
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！