def test_SplatAdjoint(self, disp=False):
hI = common.RandImage(self.sz,
nSig=1.0,
gSig=0.0,
mType=ca.MEM_HOST,
sp=self.imSp)
hJ = common.RandImage(self.sz,
nSig=1.0,
gSig=0.0,
mType=ca.MEM_HOST,
sp=self.imSp)
hPhi = common.RandField(self.sz,
nSig=5.0,
gSig=4.0,
mType=ca.MEM_HOST,
sp=self.imSp)
tmp = ca.Image3D(self.grid, ca.MEM_HOST)
# compute < I(Phi(x)), J(x) >
ca.ApplyH(tmp, hI, hPhi)
phiIdotJ = ca.Dot(tmp, hJ)
# compute < I(y), |DPhi^{-1}(y)| J(Phi^{-1}(y)) >
ca.Splat(tmp, hPhi, hJ)
IdotphiJ = ca.Dot(tmp, hI)
#print "a=%f b=%f" % (phiIdotJ, IdotphiJ)
self.assertLess(abs(phiIdotJ - IdotphiJ), 2e-6)
def test_GroupAdjointAction(self, disp=False):
hM = common.RandField(self.sz,
nSig=5.0,
gSig=4.0,
mType=ca.MEM_HOST,
sp=self.imSp)
hV = common.RandField(self.sz,
nSig=5.0,
gSig=4.0,
mType=ca.MEM_HOST,
sp=self.imSp)
hPhi = common.RandField(self.sz,
nSig=5.0,
gSig=4.0,
mType=ca.MEM_HOST,
sp=self.imSp)
tmp = ca.Field3D(self.grid, ca.MEM_HOST)
# compute < m, Ad_\phi v >
ca.Ad(tmp, hPhi, hV)
rhs = ca.Dot(tmp, hM)
# compute < Ad^*_\phi m, v >
ca.CoAd(tmp, hPhi, hM)
lhs = ca.Dot(tmp, hV)
#print "a=%f b=%f" % (rhs, lhs)
self.assertLess(abs(rhs - lhs), 2e-6)
def Compute(workerFn, cf):
"""Run parallel workerFn using compute configuration"""
if cf.compute.useMPI and 'OMPI_COMM_WORLD_LOCAL_RANK' not in os.environ:
# is it is not already started as an MPI process
# get hostlists from hostfile and pass it to Spawn
Spawn(nproc=min(cf.compute.numProcesses, cf.study.numSubjects),
hostList=ReadHostFile(cf.compute.hostFile))
elif 'OMPI_COMM_WORLD_LOCAL_RANK' in os.environ:
# if already running as an MPI process, may be from outside python
# behave as if started from inside
cf.compute.useMPI = True
cf.compute.numProcesses = GetMPIInfo()['size']
if cf.compute.useMPI:
# so that exceptions raised by mpi threads are
# properly handled
sys.excepthook = mpi_excepthook
if cf.compute.useMPI:
# Simple check that we're not using more host processes than GPUs
mpiLocalRank = GetMPIInfo()['local_rank']
if cf.compute.useCUDA:
if mpiLocalRank >= ca.GetNumberOfCUDADevices():
#MPI.COMM_WORLD.Abort(1)
raise Exception("Please don't use more host processes " +
"than GPUs")
ca.SetCUDADevice(mpiLocalRank)
# run the worker process
workerFn(cf)
def RandField(sz,
nSig=1.0,
gSig=0.0,
NonNeg=False,
mType=core.MEM_HOST,
sp=core.Vec3Df(1.0, 1.0, 1.0),
orig=core.Vec3Df(0.0, 0.0, 0.0)):
vSz = list(sz)
dim = len(vSz)
assert dim == 2 or dim == 3
if dim == 3 and vSz[2] == 1:
dim = 2
if dim == 2:
vSz.append(1)
vSz.append(3)
vArr = np.zeros(vSz)
for d in range(dim):
vDimArr = np.atleast_3d(nSig * np.random.randn(*vSz[0:2]))
if gSig > 0:
vDimArr = common.GaussianBlur(vDimArr, gSig)
vArr[:, :, :, d] = vDimArr
if NonNeg:
vArr = np.abs(vArr)
v = common.FieldFromNPArr(vArr, mType, sp=sp, orig=orig)
return v
def LoadPNGImage(fname,
mType=core.MEM_HOST,
sp=core.Vec3Df(1.0, 1.0, 1.0),
orig=core.Vec3Df(0.0, 0.0, 0.0)):
imArr = plt.imread(fname)
im = ImFromNPArr(imArr, mType=mType, sp=sp, orig=orig)
return im
def test_ThreadMemMan(self):
# these have to be run in this order
self.MemManAlloc()
self.InitMgr()
self.MemManDeAlloc()
mType = ca.MEM_HOST
self.assertTrue(ca.ThreadMemoryManager.isInitialized())
tmm = ca.ThreadMemoryManager.instance()
NImages = 50
NFields = 50
for k in range(20):
# print 'k=',k
imList = []
fieldList = []
for i in range(NImages):
imList.append(ca.ManagedImage3D(self.grid, mType))
# print len(imList)
# print tmm.getNumPools()
for i in range(NFields):
fieldList.append(ca.ManagedField3D(self.grid, mType))
# print len(fieldList)
# print tmm.getNumPools()
self.assertEqual(tmm.getNumPools(), NFields * 3 + NImages)
def SubRegion(src_grid, sub_grid, def_grid):
# The sapcing of the src image was changed, so we have to find the new spacing of the sub region
reg_grid = ConvertGrid(src_grid, def_grid)
spacing = (np.array(reg_grid.spacing().tolist()) / np.array(
src_grid.spacing().tolist())) * np.array(sub_grid.spacing().tolist())
# Because we updated the spacing, the origin of the sub region will change and we have to find the new origin
# The new origin is the upper left real coordinate of the subregion to extract
pixel_origin = np.array(sub_grid.origin().tolist()) / np.array(
src_grid.spacing().tolist())
upL_real = pixel_origin * np.array(reg_grid.spacing().tolist()) + np.array(
reg_grid.origin().tolist())
# Now need to find the bottom right in real coordinates
btR_real = (spacing * np.array(sub_grid.size().tolist())) + upL_real
# Now that we have the top left and bottom right, we need to convert them to index corrdiantes of the deformation grid
upL = np.floor((upL_real - np.array(def_grid.origin().tolist())) /
np.array(def_grid.spacing().tolist()))
btR = np.floor((btR_real - np.array(def_grid.origin().tolist())) /
np.array(def_grid.spacing().tolist()))
xrng = [int(upL[0]), int(btR[0])]
yrng = [int(upL[1]), int(btR[1])]
new_sub_grid = cc.MakeGrid(
ca.Vec3Di(sub_grid.size()[0],
sub_grid.size()[1], 1), ca.Vec3Df(spacing[0], spacing[1], 1),
ca.Vec3Df(upL_real[0], upL_real[1], 0))
return xrng, yrng, new_sub_grid
def HGMPreprocessInput(cf, J, n):
for i in range(len(J)):
if cf.study.setUnitSpacing:
J[i].setSpacing(ca.Vec3Df(1.0, 1.0, 1.0))
n[i].setSpacing(ca.Vec3Df(1.0, 1.0, 1.0))
if cf.study.setZeroOrigin:
J[i].setOrigin(ca.Vec3Df(0, 0, 0))
n[i].setOrigin(ca.Vec3Df(0, 0, 0))
def MemManAlloc(self):
# this should just create an unmanaged image
assert (not ca.ThreadMemoryManager.isInitialized())
I = ca.ManagedImage3D(self.grid, ca.MEM_HOST)
J = ca.ManagedImage3D(self.grid, ca.MEM_HOST)
ca.MulC(I, J, 2.0) # test that we can do something with these things
# Finally, make sure the TMM stays uninitialized
assert (not ca.ThreadMemoryManager.isInitialized())
def GeoRegPreprocessInput(subid, cf, p, t, Imsmts, cpinds, cpstates, msmtinds,
gradAtMsmts):
for i in range(len(Imsmts)):
if cf.study.setUnitSpacing:
Imsmts[i].setSpacing(ca.Vec3Df(1.0, 1.0, 1.0))
if cf.study.setZeroOrigin:
Imsmts[i].setOrigin(ca.Vec3Df(0, 0, 0))
ca.MulC_I(Imsmts[i], 1.0 / float(255.0))
def RandUnifImage(sz,
lbound=0,
ubound=1,
mType=core.MEM_HOST,
sp=core.Vec3Df(1.0, 1.0, 1.0),
orig=core.Vec3Df(0.0, 0.0, 0.0)):
imArr = np.random.rand(*sz) * (ubound - lbound) + lbound
im = common.ImFromNPArr(imArr, mType, sp=sp, orig=orig)
return im
def DispImage(im, title=None,
sliceIdx=None, dim='z',
cmap='gray', newFig=True,
rng=None, t=False, log=False):
# if this volume is not a slice already, extract a slice
sz = im.size().tolist()
if sz[common.DIMMAP[dim]] > 1:
im = common.ExtractSliceIm(im, sliceIdx, dim)
im.toType(core.MEM_HOST)
# transfer to host memory if necessary
if im.memType() == core.MEM_DEVICE:
tmp = core.Image3D(im.grid(), core.MEM_HOST)
core.Copy(tmp, im)
im = tmp
# create the figure if requested
if newFig:
if title is None:
plt.figure()
else:
plt.figure(title)
plt.clf()
# set the range
if rng is None:
vmin = None
vmax = None
else:
vmin = rng[0]
vmax = rng[1]
if log:
norm = matplotlib.colors.LogNorm(vmin=vmin, vmax=vmax)
else:
norm = matplotlib.colors.Normalize(vmin=vmin, vmax=vmax)
# convert to numpy array
arr = np.squeeze(im.asnp().copy())
# transpose if requested
if t:
arr = arr.T
# display
plt.imshow(arr, cmap=cmap, vmin=vmin, vmax=vmax, norm=norm, interpolation='nearest')
plt.axis('tight')
plt.axis('image')
if title is not None:
plt.title(title)
plt.xticks([])
plt.yticks([])
plt.draw()
def ImFromNPArr(arr,
mType=core.MEM_HOST,
sp=core.Vec3Df(1.0, 1.0, 1.0),
orig=core.Vec3Df(0.0, 0.0, 0.0)):
arr3d = np.atleast_3d(arr)
imSz = core.Vec3Di()
imSz.fromlist(arr3d.shape)
grid = core.GridInfo(imSz, sp, orig)
im = core.Image3D(grid, core.MEM_HOST)
im.asnp()[:, :, :] = arr3d
im.toType(mType)
return im
def ExtractROI(im, extent):
roiStart = core.Vec3Di(extent[0], extent[2], extent[4])
roiSize = core.Vec3Di(extent[1] - extent[0] + 1, extent[3] - extent[2] + 1,
extent[5] - extent[4] + 1)
roiGrid = core.GridInfo(im.grid().size(),
im.grid().spacing(),
im.grid().origin())
roiGrid.setSize(roiSize)
roi = core.Image3D(roiGrid, im.memType())
core.SubVol(roi, im, roiStart)
return roi
def LoadFieldNPZ(fname, mType=core.MEM_HOST):
"""Load a field in *.npz format (with proper origin/spacing info)"""
# TODO: put some format validation in here
npz = np.load(fname)
spacing = core.Vec3Df()
spacing.fromlist(npz['spacing'])
origin = core.Vec3Df()
origin.fromlist(npz['origin'])
f = common.FieldFromNPArr(npz['data'], mType=mType, sp=spacing, orig=origin)
del npz.f
npz.close()
return f
def RandImage(sz,
nSig=1.0,
gSig=0.0,
NonNeg=False,
mType=core.MEM_HOST,
sp=core.Vec3Df(1.0, 1.0, 1.0),
orig=core.Vec3Df(0.0, 0.0, 0.0)):
imArr = nSig * np.random.randn(*sz)
if gSig > 0:
imArr = common.GaussianBlur(imArr, gSig)
if NonNeg:
imArr = np.abs(imArr)
im = common.ImFromNPArr(imArr, mType, sp=sp, orig=orig)
return im
def MemManDeAlloc(self):
# test that the memory manager releases memory when deleting a managed
# image
ca.ThreadMemoryManager.init(self.grid, ca.MEM_HOST, 0)
tmm = ca.ThreadMemoryManager.instance()
#nInitialIm = tmm.getNumPools()
I = ca.ManagedImage3D(self.grid, ca.MEM_HOST)
nImAfterFirstAlloc = tmm.getNumPools()
del I
J = ca.ManagedImage3D(self.grid, ca.MEM_HOST)
nFinalIm = tmm.getNumPools()
del J
# Test that we actually freed I, so that J now resides where I was
assert (nImAfterFirstAlloc == nFinalIm)
def test_SplatWorldAdjoint(self, disp=False):
# Random input images
reg = common.RandImage(self.sz,
nSig=1.0,
gSig=0.0,
mType=ca.MEM_HOST,
sp=self.imSp)
# adjust hJ's grid so that voxels don't align perfectly
spfactor = 0.77382
small = common.RandImage(self.sz,
nSig=1.0,
gSig=0.0,
mType=ca.MEM_HOST,
sp=self.imSp * spfactor)
tmpsmall = ca.Image3D(small.grid(), ca.MEM_HOST)
ca.SetMem(tmpsmall, 0)
# compute < I(Phi(x)), J(x) >
ca.ResampleWorld(tmpsmall, reg)
smallIP = ca.Dot(tmpsmall, small)
# compute < I(y), |DPhi^{-1}(y)| J(Phi^{-1}(y)) >
tmpreg = ca.Image3D(reg.grid(), ca.MEM_HOST)
ca.SetMem(tmpreg, 0)
ca.SplatWorld(tmpreg, small)
regIP = ca.Dot(tmpreg, reg)
#print "a=%f b=%f" % (phiIdotJ, IdotphiJ)
self.assertLess(abs(smallIP - regIP), 2e-6)
def __init__(self, methodName='runTest'):
super(MiscTestCase, self).__init__(methodName)
self.cudaEnabled = (ca.GetNumberOfCUDADevices() > 0)
# image size
self.sz = np.array([128, 120])
# spacing
self.sp = [1.5, 2.1]
# Vec3D versions
self.imSz = ca.Vec3Di(int(self.sz[0]), int(self.sz[1]), 1)
self.imSp = ca.Vec3Df(float(self.sp[0]), float(self.sp[1]), 1.0)
# set up grid
self.grid = ca.GridInfo(self.imSz, self.imSp)
def HGMComputeJumpGradientsFromResidual(gradIntercept, gradSlope,
residualState, mt, J1, n1):
interceptEnergy = 0.0
slopeEnergy = 0.0
grid = residualState.J0.grid()
mType = residualState.J0.memType()
imdiff = ca.ManagedImage3D(grid, mType)
vecdiff = ca.ManagedField3D(grid, mType)
# 1. Gradient for Intercept
ApplyH(imdiff, residualState.J0, residualState.rhoinv)
Sub_I(imdiff, J1)
iEnergy = 0.5 * ca.Sum2(imdiff) / (
float(residualState.p0.nVox()) * residualState.Sigma *
residualState.Sigma * residualState.SigmaIntercept *
residualState.SigmaIntercept) # save for use in intercept energy term
MulC_I(
imdiff,
1.0 / (residualState.SigmaIntercept * residualState.SigmaIntercept *
residualState.Sigma * residualState.Sigma))
#Splat(gradIntercept, residualState.rhoinv, imdiff,False)
SplatSafe(gradIntercept, residualState.rhoinv, imdiff)
# 2. Gradient for Slope
CoAd(residualState.p, residualState.rhoinv, mt)
Sub_I(residualState.p, n1)
Copy(vecdiff, residualState.p) # save for use in slope energy term
residualState.diffOp.applyInverseOperator(residualState.p)
# apply Ad and get the result in gradSlope
Ad(gradSlope, residualState.rhoinv, residualState.p)
MulC_I(gradSlope,
1.0 / (residualState.SigmaSlope * residualState.SigmaSlope))
# energy computation here
# slope term
slopeEnergy = ca.Dot(residualState.p, vecdiff) / (
float(residualState.p0.nVox()) * residualState.SigmaSlope *
residualState.SigmaSlope)
# intercept term. p is used as scratch variable
Copy(residualState.p, residualState.p0)
residualState.diffOp.applyInverseOperator(residualState.p)
pEnergy = ca.Dot(residualState.p0, residualState.p) / (
float(residualState.p0.nVox()) * residualState.SigmaIntercept *
residualState.SigmaIntercept)
return (pEnergy, iEnergy, slopeEnergy)
def WavyDef(sz,
nWaves=4,
waveAmp=10,
waveDim=0,
mType=core.MEM_HOST,
deformation=True):
"""
Generate and return a 'wavy' vector field. If deformation is
True, return a deformation, otherwise return a displacement.
"""
gridy, gridx = np.meshgrid(np.arange(0, sz[1]), np.arange(0, sz[0]))
if waveDim == 0:
wGrid = gridy
elif waveDim == 1:
wGrid = gridx
else:
raise Exception('waveDim should be 0 or 1')
vfArr = np.zeros((sz[0], sz[1], 2))
vfArr[:,:,waveDim] = \
waveAmp*np.sin(2*np.pi*nWaves*wGrid/float(sz[1]))
vf = common.FieldFromNPArr(vfArr, mType=mType)
if deformation:
core.VtoH_I(vf)
return vf
def ConvertGrid(I_src_grid, I_tar_grid):
'''Given a source grid and target grid, returns a grid for the source that is in the world coordinates of the target grid'''
nS = np.multiply(
np.divide(I_tar_grid.size().tolist(),
[float(i) for i in I_src_grid.size().tolist()]),
I_tar_grid.spacing().tolist())
return cc.MakeGrid(I_src_grid.size(), ca.Vec3Df(nS[0], nS[1], nS[2]),
'center')
def Matching(cf):
if cf.compute.useCUDA and cf.compute.gpuID is not None:
ca.SetCUDADevice(cf.compute.gpuID)
# 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(MatchingConfigSpec, cf)
with open(cf.io.outputPrefix + "parsedconfig.yaml", "w") as f:
f.write(cfstr)
mType = ca.MEM_DEVICE if cf.compute.useCUDA else ca.MEM_HOST
I0 = common.LoadITKImage(cf.study.I0, mType)
I1 = common.LoadITKImage(cf.study.I1, mType)
#ca.DivC_I(I0,255.0)
#ca.DivC_I(I1,255.0)
grid = I0.grid()
ca.ThreadMemoryManager.init(grid, mType, 1)
#common.DebugHere()
# TODO: need to work on these
t = [x*1./cf.optim.nTimeSteps for x in range(cf.optim.nTimeSteps+1)]
checkpointinds = range(1,len(t))
checkpointstates = [(ca.Field3D(grid,mType),ca.Field3D(grid,mType)) for idx in checkpointinds]
p = MatchingVariables(I0,I1, cf.vectormomentum.sigma, t,checkpointinds, checkpointstates, cf.vectormomentum.diffOpParams[0], cf.vectormomentum.diffOpParams[1], cf.vectormomentum.diffOpParams[2], cf.optim.Niter, cf.optim.stepSize, cf.optim.maxPert, cf.optim.nTimeSteps, integMethod = cf.optim.integMethod, optMethod=cf.optim.method, nInv=cf.optim.NIterForInverse,plotEvery=cf.io.plotEvery, plotSlice = cf.io.plotSlice, quiverEvery = cf.io.quiverEvery, outputPrefix = cf.io.outputPrefix)
RunMatching(p)
# write output
if cf.io.outputPrefix is not None:
# reset all variables by shooting once, may have been overwritten
CAvmCommon.IntegrateGeodesic(p.m0,p.t,p.diffOp,\
p.m, p.g, p.ginv,\
p.scratchV1, p.scratchV2,p. scratchV3,\
p.checkpointstates, p.checkpointinds,\
Ninv=p.nInv, integMethod = p.integMethod)
common.SaveITKField(p.m0, cf.io.outputPrefix+"m0.mhd")
common.SaveITKField(p.ginv, cf.io.outputPrefix+"phiinv.mhd")
common.SaveITKField(p.g, cf.io.outputPrefix+"phi.mhd")
def setScale(scale):
global curGrid
scaleManager.set(scale)
curGrid = scaleManager.getCurGrid()
# since this is only 2D:
curGrid.spacing().z = 1.0
resampler.setScaleLevel(scaleManager)
diffOp.setAlpha(fluidParams[0])
diffOp.setBeta(fluidParams[1])
diffOp.setGamma(fluidParams[2])
diffOp.setGrid(curGrid)
# downsample images
I0.setGrid(curGrid)
I1.setGrid(curGrid)
if scaleManager.isLastScale():
ca.Copy(I0, I0Orig)
ca.Copy(I1, I1Orig)
else:
resampler.downsampleImage(I0, I0Orig)
resampler.downsampleImage(I1, I1Orig)
if Mask != None:
if scaleManager.isLastScale():
Mask.setGrid(curGrid)
ca.Copy(Mask, MaskOrig)
else:
resampler.downsampleImage(Mask, MaskOrig)
# initialize / upsample deformation
if scaleManager.isFirstScale():
u.setGrid(curGrid)
ca.SetMem(u, 0.0)
else:
resampler.updateVField(u)
# set grids
gI.setGrid(curGrid)
Idef.setGrid(curGrid)
diff.setGrid(curGrid)
gU.setGrid(curGrid)
scratchI.setGrid(curGrid)
scratchV.setGrid(curGrid)
def SaveSliceStack(fname, imList, sliceIdx=None, dim='z'):
nIm = len(imList)
imSz = imList[0].size()
sz = imSz.tolist()
mType = imList[0].memType()
volSz = core.Vec3Di(imSz)
volSz.set(DIMMAP[dim], nIm)
volGrid = core.GridInfo(volSz)
vol = core.Image3D(volGrid, mType)
start = core.Vec3Di(0, 0, 0)
for imIdx in range(nIm):
# if this volume is not a slice already, extract a slice
im = imList[imIdx]
if sz[DIMMAP[dim]] > 1:
im = ExtractSliceArrIm(im, sliceIdx, dim)
start.set(DIMMAP[dim], imIdx)
core.SetSubVol_I(vol, im, start)
core._ITKFileIO.SaveImage(vol, fname)
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))
def MatchingIteration(p):
# compute gradient for matching
(grad_m, VEnergy, IEnergy) = MatchingGradient(p)
if p.optMethod == 'FIXEDGD':
# take fixed stepsize gradient step
ca.Add_MulC_I(p.m0, grad_m, -p.stepSize)
else:
raise Exception("Unknown optimization scheme: " + p.optMethod)
# end if
return (VEnergy, IEnergy)
def _CopyImDataFromNPArr(imOut, arrIn):
arr3d = np.atleast_3d(arrIn)
imSz = core.Vec3Di()
imSz.fromlist(arr3d.shape)
if imSz != imOut.size():
raise Exception('imOut and arrIn must have compatible sizes: ' +
str(imSz) + ' != ' + str(imOut.size()))
origType = imOut.memType()
imOut.toType(core.MEM_HOST)
imOut.asnp()[:, :, :] = arr3d
imOut.toType(origType)
def ExtractSliceVF(vf, sliceIdx=None, dim='z'):
"""
Given a Field3D 'vf', extract the given slice along the given dimension.
If sliceIdx is None, extract the middle slice.
"""
sz = vf.size().tolist()
# take mid slice if none specified
if sliceIdx is None:
sliceIdx = sz[DIMMAP[dim]] // 2
roiStart = core.Vec3Di(0, 0, 0)
roiSize = core.Vec3Di(sz[0], sz[1], sz[2])
roiStart.set(DIMMAP[dim], sliceIdx)
roiSize.set(DIMMAP[dim], 1)
roiGrid = core.GridInfo(vf.grid().size(),
vf.grid().spacing(),
vf.grid().origin())
roiGrid.setSize(roiSize)
sliceVF = core.Field3D(roiGrid, vf.memType())
core.SubVol(sliceVF, vf, roiStart)
return sliceVF
def FieldFromNPArr(arr,
mType=core.MEM_HOST,
sp=core.Vec3Df(1.0, 1.0, 1.0),
orig=core.Vec3Df(0.0, 0.0, 0.0)):
"""
Expects X-by-Y-by-Z-by-3 or X-by-Y-by-2 array
"""
arrx, arry, arrz = _ComponentArraysFromField(arr)
fSz = core.Vec3Di()
fSz.fromlist(arrx.shape)
grid = core.GridInfo(fSz, sp, orig)
f = core.Field3D(grid, core.MEM_HOST)
(fArrX, fArrY, fArrZ) = f.asnp()
fArrX[:, :, :] = arrx
fArrY[:, :, :] = arry
fArrZ[:, :, :] = arrz
f.toType(mType)
return f
def crop_im(volume =None, x=0, x2=0, y=0, y2=0, z=0, z2=0, plot =True, sliceInd = None):
'''crops an image3D by the specified dimensions'''
#TODO put in check for grid smaller or equal to the new grid.
vg = volume.grid()
np_ia = common.AsNPCopy(volume)
# print 'grid',volume.grid()
# print 'space',volume.spacing()
# print 'orign',volume.origin()
# print 'size',volume.size()
if (z == 0 and z2 == 0):
np_ic = np_ia[x:x2,y:y2,:]
np_ic = common.ImFromNPArr(np_ic, ca.MEM_DEVICE)
np_ic.setGrid(
ca.gridInfo(ca.Vec3Di(x2-x,y2-y,z2-z),
volume.grid().origin(),
volume.grid().spacing()))
else:
# print np_ia.shape
np_ic = np_ia[x:x2, y:y2, z:z2]
# print np_ic.shape
np_ic = common.ImFromNPArr(np_ic, ca.MEM_DEVICE)
# print "npic im", np_ic
# print "vol.spacing", volume.grid().spacing()
# print "vol.origin", volume.grid().origin()
np_ic.setGrid(ca.GridInfo(
ca.Vec3Di(x2-x,y2-y,z2-z),
volume.grid().spacing(),
ca.Vec3Df(x,y,z) ))
# volume.grid().origin()))
if plot:
plt.figure('Plot')
plt.subplot(1,3,1)
display.DispImage(np_ic, sliceIdx = None, dim = 'x', newFig = False)
plt.hold(True)
plt.subplot(1,3,2)
display.DispImage(np_ic, sliceIdx = None, dim = 'y', newFig = False)
plt.subplot(1,3,3)
display.DispImage(np_ic, sliceIdx = None, dim = 'z', newFig = False)
plt.show(block=True)
return np_ic
