def main():
secNum = sys.argv[1]
mkyNum = sys.argv[2]
channel = sys.argv[3]
region = str(sys.argv[4])
conf_dir = '/home/sci/blakez/korenbergNAS/3D_database/Working/Microscopic/confocal/src_registration/'
side_dir = '/home/sci/blakez/korenbergNAS/3D_database/Working/Microscopic/side_light_microscope/src_registration/'
save_dir = '/home/sci/blakez/korenbergNAS/3D_database/Working/Microscopic/confocal/sidelight_registered/'
# DIC = '/home/sci/blakez/Reflect Affine/DIC_to_Reflect.txt'
src_pt = conf_dir + 'M{0}/section_{1}/{2}/section_{1}_confocal_relation_with_sidelight.txt'.format(mkyNum, secNum, region)
tar_pt = side_dir + 'M{0}/section_{1}/section_{1}_sidelight_relation_with_confocal.txt'.format(mkyNum, secNum)
# SID = '/home/sci/blakez/Reflect Affine/sidelight_to_DIC.txt'
src_im = common.LoadITKImage(conf_dir + 'M{0}/section_{1}/{3}/Ch{2}/M{0}_{1}_LGN_RHS_Ch{2}_z00.tif'.format(mkyNum, secNum, channel, region))
# tar_im = common.LoadITKImage('M{0}/{1}/Crop_ThirdNerve_EGFP_z16.tiff'.format(mkyNum, secNum))
# The points need to be chosen in the origin corrected sidescape for downstream purposes
affine = load_and_solve(tar_pt, src_pt)
out_grid = bb_grid_solver(src_im, affine)
z_stack = []
num_slices = len(glob.glob(conf_dir + 'M{0}/section_{1}/{3}/Ch{2}/*'.format(mkyNum, secNum, channel, region)))
for z in range(0, num_slices):
src_im = common.LoadITKImage(conf_dir + 'M{0}/section_{1}/{4}/Ch{2}/M{0}_{1}_LGN_RHS_Ch{2}_z{3}.tif'.format(mkyNum, secNum, channel, str(z).zfill(2), region))
aff_im = ca.Image3D(out_grid, ca.MEM_HOST)
cc.ApplyAffineReal(aff_im, src_im, affine)
common.SaveITKImage(aff_im, save_dir + 'M{0}/section_{1}/{4}/Ch{2}/M{0}_01_section_{1}_LGN_RHS_Ch{2}_conf_aff_sidelight_z{3}.tiff'.format(mkyNum, secNum, channel, str(z).zfill(2), region))
z_stack.append(aff_im)
print('==> Done with {0}/{1}'.format(z, num_slices - 1))
stacked = cc.Imlist_to_Im(z_stack)
stacked.setSpacing(ca.Vec3Df(out_grid.spacing()[0], out_grid.spacing()[1], 0.03/num_slices))
common.SaveITKImage(stacked, save_dir + 'M{0}/section_{1}/{3}/Ch{2}/M{0}_01_section_{1}_Ch{2}_conf_aff_sidelight_stack.nrrd'.format(mkyNum, secNum, channel, region))
common.DebugHere()
if channel==0:
cc.WriteGrid(stacked.grid(), save_dir + 'M{0}/section_{1}/{2}/affine_registration_grid.txt'.format(mkyNum, secNum, region))
BFIfname = 'block{0}_reg_fillblanks_{1}_hd4.mha'.format(block, color)
# BFI = cc.LoadMHA(BFIdir + BFIfname, mType)
# outimage = common.ExtractSliceIm(BFI,100)
cd.Disp3Pane(BFI_aff)
if color in ['bw', 've', 'weight']:
BFIdef = ca.ManagedImage3D(MRIgrid, mType) # these should be small enough
else:
BFIdef = ca.ManagedField3D(MRIgrid, mType)
cc.ApplyHReal(BFIdef, BFI_aff, h)
if sz == MRIsizes[-1] and color == colors[-1]:
cd.Disp3Pane(BFIdef)
# write data
if Write:
if color == 'rgb':
fname = 'block{0}_as_MRI_rgba_{1}.mha'.format(block, sz)
cc.WriteColorMHA(BFIdef, outdir + fname)
fname = 'block{0}_as_MRI_rgb_{1}.mha'.format(block, sz)
cc.WriteMHA(BFIdef, outdir + fname)
else:
#fname = 'block{0}_as_MRI_{1}_{2}_NEWLANDMARKS.mha'.format(block, color, sz)
fname = 'M15_01_to_MRI_TPS_bw_256_VE.mha'
cc.WriteMHA(BFIdef, outdir + fname)
cc.WriteMHA(h, outdir + 'M15_01_to_MRI_TPS_def_256.mha')
# cc.WriteMHA(h, outdir + 'block{0}_TPS_HField_{1}.mha'.format(block,sz))
cd.Disp3Pane(BFIdef)
common.DebugHere()
del BFIdef, BFI
del h
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))
def MatchingImageMomenta(cf):
"""Runs matching for image momenta pair."""
if cf.compute.useCUDA and cf.compute.gpuID is not None:
ca.SetCUDADevice(cf.compute.gpuID)
common.DebugHere()
# prepare output directory
common.Mkdir_p(os.path.dirname(cf.io.outputPrefix))
# Output loaded config
if cf.io.outputPrefix is not None:
cfstr = Config.ConfigToYAML(MatchingImageMomentaConfigSpec, cf)
with open(cf.io.outputPrefix + "parsedconfig.yaml", "w") as f:
f.write(cfstr)
# mem type is determined by whether or not we're using CUDA
mType = ca.MEM_DEVICE if cf.compute.useCUDA else ca.MEM_HOST
# load data in memory
I0 = common.LoadITKImage(cf.study.I, mType)
m0 = common.LoadITKField(cf.study.m, mType)
J1 = common.LoadITKImage(cf.study.J, mType)
n1 = common.LoadITKField(cf.study.n, mType)
# get imGrid from data
imGrid = I0.grid()
# create time array with checkpointing info for this geodesic to be estimated
(s, scratchInd,
rCpinds) = CAvmHGM.HGMSetUpTimeArray(cf.optim.nTimeSteps, [1.0], 0.001)
tDiscGeodesic = CAvmHGMCommon.HGMSetupTimeDiscretizationResidual(
s, rCpinds, imGrid, mType)
# create the state variable for geodesic that is going to hold all info
p0 = ca.Field3D(imGrid, mType)
geodesicState = CAvmHGMCommon.HGMResidualState(
I0,
p0,
imGrid,
mType,
cf.vectormomentum.diffOpParams[0],
cf.vectormomentum.diffOpParams[1],
cf.vectormomentum.diffOpParams[2],
s,
cf.optim.NIterForInverse,
1.0,
cf.vectormomentum.sigmaM,
cf.vectormomentum.sigmaI,
cf.optim.stepSize,
integMethod=cf.optim.integMethod)
# initialize with zero
ca.SetMem(geodesicState.p0, 0.0)
# start up the memory manager for scratch variables
ca.ThreadMemoryManager.init(imGrid, mType, 0)
EnergyHistory = []
# run the loop
for it in range(cf.optim.Niter):
# shoot the geodesic forward
CAvmHGMCommon.HGMIntegrateGeodesic(geodesicState.p0, geodesicState.s,
geodesicState.diffOp,
geodesicState.p, geodesicState.rho,
geodesicState.rhoinv, tDiscGeodesic,
geodesicState.Ninv,
geodesicState.integMethod)
# integrate the geodesic backward
CAvmHGMCommon.HGMIntegrateAdjointsResidual(geodesicState,
tDiscGeodesic, m0, J1, n1)
# TODO: verify it should just be log map/simple image matching when sigmaM=\infty
# gradient descent step for geodesic.p0
CAvmHGMCommon.HGMTakeGradientStepResidual(geodesicState)
# compute and print energy
(VEnergy, IEnergy,
MEnergy) = MatchingImageMomentaComputeEnergy(geodesicState, m0, J1,
n1)
EnergyHistory.append(
[VEnergy + IEnergy + MEnergy, VEnergy, IEnergy, MEnergy])
print "Iter", it, "of", cf.optim.Niter, ":", VEnergy + IEnergy + MEnergy, '(Total) = ', VEnergy, '(Vector) + ', IEnergy, '(Image Match) + ', MEnergy, '(Momenta Match)'
# plots
if cf.io.plotEvery > 0 and (((it + 1) % cf.io.plotEvery == 0) or
(it == cf.optim.Niter - 1)):
MatchingImageMomentaPlots(cf,
geodesicState,
tDiscGeodesic,
EnergyHistory,
m0,
J1,
n1,
writeOutput=True)
# write output
MatchingImageMomentaWriteOuput(cf, geodesicState)
def SaveFrames(checkpointstates, checkpointinds, I0, It, m0, mt, cf):
momentathresh = 0.00002
common.Mkdir_p(os.path.dirname(cf.io.outputPrefix) + '/frames/')
image_idx = 0
fig = plt.figure(1, frameon=False)
plt.clf()
display.DispImage(I0,
'',
newFig=False,
cmap='gray',
dim=cf.io.plotSliceDim,
sliceIdx=cf.io.plotSlice)
plt.draw()
outfilename = cf.io.outputPrefix + '/frames/I' + str(image_idx).zfill(
5) + '.png'
fig.set_size_inches(4, 4)
plt.savefig(outfilename, bbox_inches='tight', pad_inches=0, dpi=100)
fig = plt.figure(2, frameon=False)
plt.clf()
temp = ca.Field3D(I0.grid(), I0.memType())
ca.SetToIdentity(temp)
common.DebugHere()
CAvmCommon.MyGridPlot(temp,
every=cf.io.gridEvery,
color='k',
dim=cf.io.plotSliceDim,
sliceIdx=cf.io.plotSlice,
isVF=False,
plotBase=False)
#fig.patch.set_alpha(0)
#fig.patch.set_visible(False)
a = fig.gca()
#a.set_frame_on(False)
a.set_xticks([])
a.set_yticks([])
plt.axis('tight')
plt.axis('image')
plt.axis('off')
plt.draw()
fig.set_size_inches(4, 4)
outfilename = cf.io.outputPrefix + '/frames/invdef' + str(image_idx).zfill(
5) + '.png'
plt.savefig(outfilename, bbox_inches='tight', pad_inches=0, dpi=100)
fig = plt.figure(3, frameon=False)
plt.clf()
CAvmCommon.MyGridPlot(temp,
every=cf.io.gridEvery,
color='k',
dim=cf.io.plotSliceDim,
sliceIdx=cf.io.plotSlice,
isVF=False,
plotBase=False)
#fig.patch.set_alpha(0)
#fig.patch.set_visible(False)
a = fig.gca()
#a.set_frame_on(False)
a.set_xticks([])
a.set_yticks([])
plt.axis('tight')
plt.axis('image')
plt.axis('off')
plt.draw()
fig.set_size_inches(4, 4)
outfilename = cf.io.outputPrefix + '/frames/def' + str(image_idx).zfill(
5) + '.png'
plt.savefig(outfilename, bbox_inches='tight', pad_inches=0, dpi=100)
fig = plt.figure(4, frameon=False)
plt.clf()
display.DispImage(I0,
'',
newFig=False,
cmap='gray',
dim=cf.io.plotSliceDim,
sliceIdx=cf.io.plotSlice)
plt.hold('True')
CAvmCommon.MyQuiver(m0,
dim=cf.io.plotSliceDim,
sliceIdx=cf.io.plotSlice,
every=cf.io.quiverEvery,
thresh=momentathresh,
scaleArrows=0.25,
arrowCol='r',
lineWidth=0.5,
width=0.005)
plt.draw()
plt.hold('False')
outfilename = cf.io.outputPrefix + '/frames/m' + str(image_idx).zfill(
5) + '.png'
fig.set_size_inches(4, 4)
plt.savefig(outfilename, bbox_inches='tight', pad_inches=0, dpi=100)
for i in range(len(checkpointinds)):
image_idx = image_idx + 1
ca.ApplyH(It, I0, checkpointstates[i][1])
fig = plt.figure(1, frameon=False)
plt.clf()
display.DispImage(It,
'',
newFig=False,
cmap='gray',
dim=cf.io.plotSliceDim,
sliceIdx=cf.io.plotSlice)
plt.draw()
outfilename = cf.io.outputPrefix + '/frames/I' + str(image_idx).zfill(
5) + '.png'
fig.set_size_inches(4, 4)
plt.savefig(outfilename, bbox_inches='tight', pad_inches=0, dpi=100)
fig = plt.figure(2, frameon=False)
plt.clf()
CAvmCommon.MyGridPlot(checkpointstates[i][1],
every=cf.io.gridEvery,
color='k',
dim=cf.io.plotSliceDim,
sliceIdx=cf.io.plotSlice,
isVF=False,
plotBase=False)
#fig.patch.set_alpha(0)
#fig.patch.set_visible(False)
a = fig.gca()
#a.set_frame_on(False)
a.set_xticks([])
a.set_yticks([])
plt.axis('tight')
plt.axis('image')
plt.axis('off')
plt.draw()
outfilename = cf.io.outputPrefix + '/frames/invdef' + str(
image_idx).zfill(5) + '.png'
fig.set_size_inches(4, 4)
plt.savefig(outfilename, bbox_inches='tight', pad_inches=0, dpi=100)
fig = plt.figure(3, frameon=False)
plt.clf()
CAvmCommon.MyGridPlot(checkpointstates[i][0],
every=cf.io.gridEvery,
color='k',
dim=cf.io.plotSliceDim,
sliceIdx=cf.io.plotSlice,
isVF=False,
plotBase=False)
#fig.patch.set_alpha(0)
#fig.patch.set_visible(False)
a = fig.gca()
#a.set_frame_on(False)
a.set_xticks([])
a.set_yticks([])
plt.axis('tight')
plt.axis('image')
plt.axis('off')
plt.draw()
outfilename = cf.io.outputPrefix + '/frames/def' + str(
image_idx).zfill(5) + '.png'
fig.set_size_inches(4, 4)
plt.savefig(outfilename, bbox_inches='tight', pad_inches=0, dpi=100)
ca.CoAd(mt, checkpointstates[i][1], m0)
fig = plt.figure(4, frameon=False)
plt.clf()
display.DispImage(It,
'',
newFig=False,
cmap='gray',
dim=cf.io.plotSliceDim,
sliceIdx=cf.io.plotSlice)
plt.hold('True')
CAvmCommon.MyQuiver(mt,
dim=cf.io.plotSliceDim,
sliceIdx=cf.io.plotSlice,
every=cf.io.quiverEvery,
thresh=momentathresh,
scaleArrows=0.40,
arrowCol='r',
lineWidth=0.5,
width=0.005)
plt.draw()
plt.hold('False')
outfilename = cf.io.outputPrefix + '/frames/m' + str(image_idx).zfill(
5) + '.png'
fig.set_size_inches(4, 4)
plt.savefig(outfilename, bbox_inches='tight', pad_inches=0, dpi=100)
def main():
# Extract the Monkey number and section number from the command line
global frgNum
global secOb
mkyNum = sys.argv[1]
secNum = sys.argv[2]
frgNum = int(sys.argv[3])
write = True
# if not os.path.exists(os.path.expanduser('~/korenbergNAS/3D_database/Working/configuration_files/SidescapeRelateBlockface/M{0}/section_{1}/include_configFile.yaml'.format(mkyNum,secNum))):
# cf = initial(secNum, mkyNum)
try:
secOb = Config.Load(
secSpec,
pth.expanduser(
'~/korenbergNAS/3D_database/Working/configuration_files/SidescapeRelateBlockface/M{0}/section_{1}/include_configFile.yaml'
.format(mkyNum, secNum)))
except IOError as e:
try:
temp = Config.LoadYAMLDict(pth.expanduser(
'~/korenbergNAS/3D_database/Working/configuration_files/SidescapeRelateBlockface/M{0}/section_{1}/include_configFile.yaml'
.format(mkyNum, secNum)),
include=False)
secOb = Config.MkConfig(temp, secSpec)
except IOError:
print 'It appears there is no configuration file for this section. Please initialize one and restart.'
sys.exit()
if frgNum == int(secOb.yamlList[frgNum][-6]):
Fragmenter()
try:
secOb = Config.Load(
secSpec,
pth.expanduser(
'~/korenbergNAS/3D_database/Working/configuration_files/SidescapeRelateBlockface/M{0}/section_{1}/include_configFile.yaml'
.format(mkyNum, secNum)))
except IOError:
print 'It appeas that the include yaml file list does not match your fragmentation number. Please check them and restart.'
sys.exit()
if not pth.exists(
pth.expanduser(secOb.ssiOutPath + 'frag{0}'.format(frgNum))):
common.Mkdir_p(
pth.expanduser(secOb.ssiOutPath + 'frag{0}'.format(frgNum)))
if not pth.exists(
pth.expanduser(secOb.bfiOutPath + 'frag{0}'.format(frgNum))):
common.Mkdir_p(
pth.expanduser(secOb.bfiOutPath + 'frag{0}'.format(frgNum)))
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)))
frgOb = Config.MkConfig(secOb.yamlList[frgNum], frgSpec)
ssiSrc, bfiSrc, ssiMsk, bfiMsk = Loader(frgOb, ca.MEM_HOST)
#Extract the saturation Image from the color iamge
bfiHsv = common.FieldFromNPArr(
matplotlib.colors.rgb_to_hsv(
np.rollaxis(np.array(np.squeeze(bfiSrc.asnp())), 0, 3)),
ca.MEM_HOST)
bfiHsv.setGrid(bfiSrc.grid())
bfiSat = ca.Image3D(bfiSrc.grid(), bfiHsv.memType())
ca.Copy(bfiSat, bfiHsv, 1)
#Histogram equalize, normalize and mask the blockface saturation image
bfiSat = cb.HistogramEqualize(bfiSat, 256)
bfiSat.setGrid(bfiSrc.grid())
bfiSat *= -1
bfiSat -= ca.Min(bfiSat)
bfiSat /= ca.Max(bfiSat)
bfiSat *= bfiMsk
bfiSat.setGrid(bfiSrc.grid())
#Write out the blockface region after adjusting the colors with a format that supports header information
if write:
common.SaveITKImage(
bfiSat,
pth.expanduser(secOb.bfiSrcPath +
'frag{0}/M{1}_01_bfi_section_{2}_frag{0}_sat.nrrd'.
format(frgNum, secOb.mkyNum, secOb.secNum)))
#Set the sidescape grid relative to that of the blockface
ssiSrc.setGrid(ConvertGrid(ssiSrc.grid(), bfiSat.grid()))
ssiMsk.setGrid(ConvertGrid(ssiMsk.grid(), bfiSat.grid()))
ssiSrc *= ssiMsk
#Write out the sidescape masked image in a format that stores the header information
if write:
common.SaveITKImage(
ssiSrc,
pth.expanduser(secOb.ssiSrcPath +
'frag{0}/M{1}_01_ssi_section_{2}_frag{0}.nrrd'.
format(frgNum, secOb.mkyNum, secOb.secNum)))
#Update the image parameters of the sidescape image for future use
frgOb.imSize = ssiSrc.size().tolist()
frgOb.imOrig = ssiSrc.origin().tolist()
frgOb.imSpac = ssiSrc.spacing().tolist()
updateFragOb(frgOb)
#Find the affine transform between the two fragments
bfiAff, ssiAff, aff = Affine(bfiSat, ssiSrc, frgOb)
updateFragOb(frgOb)
#Write out the affine transformed images in a format that stores header information
if write:
common.SaveITKImage(
bfiAff,
pth.expanduser(
secOb.bfiOutPath +
'frag{0}/M{1}_01_bfi_section_{2}_frag{0}_aff_ssi.nrrd'.format(
frgNum, secOb.mkyNum, secOb.secNum)))
common.SaveITKImage(
ssiAff,
pth.expanduser(
secOb.ssiOutPath +
'frag{0}/M{1}_01_ssi_section_{2}_frag{0}_aff_bfi.nrrd'.format(
frgNum, secOb.mkyNum, secOb.secNum)))
bfiVe = bfiAff.copy()
ssiVe = ssiSrc.copy()
cc.VarianceEqualize_I(bfiVe, sigma=frgOb.sigVarBfi, eps=frgOb.epsVar)
cc.VarianceEqualize_I(ssiVe, sigma=frgOb.sigVarSsi, eps=frgOb.epsVar)
#As of right now, the largest pre-computed FFT table is 2048, so resample onto that grid for registration
regGrd = ConvertGrid(
cc.MakeGrid(ca.Vec3Di(2048, 2048, 1), ca.Vec3Df(1, 1, 1),
ca.Vec3Df(0, 0, 0)), ssiSrc.grid())
ssiReg = ca.Image3D(regGrd, ca.MEM_HOST)
bfiReg = ca.Image3D(regGrd, ca.MEM_HOST)
cc.ResampleWorld(ssiReg, ssiVe)
cc.ResampleWorld(bfiReg, bfiVe)
#Create the default configuration object for IDiff Matching and then set some parameters
idCf = Config.SpecToConfig(IDiff.Matching.MatchingConfigSpec)
idCf.compute.useCUDA = True
idCf.io.outputPrefix = '/home/sci/blakez/IDtest/'
#Run the registration
ssiDef, phi = DefReg(ssiReg, bfiReg, frgOb, ca.MEM_DEVICE, idCf)
#Turn the deformation into a displacement field so it can be applied to the large tif with C++ code
affV = phi.copy()
cc.ApplyAffineReal(affV, phi, np.linalg.inv(frgOb.affine))
ca.HtoV_I(affV)
#Apply the found deformation to the input ssi
ssiSrc.toType(ca.MEM_DEVICE)
cc.HtoReal(phi)
affPhi = phi.copy()
ssiBfi = ssiSrc.copy()
upPhi = ca.Field3D(ssiSrc.grid(), phi.memType())
cc.ApplyAffineReal(affPhi, phi, np.linalg.inv(frgOb.affine))
cc.ResampleWorld(upPhi, affPhi, bg=2)
cc.ApplyHReal(ssiBfi, ssiSrc, upPhi)
# ssiPhi = ca.Image3D(ssiSrc.grid(), phi.memType())
# upPhi = ca.Field3D(ssiSrc.grid(), phi.memType())
# cc.ResampleWorld(upPhi, phi, bg=2)
# cc.ApplyHReal(ssiPhi, ssiSrc, upPhi)
# ssiBfi = ssiSrc.copy()
# cc.ApplyAffineReal(ssiBfi, ssiPhi, np.linalg.inv(frgOb.affine))
# #Apply affine to the deformation
# affPhi = phi.copy()
# cc.ApplyAffineReal(affPhi, phi, np.linalg.inv(frgOb.affine))
if write:
common.SaveITKImage(
ssiBfi,
pth.expanduser(
secOb.ssiOutPath +
'frag{0}/M{1}_01_ssi_section_{2}_frag{0}_def_bfi.nrrd'.format(
frgNum, secOb.mkyNum, secOb.secNum)))
cc.WriteMHA(
affPhi,
pth.expanduser(
secOb.ssiOutPath +
'frag{0}/M{1}_01_ssi_section_{2}_frag{0}_to_bfi_real.mha'.
format(frgNum, secOb.mkyNum, secOb.secNum)))
cc.WriteMHA(
affV,
pth.expanduser(
secOb.ssiOutPath +
'frag{0}/M{1}_01_ssi_section_{2}_frag{0}_to_bfi_disp.mha'.
format(frgNum, secOb.mkyNum, secOb.secNum)))
#Create the list of names that the deformation should be applied to
# nameList = ['M15_01_0956_SideLight_DimLED_10x_ORG.tif',
# 'M15_01_0956_TyrosineHydroxylase_Ben_10x_Stitching_c1_ORG.tif',
# 'M15_01_0956_TyrosineHydroxylase_Ben_10x_Stitching_c2_ORG.tif',
# 'M15_01_0956_TyrosineHydroxylase_Ben_10x_Stitching_c3_ORG.tif']
# appLarge(nameList, affPhi)
common.DebugHere()