def _box_positions(fnMask):
mask = volumeio.OpenXML(fnMask, kind='Mask', asNumpy=True)
#mask = np.bitwise_or((mask==1),(mask==5))*1.0
mask = (mask > 0) * 1.0
if P_SIZE[0] > 1:
mask = morph.binary_erosion(mask,
structure=np.ones((2, 1, 1)),
iterations=P_SIZE[0] - 1,
origin=(-1, 0, 0))
if P_SIZE[1] > 1:
mask = morph.binary_erosion(mask,
structure=np.ones((1, 2, 1)),
iterations=P_SIZE[1] - 1,
origin=(0, -1, 0))
if P_SIZE[2] > 1:
mask = morph.binary_erosion(mask,
structure=np.ones((1, 1, 2)),
iterations=P_SIZE[2] - 1,
origin=(0, 0, -1))
gridx, gridy, gridz = np.meshgrid((np.arange(mask.shape[1])) % P_STRIDE[1],
(np.arange(mask.shape[0])) % P_STRIDE[0],
(np.arange(mask.shape[2])) % P_STRIDE[2])
mask *= np.logical_and(np.logical_and((gridx == 0), (gridy == 0)),
(gridz == 0))
return np.where(mask == 1)
def _avg_std(fns, kernel):
std = 0
fn_mask = ''
for i in tqdm(range(len(fns))):
volume = volumeio.OpenXML(fns[i][0], kind='Slices', asNumpy=True)
if fns[i][1] != fn_mask:
fn_mask = fns[i][1]
mask = _mask(fn_mask, kernel)
hp = volume - local_bmd(volume, kernel)
std += (hp[mask == 1]).std()
std /= len(fns)
return std
def _process_calib_fn_ms(fn_in, fn_out, kernel, factor=1.0):
vol_itk = volumeio.OpenXML(fn_in, kind='Slices')
vol_np = volumeio.sitk.GetArrayFromImage(vol_itk)
dtype = vol_np.dtype
lp = local_bmd(vol_np, kernel)
vol_np = (vol_np - lp) * factor + lp
vol_itk2 = volumeio.sitk.GetImageFromArray(vol_np.astype(dtype))
volumeio.CopyMetaData(vol_itk, vol_itk2)
vol_itk2.SetSpacing(vol_itk.GetSpacing())
volumeio.SaveXML(vol_itk2, filename=fn_out, kind='Slices')
def _process_calib_fn(fn_in, fn_out, gt, mask, kernel):
vol_itk = volumeio.OpenXML(fn_in, kind='Slices')
vol_np = volumeio.sitk.GetArrayFromImage(vol_itk)
dtype = vol_np.dtype
vol_np = local_bmd(vol_np, kernel)
m, b = _calibration_values(vol_np, gt, mask)
vol_np = volumeio.sitk.GetArrayFromImage(vol_itk) * m + b
vol_itk2 = volumeio.sitk.GetImageFromArray(vol_np.astype(dtype))
volumeio.CopyMetaData(vol_itk, vol_itk2)
vol_itk2.SetSpacing(vol_itk.GetSpacing())
volumeio.SaveXML(vol_itk2, filename=fn_out, kind='Slices')
def read_subvolume(fn, path=PATH_VOL + '/calib', size=(9, -1, -1)):
vol = volumeio.OpenXML(os.path.join(path, fn), kind='Slices', asNumpy=True)
s = np.array(size)
shape = np.array(vol.shape)
s[s < 0] = shape[s < 0]
#center:
x = shape // 2 - s // 2
vol = vol[x[0]:x[0] + s[0], x[1]:x[1] + s[1], x[2]:x[2] + s[2]]
# remove maybe nans:
vol[np.isnan(vol)] = 0
# meta-data:
try:
l = fn.split('_')
metadata = torch.tensor([int(l[1]), Dataset._type_codes[l[2]]])
except: # ground truth case
metadata = (0, 0)
return (vol, metadata)
def _grab_and_store(positions,
maskIDs,
folder_slices='calib',
path_slices=PATH_VOL,
path_patches=PATH_PATCH):
n = 0
for i in range(len(positions)):
n += len(positions[i][0])
zFill = np.ceil(np.log10(n + 1)).astype(int)
path_slices = os.path.join(path_slices, folder_slices)
path_patches = os.path.join(path_patches, folder_slices, folder_patch())
if os.path.exists(path_patches):
shutil.rmtree(path_patches)
os.makedirs(path_patches)
counter = 0
for pat, maskID in enumerate(maskIDs):
fnSlices = [
f for f in os.listdir(path_slices)
if f.find(maskID) >= 0 and f.find('Slices.xml') >= 0
]
pbar = tqdm(desc=folder_slices + ': ' + maskID,
total=len(fnSlices) * len(positions[pat][0]),
leave=False)
for fn in fnSlices:
imSlices = volumeio.OpenXML(os.path.join(path_slices, fn),
kind='Slices',
asNumpy=True)
fnStore = fn.replace('Slices.xml', '.pt')
for i in range(len(positions[pat][0])):
patch = imSlices[positions[pat][0][i]:positions[pat][0][i] +
P_SIZE[0],
positions[pat][1][i]:positions[pat][1][i] +
P_SIZE[1],
positions[pat][2][i]:positions[pat][2][i] +
P_SIZE[2]]
newfn = fnStore.replace(
maskID, 'P' + str(i + counter).zfill(zFill) + '_' + maskID)
newfn = os.path.join(path_patches, newfn)
if _is_patch_valid(patch): torch.save(patch, newfn)
pbar.update(1)
pbar.close()
counter += len(positions[pat][0])
return counter
def _gt(fn_gt, kernel):
gt = volumeio.OpenXML(fn_gt, kind='Slices', asNumpy=True)
gt = local_bmd(gt, kernel)
return gt
def _mask(fn_mask, kernel):
EPS = 0.001
mask = volumeio.OpenXML(fn_mask, kind='Mask', asNumpy=True)
mask = np.bitwise_or((mask == 1), (mask == 5)) * 1.0
mask = (signal.convolve(mask, kernel, 'same') > (1 - EPS)) * 1.0
return mask