def obtain_tissue_tmax(self):
cbf_seq = np.zeros((256 * 256))
tmax_seq = np.zeros((256 * 256))
comb_seq = np.zeros((256 * 256))
for ii in tqdm(range(256 * 256)):
y = int(ii // 256)
x = int(ii % 256)
if self.brain_mask[y, x] == 0:
continue
tissue_lst = [0] * len(self.img_lst)
for idx, img in enumerate(self.images):
tissue_lst[idx] = get_ct_value_neighbor_avg(
img, x, y, self.brain_mask, self.img_mask, g_d)
array_ct_value_tissue = np.array(tissue_lst)
array_ct_value_tissue_bl = baseline_process(
array_ct_value_tissue, g_std_t)
array_ct_value_tissue_bl_f = filter_lp(array_ct_value_tissue,
cutoff_l=None,
cutoff_h=0.41,
ftype="lowpass")
final_signal_tissue, base_tissue = baseline_correction(
array_ct_value_tissue_bl_f)
tmax_seq[ii] = np.argmax(final_signal_tissue)
cbf_seq[ii] = final_signal_tissue.max()
comb_seq[ii] = tmax_seq[ii] * cbf_seq[ii]
return tmax_seq.reshape((256, 256)), cbf_seq.reshape(
(256, 256)), comb_seq.reshape((256, 256))
def get_tissue_signal(self):
output = np.zeros((256, 256, len(self.img_lst)))
for ii in tqdm(range(256 * 256)):
y_t_i = int(ii // 256)
x_t_i = int(ii % 256)
if self.brain_mask[y_t_i, x_t_i] == 0:
continue
length = len(self.img_lst)
tissue_lst = [0] * length
for idx, img in enumerate(self.images):
tissue_lst[idx] = get_ct_value_neighbor_avg(
img, x_t_i, y_t_i, self.brain_mask, self.img_mask, g_d)
array_ct_value_tissue = np.array(tissue_lst)
# array_ct_value_tissue_bl = baseline_process(array_ct_value_tissue, g_std_t)
array_ct_value_tissue_bl_f = filter_lp(array_ct_value_tissue,
cutoff_l=None,
cutoff_h=0.41,
ftype="lowpass")
final_signal_tissue, base_tissue = baseline_correction(
array_ct_value_tissue_bl_f)
output[y_t_i, x_t_i, :] = final_signal_tissue
return output
def compute_irf_time(self, index):
'''
Input:
index:the index of pixel in flat image
isPad: expand time axis for extensive distribution of Tmax
output: Tmax of irf
Describe:
if the time of peak in tissue is after the time of peak in aif, tmax = tissue_peak_time - aif_peak_time
else tmax = total_time - (aif_peak_time - tissue_peak_time)
'''
y_t_i = int(index // 256)
x_t_i = int(index % 256)
if self.brain_mask[y_t_i, x_t_i] == 0:
return
length = len(self.final_signal_aif)
tissue_lst = [0] * length
for idx, img in enumerate(self.images):
tissue_lst[idx] = get_ct_value_neighbor_avg(
img, x_t_i, y_t_i, self.brain_mask, self.img_mask, g_d)
array_ct_value_tissue = np.array(tissue_lst)
array_ct_value_tissue_bl = baseline_process(array_ct_value_tissue,
g_std_t)
array_ct_value_tissue_bl_f = filter_lp(array_ct_value_tissue,
cutoff_l=None,
cutoff_h=0.41,
ftype="lowpass")
final_signal_tissue, base_tissue = baseline_correction(
array_ct_value_tissue_bl_f)
aif_delay = np.min(np.where(self.final_signal_aif > 0))
tissue_delay = np.min(np.where(final_signal_tissue > 0))
irf_delay = abs(tissue_delay - aif_delay)
aif_peak = np.argmax(self.final_signal_aif)
tissue_peak = np.argmax(final_signal_tissue)
max_aif = np.max(self.final_signal_aif)
self.cbf_img[y_t_i,
x_t_i] = (1 / max_aif) * np.max(final_signal_tissue)
self.cbv_img[y_t_i, x_t_i] = trapz(
final_signal_tissue, np.arange(len(final_signal_tissue)),
dx=1) / trapz(self.final_signal_aif,
np.arange(len(self.final_signal_aif)),
dx=1)
if tissue_peak >= aif_peak:
self.irf_img[y_t_i, x_t_i] += (tissue_peak - aif_peak)
def __init__(self, img_path, brain_aif_mask, mask_path, g_std_t, lamda,
**kwargs):
self.img_path = r"{}/{}".format(img_path, global_patient)
file_lst = os.listdir(self.img_path)
self.lamda = lamda
# --- get image files list---
img_lst = []
for f in file_lst:
if f.endswith(".png"):
case_i = f.split("_")[2]
slc_i = f.split("_")[3]
if case_i == global_case and slc_i == global_slc:
img_lst.append(f)
self.img_lst = sorted(img_lst, key=lambda x: int(x.split('_')[
4])) # Sort image files belonging single slice with time
self.g_std_t = g_std_t
# --- Get ground truth, aif mask and brain mask ---
for f in os.listdir(brain_aif_mask):
if f.split('_')[-1] == "aif.png":
self.aif_mask = cv2.imread(r"{}/{}".format(brain_aif_mask, f),
0)
elif f.split('_')[-1] == 'brain.png':
self.brain_mask = cv2.imread(
r"{}/{}".format(brain_aif_mask, f), 0)
self.img_mask = cv2.imread(
r"{}/{}/{}_case_{}_{}_mask.png".format(mask_path, global_patient,
global_patient, global_case,
global_slc), 0)
ret, img_mask_bin = cv2.threshold(self.img_mask, 127, 255,
cv2.THRESH_BINARY)
self.mask_contours, hierarchy = cv2.findContours(
img_mask_bin, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
# self.tissue_signal = np.zeros((256, 256, len(self.img_lst)))
# --- Prepare original images, cbf images and tmax images ---
self.images = np.zeros((len(self.img_lst), 256, 256))
self.cbf_img = np.zeros((256, 256))
self.irf_img = np.zeros((256, 256))
self.cbv_img = np.zeros((256, 256))
self.load_img() # reading all image into memory
self.tissue_signal = self.get_tissue_signal()
self.aif_seq, self.aif_contours = self.get_aif_signal()
self.final_signal_aif, self.base_aif = baseline_correction(
self.aif_seq, name="aif")
def compute_irf(self, index):
'''
Input:
index:the index of pixel in flat image
isPad: expand time axis for extensive distribution of Tmax
Output: Tmax of irf
Describe:
Compute irf using Tikhonov svd
'''
y_t_i = int(index // 256)
x_t_i = int(index % 256)
if self.brain_mask[y_t_i, x_t_i] == 0:
return
tissue_lst = [0] * len(self.img_lst)
for idx, img in enumerate(self.images):
tissue_lst[idx] = get_ct_value_neighbor_avg(
img, x_t_i, y_t_i, self.brain_mask, self.img_mask, g_d)
array_ct_value_tissue = np.array(tissue_lst)
array_ct_value_tissue_bl = baseline_process(array_ct_value_tissue,
g_std_t)
array_ct_value_tissue_bl_f = filter_lp(array_ct_value_tissue,
cutoff_l=None,
cutoff_h=0.41,
ftype="lowpass")
final_signal_tissue, base_tissue = baseline_correction(
array_ct_value_tissue_bl_f)
residual_func = deconvolution(self.final_signal_aif,
final_signal_tissue)
t_idx = np.argmax(residual_func)
self.irf_img[y_t_i, x_t_i] += t_idx
self.cbf_img[y_t_i, x_t_i] += np.max(residual_func)
def show_R_signal(self):
final_signal_aif, base_aif = baseline_correction(self.aif_seq,
name="aif")
for x_t_i in range(100, 256):
for y_t_i in range(100, 256):
if self.brain_mask[y_t_i, x_t_i] == 0:
continue
# ---draw contours---
img = cv2.imread(
r"{}/{}".format(self.img_path, self.img_lst[0]),
cv2.IMREAD_COLOR)
img = cv2.drawContours(img, self.aif_contours, 0,
(153, 0, 153), 1)
img = cv2.drawContours(img, self.mask_contours, 0, (255, 0, 0),
1)
cv2.rectangle(img, (max(0, x_t_i - 2), max(y_t_i - 2, 0)),
(min(256, x_t_i + 2), min(256, y_t_i + 2)),
(227, 23, 13), 1)
# ---Tissue TDC---
with parallel_backend('threading', n_jobs=-1):
tissue_lst = Parallel()(
delayed(get_ct_value_neighbor_avg)(*[img, x_t_i, y_t_i, self.brain_mask, self.img_mask, g_d]) \
for img in self.images)
array_ct_value_tissue = np.array(tissue_lst)
array_ct_value_tissue_bl = baseline_process(
array_ct_value_tissue, g_std_t)
array_ct_value_tissue_bl_f = filter_lp(
array_ct_value_tissue_bl,
cutoff_l=None,
cutoff_h=0.41,
ftype="lowpass")
final_signal_tissue, base_tissue = baseline_correction(
array_ct_value_tissue_bl_f)
# --- Compute IRF ---
residual_func = deconv_nonparam_alg_tikhonov_svd(
self.final_signal_aif,
final_signal_tissue,
lamdaa=self.lamda)
residual_func_blur, sig = deconvolution(self.final_signal_aif,
final_signal_tissue,
show=True)
# --- Show Main Peak ---
# residual_func_baseline = BaselineRemoval(residual_func).IModPoly(2)
# residual_func_baseline[residual_func_baseline < 0] = 0
# peaks, properties = find_peaks(residual_func_baseline, prominence = 0)
# left_bases = properties['left_bases']
# right_bases = properties['right_bases']
# idex = np.argmax(residual_func_baseline[peaks])
# residual_func_baseline[:left_bases[idex]] = 0
# residual_func_baseline[right_bases[idex]:] = 0
tissue_t = np.argmax(final_signal_tissue)
aif_t = np.argmax(final_signal_aif)
print("tissue tmax:", tissue_t, "aif tmax:", aif_t,
"irf tmax:", tissue_t - aif_t)
# inverse aif
cir_aif = circulant(self.final_signal_aif)
inver_sig = np.linalg.inv(cir_aif)
o_sig = inver_sig[0, :].copy()
pdb.set_trace()
# --- Plot Image ---
plt.figure(figsize=(15, 7))
display.clear_output(wait=True)
plt.subplot(2, 4, 1)
plt.imshow(img)
# plt.title("{}, x:{}, y:{}".format(x_t_i, y_t_i))
plt.subplot(2, 4, 2)
plt.plot(residual_func, label="irf signal")
# plt.plot(residual_func_blur, label = "irf_blur signal")
# plt.legend()
plt.minorticks_on()
plt.title('IRF')
plt.subplot(2, 4, 3)
plt.plot(array_ct_value_tissue_bl,
label="array_tissue_signal_f")
plt.plot(base_tissue, label="tissue without baseline shift")
plt.plot(final_signal_tissue, label="final_signal_tissue")
plt.legend()
plt.title('Tissue TDC')
plt.subplot(2, 4, 4)
plt.plot(final_signal_aif, label="aif signal")
plt.plot(final_signal_tissue, label="tissue signal")
plt.plot(sig * 100, label='reg inv_aif')
plt.legend()
plt.title('AIF & Tissue TDC')
plt.subplot(2, 4, 5)
plt.plot(self.aif_seq, label="array_aif_bl_f")
plt.plot(base_aif, label="aif without baseline shift")
plt.plot(final_signal_aif, label="final_signal_aif")
plt.legend()
plt.title('AIF TDC')
plt.subplot(2, 4, 6)
plt.plot(o_sig * 100, label='inverse aif')
plt.plot(final_signal_tissue, label='tissue')
plt.legend()
plt.title('inverse aif')
plt.subplot(2, 4, 7)
plt.plot(residual_func_blur)
# plt.plot(residual_func * 10, label = 'svd irf')
plt.title('irf blur')
plt.show()
plt.pause(0.8)
plt.close()
