def get_mixup(x_candidate, x_candidate_label, alpha):
if alpha == 0:
return x_candidate, x_candidate_label
if alpha > 0:
x_mixup = np.zeros(np.shape(x_candidate))
y_mixup = np.zeros(np.shape(x_candidate_label), 'float')
length = len(x_candidate)
lam = np.random.beta(alpha, alpha, length)
indexs = np.random.randint(0, length, length)
for i in range(length):
x_mixup[i] = x_candidate[i]*lam[i]+(1-lam[i])*x_candidate[indexs[i]]
y_mixup[i] = x_candidate_label[i]*lam[i]+(1-lam[i])*x_candidate_label[indexs[i]]
return x_mixup, y_mixup
def get_test_dataset():
x_return_test = np.zeros((117, size, size, size))
x_name_test = pd.read_csv("test.csv")['Id']
filenum = 0
for i in range(117):
x_file_temp = os.path.join(x_test_path, x_name_test[i] + '.npz')
x_voxel = np.array(np.load(x_file_temp)['voxel'])
x_seg = np.array(np.load(x_file_temp)['seg'])
x_temp = x_voxel * x_seg * 0.8 + x_voxel * 0.2
s = x_seg * x_voxel
sign = np.array(np.nonzero(s))
min1, low1, len1 = get_rec(sign, 0)
min2, low2, len2 = get_rec(sign, 1)
min3, low3, len3 = get_rec(sign, 2)
i_temp = 0
for i in range(low1, low1+len1):
j_temp = 0
for j in range(low2, low2+len2):
k_temp = 0
for k in range(low3, low3+len3):
x_return_test[filenum, i, j, k] = x_temp[min1 + i_temp, min2 + j_temp, min3 + k_temp]
k_temp += 1
j_temp += 1
i_temp += 1
filenum += 1
return x_return_test
def data_augmentation(x, y, index):
x_lr = x_ud = x_r1 = x_r2 = x_r3 = x_r4 = x_r5 = x_r6 = x_m1 = x_m2 = x_m3 = x_m4 = np.zeros(
np.shape(x))
y_m1 = y_m2 = y_m3 = y_m4 = np.zeros(np.shape(y), 'float')
l1 = np.random.beta(0.1, 0.1, len(x))
l2 = np.random.beta(0.15, 0.15, len(x))
l3 = np.random.beta(0.2, 0.2, len(x))
l4 = np.random.beta(0.25, 0.25, len(x))
randi = np.random.randint(0, len(x), len(x))
for ii in range(x.shape[0]):
x_lr[ii, :, :, :] = np.fliplr(x[ii, :, :, :])
x_ud[ii, :, :, :] = np.flipud(x[ii, :, :, :])
x_r1[ii, :, :, :] = np.rot90(x[ii, :, :, :], 1, (0, 1))
x_r2[ii, :, :, :] = np.rot90(x[ii, :, :, :], 1, (0, 2))
x_r3[ii, :, :, :] = np.rot90(x[ii, :, :, :], 1, (1, 2))
x_r4[ii, :, :, :] = np.rot90(x[ii, :, :, :], 3, (0, 1))
x_r5[ii, :, :, :] = np.rot90(x[ii, :, :, :], 3, (0, 2))
x_r6[ii, :, :, :] = np.rot90(x[ii, :, :, :], 3, (1, 2))
x_m1[ii] = x[ii] * l1[ii] + (1 - l1[ii]) * x[randi[ii]]
y_m1[ii] = y[ii] * l1[ii] + (1 - l1[ii]) * y[randi[ii]]
x_m2[ii] = x[ii] * l2[ii] + (1 - l2[ii]) * x[randi[ii]]
y_m2[ii] = y[ii] * l2[ii] + (1 - l2[ii]) * y[randi[ii]]
x_m3[ii] = x[ii] * l3[ii] + (1 - l3[ii]) * x[randi[ii]]
y_m3[ii] = y[ii] * l3[ii] + (1 - l3[ii]) * y[randi[ii]]
x_m4[ii] = x[ii] * l4[ii] + (1 - l4[ii]) * x[randi[ii]]
y_m4[ii] = y[ii] * l4[ii] + (1 - l4[ii]) * y[randi[ii]]
x_train = np.r_[x, x_lr, x_ud, x_r1, x_r2, x_m1, x_m2, x_m3, x_m4]
y_train = np.r_[y, y, y, y, y, y_m1, y_m2, y_m3, y_m4]
x_test = np.r_[x, x_lr, x_ud, x_r1, x_r2, x_r3, x_r4, x_r5, x_r6]
y_test = np.r_[y, y, y, y, y, y, y, y, y]
if index == 0:
return x_train, y_train
else:
return x_test, y_test
def load_testdata():
x_return = np.zeros((117, size, size, size))
x_name = pd.read_csv("sampleSubmission.csv")[
'Id'] # 此处[' ']内填写的是sampleSubmission.csv内的第一列表头
filenum = 0
for i in range(117):
x_file_temp = os.path.join(x_test_path, x_name[i] + '.npz')
x_voxel = np.array(np.load(x_file_temp)['voxel'])
x_mask = np.array(np.load(x_file_temp)['seg'])
x_temp = x_voxel * x_mask * 0.8 + x_voxel * 0.2
list_xx_test = x_voxel * x_mask
list_xx_nz_test = np.array(np.nonzero(list_xx_test))
coor1min = list_xx_nz_test[0, :].min()
coor1max = list_xx_nz_test[0, :].max()
coor1len = coor1max - coor1min + 1
coor1bigger = coor1len - size
if coor1bigger > 0:
coor1min += coor1bigger // 2
coor1max -= coor1bigger - coor1bigger // 2
coor1len = size
coor1low = (size // 2) - (coor1len // 2)
coor1high = coor1low + coor1len
coor2min = list_xx_nz_test[1, :].min()
coor2max = list_xx_nz_test[1, :].max()
coor2len = coor2max - coor2min + 1
coor2bigger = coor2len - size
if coor2bigger > 0:
coor2min += coor2bigger // 2
coor2max -= coor2bigger - coor2bigger // 2
coor2len = size
coor2low = (size // 2) - (coor2len // 2)
coor2high = coor2low + coor2len
coor3min = list_xx_nz_test[2, :].min()
coor3max = list_xx_nz_test[2, :].max()
coor3len = coor3max - coor3min + 1
coor3bigger = coor3len - size
if coor3bigger > 0:
coor1min += coor3bigger // 2
coor3max -= coor3bigger - coor3bigger // 2
coor3len = size
coor3low = (size // 2) - (coor3len // 2)
coor3high = coor3low + coor3len
# print(file, coor1low, coor1high, coor2low, coor2high, coor3low, coor3high)
coorlist1 = 0
for coor1 in range(coor1low, coor1high):
coorlist2 = 0
for coor2 in range(coor2low, coor2high):
coorlist3 = 0
for coor3 in range(coor3low, coor3high):
x_return[filenum, coor1, coor2,
coor3] = x_temp[coor1min + coorlist1,
coor2min + coorlist2,
coor3min + coorlist3]
coorlist3 += 1
coorlist2 += 1
coorlist1 += 1
filenum += 1
return x_return
def load_traindata():
x_return = np.zeros((495, size, size, size))
x_name = pd.read_csv("train_val.csv")[
'Id'] # 此处[' ']内填写的是train_val.csv内的第一列表头
count_file = 0
for i in range(len(traindata_list)):
x_file_temp = os.path.join(traindata_path, x_name[i] + '.npz')
x_voxel = np.array(np.load(x_file_temp)['voxel'])
x_mask = np.array(np.load(x_file_temp)['seg'])
x_temp = x_voxel * x_mask * 0.8 + x_voxel * 0.2
list_xx = x_mask * x_voxel
list_xx_nz = np.array(np.nonzero(list_xx))
coor1min = list_xx_nz[0, :].min()
coor1max = list_xx_nz[0, :].max()
coor1len = coor1max - coor1min + 1
coor1bigger = coor1len - size
if coor1bigger > 0:
coor1min += coor1bigger // 2
coor1max -= coor1bigger - coor1bigger // 2
coor1len = size
coor1low = (size // 2) - (coor1len // 2)
coor1high = coor1low + coor1len
coor2min = list_xx_nz[1, :].min()
coor2max = list_xx_nz[1, :].max()
coor2len = coor2max - coor2min + 1
coor2bigger = coor2len - size
if coor2bigger > 0:
coor2min += coor2bigger // 2
coor2max -= coor2bigger - coor2bigger // 2
coor2len = size
coor2low = (size // 2) - (coor2len // 2)
coor2high = coor2low + coor2len
coor3min = list_xx_nz[2, :].min()
coor3max = list_xx_nz[2, :].max()
coor3len = coor3max - coor3min + 1
coor3bigger = coor3len - size
if coor3bigger > 0:
coor1min += coor3bigger // 2
coor3max -= coor3bigger - coor3bigger // 2
coor3len = size
coor3low = (size // 2) - (coor3len // 2)
coor3high = coor3low + coor3len
coorlist1 = 0
for coor1 in range(coor1low, coor1high):
coorlist2 = 0
for coor2 in range(coor2low, coor2high):
coorlist3 = 0
for coor3 in range(coor3low, coor3high):
x_return[count_file, coor1, coor2,
coor3] = x_temp[coor1min + coorlist1,
coor2min + coorlist2,
coor3min + coorlist3]
coorlist3 += 1
coorlist2 += 1
coorlist1 += 1
count_file += 1
return x_return
def scaling(self, img, index, resize=False):
img = img.convert('RGB')
im = np.array(img)
red = im[:, :, 0]
green = im[:, :, 1]
blue = im[:, :, 2]
width, height = img.size
# Calculate the second index value to maintain the aspect ratio
aspect_ratio = width / height
index1 = index
index2 = int((index1 + width - (aspect_ratio * height)) / aspect_ratio)
new_img = img.resize((width - index1, height - index2))
new_img = np.array(new_img)
new_red = np.zeros((height - index2, width - index1))
new_green = np.zeros((height - index2, width - index1))
new_blue = np.zeros((height - index2, width - index1))
if index > 0:
new_red[:, :] = red[0:height - index2, 0:width - index1]
new_green[:, :] = green[0:height - index2, 0:width - index1]
new_blue[:, :] = blue[0:height - index2, 0:width - index1]
else:
new_red[0:height, 0:width] = red[:, :]
new_green[0:height, 0:width] = green[:, :]
new_blue[0:height, 0:width] = blue[:, :]
new_img[:, :, 0] = new_red
new_img[:, :, 1] = new_green
new_img[:, :, 2] = new_blue
if not resize:
img = Image.fromarray(new_img)
img = img.resize((width, height))
else:
img = img.resize((width + index1, height + index2))
return img
def drogEdgeDetectorFilter(self, img, ret_grad=False, pillow=True):
if pillow:
img = img.convert('L')
open_cv_image = np.array(img)
width, height = 0, 0
if not pillow:
height, width = img.shape
else:
width, height = img.size
cv2.GaussianBlur(open_cv_image, (15, 15), 0)
# Create sobel x and y matrix
sobel_x = np.array([[-1, 0, 1],
[-2, 0, 2],
[-1, 0, 1]])
sobel_y = np.array([[-1, -2, -1],
[0, 0, 0],
[1, 2, 1]])
kernel1 = np.zeros(open_cv_image.shape)
kernel1[:sobel_x.shape[0], :sobel_x.shape[1]] = sobel_x
kernel1 = np.fft.fft2(kernel1)
kernel2 = np.zeros(open_cv_image.shape)
kernel2[:sobel_y.shape[0], :sobel_y.shape[1]] = sobel_y
kernel2 = np.fft.fft2(kernel2)
im = np.array(open_cv_image)
fim = np.fft.fft2(im)
Gx = np.real(np.fft.ifft2(kernel1 * fim)).astype(float)
Gy = np.real(np.fft.ifft2(kernel2 * fim)).astype(float)
open_cv_image = abs(Gx/4) + abs(Gy/4)
img = Image.fromarray(open_cv_image)
img = img.convert('L')
if ret_grad:
return Gx, Gy
return img
def cannyEdgeDetectorFilter(self, img, sigma=1, t_low=0.01, t_high=0.2):
im = img.convert('L')
img = np.array(im, dtype=float)
# 1) Convolve gaussian kernel with gradient
# gaussian kernel
halfSize = 3 * sigma
maskSize = 2 * halfSize + 1
mat = np.ones((maskSize, maskSize)) / (float)(2 * np.pi * (sigma**2))
xyRange = np.arange(-halfSize, halfSize + 1)
xx, yy = np.meshgrid(xyRange, xyRange)
x2y2 = (xx**2 + yy**2)
exp_part = np.exp(-(x2y2 / (2.0 * (sigma**2))))
gSig = mat * exp_part
gx, gy = self.drogEdgeDetectorFilter(gSig, ret_grad=True, pillow=False)
# 2) Magnitude and Angles
# apply kernels for Ix & Iy
Ix = cv2.filter2D(img, -1, gx)
Iy = cv2.filter2D(img, -1, gy)
# compute magnitude
mag = np.sqrt(Ix**2 + Iy**2)
# normalize magnitude image
normMag = my_Normalize(mag)
# compute orientation of gradient
orient = np.arctan2(Iy, Ix)
# round elements of orient
orientRows = orient.shape[0]
orientCols = orient.shape[1]
# 3) Non maximum suppression
for i in range(0, orientRows):
for j in range(0, orientCols):
if normMag[i, j] > t_low:
# case 0
if (orient[i, j] > (-np.pi / 8) and orient[i, j] <=
(np.pi / 8)):
orient[i, j] = 0
elif (orient[i, j] > (7 * np.pi / 8)
and orient[i, j] <= np.pi):
orient[i, j] = 0
elif (orient[i, j] >= -np.pi and orient[i, j] <
(-7 * np.pi / 8)):
orient[i, j] = 0
# case 1
elif (orient[i, j] > (np.pi / 8) and orient[i, j] <=
(3 * np.pi / 8)):
orient[i, j] = 3
elif (orient[i, j] >= (-7 * np.pi / 8) and orient[i, j] <
(-5 * np.pi / 8)):
orient[i, j] = 3
# case 2
elif (orient[i, j] > (3 * np.pi / 8) and orient[i, j] <=
(5 * np.pi / 8)):
orient[i, j] = 2
elif (orient[i, j] >= (-5 * np.pi / 4) and orient[i, j] <
(-3 * np.pi / 8)):
orient[i, j] = 2
# case 3
elif (orient[i, j] > (5 * np.pi / 8) and orient[i, j] <=
(7 * np.pi / 8)):
orient[i, j] = 1
elif (orient[i, j] >= (-3 * np.pi / 8) and orient[i, j] <
(-np.pi / 8)):
orient[i, j] = 1
mag = normMag
mag_thin = np.zeros(mag.shape)
for i in range(mag.shape[0] - 1):
for j in range(mag.shape[1] - 1):
if mag[i][j] < t_low:
continue
if orient[i][j] == 0:
if mag[i][j] > mag[i][j - 1] and mag[i][j] >= mag[i][j +
1]:
mag_thin[i][j] = mag[i][j]
if orient[i][j] == 1:
if mag[i][j] > mag[i - 1][j + 1] and mag[i][j] >= mag[
i + 1][j - 1]:
mag_thin[i][j] = mag[i][j]
if orient[i][j] == 2:
if mag[i][j] > mag[i - 1][j] and mag[i][j] >= mag[i +
1][j]:
mag_thin[i][j] = mag[i][j]
if orient[i][j] == 3:
if mag[i][j] > mag[i - 1][j - 1] and mag[i][j] >= mag[
i + 1][j + 1]:
mag_thin[i][j] = mag[i][j]
# 4) Thresholding and edge linking
result_binary = np.zeros(mag_thin.shape)
tHigh = t_high
tLow = t_low
# forward scan
for i in range(0, mag_thin.shape[0] - 1): # rows
for j in range(0, mag_thin.shape[1] - 1): # columns
if mag_thin[i][j] >= tHigh:
if mag_thin[i][j + 1] >= tLow: # right
mag_thin[i][j + 1] = tHigh
if mag_thin[i + 1][j + 1] >= tLow: # bottom right
mag_thin[i + 1][j + 1] = tHigh
if mag_thin[i + 1][j] >= tLow: # bottom
mag_thin[i + 1][j] = tHigh
if mag_thin[i + 1][j - 1] >= tLow: # bottom left
mag_thin[i + 1][j - 1] = tHigh
# backwards scan
for i in range(mag_thin.shape[0] - 2, 0, -1): # rows
for j in range(mag_thin.shape[1] - 2, 0, -1): # columns
if mag_thin[i][j] >= tHigh:
if mag_thin[i][j - 1] > tLow: # left
mag_thin[i][j - 1] = tHigh
if mag_thin[i - 1][j - 1]: # top left
mag_thin[i - 1][j - 1] = tHigh
if mag_thin[i - 1][j] > tLow: # top
mag_thin[i - 1][j] = tHigh
if mag_thin[i - 1][j + 1] > tLow: # top right
mag_thin[i - 1][j + 1] = tHigh
# fill in result_binary
for i in range(0, mag_thin.shape[0] - 1): # rows
for j in range(0, mag_thin.shape[1] - 1): # columns
if mag_thin[i][j] >= tHigh:
result_binary[i][j] = 255 # set to 255 for >= tHigh
img = Image.fromarray(result_binary)
return img
def fill_below(x, S, Z):
ind = nx.nonzero(nx.absolute(S-Z)==min(nx.absolute(S-Z)))[0]
Y = nx.zeros(S.shape)
Y[:ind] = S[:ind]
Y[ind:] = Z[ind:]
p.fill(x, Y, facecolor='blue', alpha=0.5)
