def main():
secNum = sys.argv[1]
mkyNum = sys.argv[2]
region = str(sys.argv[3])
# channel = sys.argv[3]
ext = 'M{0}/section_{1}/{2}/'.format(mkyNum, secNum, region)
ss_dir = '/home/sci/blakez/korenbergNAS/3D_database/Working/Microscopic/side_light_microscope/'
conf_dir = '/home/sci/blakez/korenbergNAS/3D_database/Working/Microscopic/confocal/'
memT = ca.MEM_DEVICE
try:
with open(
ss_dir +
'src_registration/M{0}/section_{1}/M{0}_01_section_{1}_regions.txt'
.format(mkyNum, secNum), 'r') as f:
region_dict = json.load(f)
f.close()
except IOError:
region_dict = {}
region_dict[region] = {}
region_dict['size'] = map(
int,
raw_input("What is the size of the full resolution image x,y? ").
split(','))
region_dict[region]['bbx'] = map(
int,
raw_input(
"What are the x indicies of the bounding box (Matlab Format x_start,x_stop? "
).split(','))
region_dict[region]['bby'] = map(
int,
raw_input(
"What are the y indicies of the bounding box (Matlab Format y_start,y_stop? "
).split(','))
if region not in region_dict:
region_dict[region] = {}
region_dict[region]['bbx'] = map(
int,
raw_input(
"What are the x indicies of the bounding box (Matlab Format x_start,x_stop? "
).split(','))
region_dict[region]['bby'] = map(
int,
raw_input(
"What are the y indicies of the bounding box (Matlab Format y_start,y_stop? "
).split(','))
img_region = common.LoadITKImage(
ss_dir +
'src_registration/M{0}/section_{1}/M{0}_01_section_{1}_{2}.tiff'.
format(mkyNum, secNum, region), ca.MEM_HOST)
ssiSrc = common.LoadITKImage(
ss_dir +
'src_registration/M{0}/section_{1}/frag0/M{0}_01_ssi_section_{1}_frag0.nrrd'
.format(mkyNum, secNum), ca.MEM_HOST)
bfi_df = common.LoadITKField(
ss_dir +
'Blockface_registered/M{0}/section_{1}/frag0/M{0}_01_ssi_section_{1}_frag0_to_bfi_real.mha'
.format(mkyNum, secNum), ca.MEM_DEVICE)
# Figure out the same region in the low resolution image: There is a transpose from here to matlab so dimensions are flipped
low_sz = ssiSrc.size().tolist()
yrng_raw = [(low_sz[1] * region_dict[region]['bbx'][0]) /
np.float(region_dict['size'][0]),
(low_sz[1] * region_dict[region]['bbx'][1]) /
np.float(region_dict['size'][0])]
xrng_raw = [(low_sz[0] * region_dict[region]['bby'][0]) /
np.float(region_dict['size'][1]),
(low_sz[0] * region_dict[region]['bby'][1]) /
np.float(region_dict['size'][1])]
yrng = [np.int(np.floor(yrng_raw[0])), np.int(np.ceil(yrng_raw[1]))]
xrng = [np.int(np.floor(xrng_raw[0])), np.int(np.ceil(xrng_raw[1]))]
low_sub = cc.SubVol(ssiSrc, xrng, yrng)
# Figure out the grid for the sub region in relation to the sidescape
originout = [
ssiSrc.origin().x + ssiSrc.spacing().x * xrng[0],
ssiSrc.origin().y + ssiSrc.spacing().y * yrng[0], 0
]
spacingout = [
(low_sub.size().x * ssiSrc.spacing().x) / (img_region.size().x),
(low_sub.size().y * ssiSrc.spacing().y) / (img_region.size().y), 1
]
gridout = cc.MakeGrid(img_region.size().tolist(), spacingout, originout)
img_region.setGrid(gridout)
only_sub = np.zeros(ssiSrc.size().tolist()[0:2])
only_sub[xrng[0]:xrng[1], yrng[0]:yrng[1]] = np.squeeze(low_sub.asnp())
only_sub = common.ImFromNPArr(only_sub)
only_sub.setGrid(ssiSrc.grid())
# Deform the only sub region to
only_sub.toType(ca.MEM_DEVICE)
def_sub = ca.Image3D(bfi_df.grid(), bfi_df.memType())
cc.ApplyHReal(def_sub, only_sub, bfi_df)
def_sub.toType(ca.MEM_HOST)
# Now have to find the bounding box in the deformation space (bfi space)
if 'deformation_bbx' not in region_dict[region]:
bb_def = np.squeeze(pp.LandmarkPicker([np.squeeze(def_sub.asnp())]))
bb_def_y = [bb_def[0][0], bb_def[1][0]]
bb_def_x = [bb_def[0][1], bb_def[1][1]]
region_dict[region]['deformation_bbx'] = bb_def_x
region_dict[region]['deformation_bby'] = bb_def_y
with open(
ss_dir +
'src_registration/M{0}/section_{1}/M{0}_01_section_{1}_regions.txt'
.format(mkyNum, secNum), 'w') as f:
json.dump(region_dict, f)
f.close()
# Now need to extract the region and create a deformation and image that have the same resolution as the img_region
deform_sub = cc.SubVol(bfi_df, region_dict[region]['deformation_bbx'],
region_dict[region]['deformation_bby'])
common.DebugHere()
sizeout = [
int(
np.ceil((deform_sub.size().x * deform_sub.spacing().x) /
img_region.spacing().x)),
int(
np.ceil((deform_sub.size().y * deform_sub.spacing().y) /
img_region.spacing().y)), 1
]
region_grid = cc.MakeGrid(sizeout,
img_region.spacing().tolist(),
deform_sub.origin().tolist())
def_im_region = ca.Image3D(region_grid, deform_sub.memType())
up_deformation = ca.Field3D(region_grid, deform_sub.memType())
img_region.toType(ca.MEM_DEVICE)
cc.ResampleWorld(up_deformation, deform_sub,
ca.BACKGROUND_STRATEGY_PARTIAL_ZERO)
cc.ApplyHReal(def_im_region, img_region, up_deformation)
ss_out = ss_dir + 'Blockface_registered/M{0}/section_{1}/{2}/'.format(
mkyNum, secNum, region)
if not pth.exists(pth.expanduser(ss_out)):
os.mkdir(pth.expanduser(ss_out))
common.SaveITKImage(
def_im_region,
pth.expanduser(ss_out) +
'M{0}_01_section_{1}_{2}_def_to_bfi.nrrd'.format(
mkyNum, secNum, region))
common.SaveITKImage(
def_im_region,
pth.expanduser(ss_out) +
'M{0}_01_section_{1}_{2}_def_to_bfi.tiff'.format(
mkyNum, secNum, region))
del img_region, def_im_region, ssiSrc, deform_sub
# Now apply the same deformation to the confocal images
conf_grid = cc.LoadGrid(
conf_dir +
'sidelight_registered/M{0}/section_{1}/{2}/affine_registration_grid.txt'
.format(mkyNum, secNum, region))
cf_out = conf_dir + 'blockface_registered/M{0}/section_{1}/{2}/'.format(
mkyNum, secNum, region)
# confocal.toType(ca.MEM_DEVICE)
# def_conf = ca.Image3D(region_grid, deform_sub.memType())
# cc.ApplyHReal(def_conf, confocal, up_deformation)
for channel in range(0, 4):
z_stack = []
num_slices = len(
glob.glob(conf_dir +
'sidelight_registered/M{0}/section_{1}/{3}/Ch{2}/*.tiff'.
format(mkyNum, secNum, channel, region)))
for z in range(0, num_slices):
src_im = common.LoadITKImage(
conf_dir +
'sidelight_registered/M{0}/section_{1}/{3}/Ch{2}/M{0}_01_section_{1}_LGN_RHS_Ch{2}_conf_aff_sidelight_z{4}.tiff'
.format(mkyNum, secNum, channel, region,
str(z).zfill(2)))
src_im.setGrid(
cc.MakeGrid(
ca.Vec3Di(conf_grid.size().x,
conf_grid.size().y, 1), conf_grid.spacing(),
conf_grid.origin()))
src_im.toType(ca.MEM_DEVICE)
def_im = ca.Image3D(region_grid, ca.MEM_DEVICE)
cc.ApplyHReal(def_im, src_im, up_deformation)
def_im.toType(ca.MEM_HOST)
common.SaveITKImage(
def_im, cf_out +
'Ch{2}/M{0}_01_section_{1}_{3}_Ch{2}_conf_def_blockface_z{4}.tiff'
.format(mkyNum, secNum, channel, region,
str(z).zfill(2)))
if z == 0:
common.SaveITKImage(
def_im, cf_out +
'Ch{2}/M{0}_01_section_{1}_{3}_Ch{2}_conf_def_blockface_z{4}.nrrd'
.format(mkyNum, secNum, channel, region,
str(z).zfill(2)))
z_stack.append(def_im)
print('==> Done with Ch {0}: {1}/{2}'.format(
channel, z, num_slices - 1))
stacked = cc.Imlist_to_Im(z_stack)
stacked.setSpacing(
ca.Vec3Df(region_grid.spacing().x,
region_grid.spacing().y,
conf_grid.spacing().z))
common.SaveITKImage(
stacked, cf_out +
'Ch{2}/M{0}_01_section_{1}_{3}_Ch{2}_conf_def_blockface_stack.nrrd'
.format(mkyNum, secNum, channel, region))
if channel == 0:
cc.WriteGrid(
stacked.grid(),
cf_out + 'deformed_registration_grid.txt'.format(
mkyNum, secNum, region))
# fname = 'block{0}_reg_fillblanks_bw.mha'.format(block)
# tmp = cc.LoadMHA(BFIdir + fname)
# cc.WriteGrid(tmp.grid(), BFIdir + 'block{0}_grid.txt'.format(block))
# tmp = cc.LoadMHA(MRI_fname)
# cc.WriteGrid(tmp.grid(), MRIdir + 'T2_grid.txt'.format(block))
# sys.exit()
#BFIgrid = cc.LoadGrid(BFIdir + 'block{0}_grid.txt'.format(block))
#MRIgrid = cc.LoadGrid(MRIdir + 'T2_grid.txt'.format(block))
MRI = cc.LoadMHA(MRI_fname,ca.MEM_HOST)
MRIgrid = MRI.grid()
#MRIgrid = cc.MakeGrid(MRI.size(),MRI.spacing(),'center')
#MRI.setGrid(MRIgrid)
#BFI = cc.LoadMHA(BFIdir + 'M15_01_seg_crop_hd8.mha',ca.MEM_HOST)
BFI_full = cc.LoadMHA(BFIdir + 'M15_01_hd8_VE.mha',ca.MEM_HOST)
BFI = cc.SubVol(BFI_full, yrng=[146,626])
BFIgrid = cc.MakeGrid(ca.Vec3Di(480,480,2239),ca.Vec3Df(0.1185,0.1185,0.030),'center')
BFI.setGrid(BFIgrid)
#BFIgrid = BFI.grid()
print MRIgrid
print BFIgrid
# print 'b4 memory', 480*480*874*4/1024./1024 *7 # 7 blocks, mem size
# print 'mri memory', 256*256*256*4/1024./1024 *7 # 7 blocks, mem size
# print 'mri big memory', 512*512*512*4/1024./1024 *7 # 7 blocks, mem size
# print 'single mri ', 256*256*256*4/1024./1024
#landmarks = get_new_landmarks(block)
# Use these landmarks for an affine
### landmarks = [[[1893.0,123.0,401.0], [187.0,135.0,202.0]],
### [[1798.0,416.0,333.0], [183.0,131.0,48.0]],
### [[892.0,222.0,251.0], [84.0,109.0,132.0]],
def Fragmenter():
tmpOb = Config.Load(
frgSpec,
pth.expanduser(
'~/korenbergNAS/3D_database/Working/configuration_files/SidescapeRelateBlockface/M{0}/section_{1}/section_{1}_frag0.yaml'
.format(secOb.mkyNum, secOb.secNum)))
dictBuild = {}
#Load in the whole image so that the fragment can cropped out
ssiSrc, bfiSrc, ssiMsk, bfiMsk = Loader(tmpOb, ca.MEM_HOST)
#Because some of the functions only woth with gray images
bfiGry = ca.Image3D(bfiSrc.grid(), bfiSrc.memType())
ca.Copy(bfiGry, bfiSrc, 1)
lblSsi, _ = ndimage.label(np.squeeze(ssiMsk.asnp()) > 0)
lblBfi, _ = ndimage.label(np.squeeze(bfiMsk.asnp()) > 0)
seedPt = np.squeeze(pp.LandmarkPicker([lblBfi, lblSsi]))
subMskBfi = common.ImFromNPArr(lblBfi == lblBfi[seedPt[0, 0],
seedPt[0,
1]].astype('int8'),
sp=bfiSrc.spacing(),
orig=bfiSrc.origin())
subMskSsi = common.ImFromNPArr(lblSsi == lblSsi[seedPt[1, 0],
seedPt[1,
1]].astype('int8'),
sp=ssiSrc.spacing(),
orig=ssiSrc.origin())
bfiGry *= subMskBfi
bfiSrc *= subMskBfi
ssiSrc *= subMskSsi
#Pick points that are the bounding box of the desired subvolume
corners = np.array(
pp.LandmarkPicker(
[np.squeeze(bfiGry.asnp()),
np.squeeze(ssiSrc.asnp())]))
bfiCds = corners[:, 0]
ssiCds = corners[:, 1]
#Extract the region from the source images
bfiRgn = cc.SubVol(bfiSrc,
xrng=[bfiCds[0, 0], bfiCds[1, 0]],
yrng=[bfiCds[0, 1], bfiCds[1, 1]])
ssiRgn = cc.SubVol(ssiSrc,
xrng=[ssiCds[0, 0], ssiCds[1, 0]],
yrng=[ssiCds[0, 1], ssiCds[1, 1]])
#Extract the region from the mask images
rgnMskSsi = cc.SubVol(subMskSsi,
xrng=[ssiCds[0, 0], ssiCds[1, 0]],
yrng=[ssiCds[0, 1], ssiCds[1, 1]])
rgnMskBfi = cc.SubVol(subMskBfi,
xrng=[bfiCds[0, 0], bfiCds[1, 0]],
yrng=[bfiCds[0, 1], bfiCds[1, 1]])
dictBuild['rgnBfi'] = np.divide(
bfiCds, np.array(bfiSrc.size().tolist()[0:2], 'float')).tolist()
dictBuild['rgnSsi'] = np.divide(
ssiCds, np.array(ssiSrc.size().tolist()[0:2], 'float')).tolist()
#Check the output directory for the source files of the fragment
if not pth.exists(
pth.expanduser(secOb.ssiSrcPath + 'frag{0}'.format(frgNum))):
os.mkdir(pth.expanduser(secOb.ssiSrcPath + 'frag{0}'.format(frgNum)))
if not pth.exists(
pth.expanduser(secOb.bfiSrcPath + 'frag{0}'.format(frgNum))):
os.mkdir(pth.expanduser(secOb.bfiSrcPath + 'frag{0}'.format(frgNum)))
#Check the output directory for the mask files of the fragment
if not pth.exists(
pth.expanduser(secOb.ssiMskPath + 'frag{0}'.format(frgNum))):
os.mkdir(pth.expanduser(secOb.ssiMskPath + 'frag{0}'.format(frgNum)))
if not pth.exists(
pth.expanduser(secOb.bfiMskPath + 'frag{0}'.format(frgNum))):
os.mkdir(pth.expanduser(secOb.bfiMskPath + 'frag{0}'.format(frgNum)))
dictBuild[
'ssiSrcName'] = 'frag{0}/M{1}_01_ssi_section_{2}_frag1.tif'.format(
frgNum, secOb.mkyNum, secOb.secNum)
dictBuild[
'bfiSrcName'] = 'frag{0}/M{1}_01_bfi_section_{2}_frag1.mha'.format(
frgNum, secOb.mkyNum, secOb.secNum)
dictBuild[
'ssiMskName'] = 'frag{0}/M{1}_01_ssi_section_{2}_frag1_mask.tif'.format(
frgNum, secOb.mkyNum, secOb.secNum)
dictBuild[
'bfiMskName'] = 'frag{0}/M{1}_01_bfi_section_{2}_frag1_mask.tif'.format(
frgNum, secOb.mkyNum, secOb.secNum)
#Write out the masked and cropped images so that they can be loaded from the YAML file
#The BFI region needs to be saved as color and mha format so that the grid information is carried over.
common.SaveITKImage(
ssiRgn, pth.expanduser(secOb.ssiSrcPath + dictBuild['ssiSrcName']))
cc.WriteColorMHA(
bfiRgn, pth.expanduser(secOb.bfiSrcPath + dictBuild['bfiSrcName']))
common.SaveITKImage(
rgnMskSsi, pth.expanduser(secOb.ssiMskPath + dictBuild['ssiMskName']))
common.SaveITKImage(
rgnMskBfi, pth.expanduser(secOb.bfiMskPath + dictBuild['bfiMskName']))
frgOb = Config.MkConfig(dictBuild, frgSpec)
updateFragOb(frgOb)
return None