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 predict_each_datapart(args, net, network_config, input_batch, datapart_idx, batch_size, patch_size, predict_transform_space): moving_image = torch.load(args.moving_image_dataset[datapart_idx]) target_image = torch.load(args.target_image_dataset[datapart_idx]) optimization_momentum = torch.load(args.deformation_parameter[datapart_idx]) for slice_idx in range(0, moving_image.size()[0]): print(slice_idx) moving_slice = moving_image[slice_idx].numpy() target_slice = target_image[slice_idx].numpy() if predict_transform_space: moving_slice = util.convert_to_registration_space(moving_slice) target_slice = util.convert_to_registration_space(target_slice) predicted_momentum = util.predict_momentum(moving_slice, target_slice, input_batch, batch_size, patch_size, net, predict_transform_space); m0_reg = common.FieldFromNPArr(predicted_momentum['image_space'], ca.MEM_DEVICE); moving_image_ca = common.ImFromNPArr(moving_slice, ca.MEM_DEVICE) target_image_ca = common.ImFromNPArr(target_slice, ca.MEM_DEVICE) registration_result = registration_methods.geodesic_shooting(moving_image_ca, target_image_ca, m0_reg, args.shoot_steps, ca.MEM_DEVICE, network_config) target_inv = common.AsNPCopy(registration_result['I1_inv']) print(target_inv.shape) if predict_transform_space: target_inv = util.convert_to_predict_space(target_inv) print(target_inv.shape) target_inv = torch.from_numpy(target_inv) target_image[slice_idx] = target_inv optimization_momentum[slice_idx] = optimization_momentum[slice_idx] - torch.from_numpy(predicted_momentum['prediction_space']) torch.save(target_image, args.warped_back_target_output[datapart_idx]) torch.save(optimization_momentum, args.momentum_residual[datapart_idx])
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 gather_file(args): if args.momentum: file = common.AsNPCopy(common.LoadITKField(args.files[0], ca.MEM_HOST)) else: #file = common.AsNPCopy(common.LoadITKImage(args.files[0], ca.MEM_HOST)) file = nib.load(args.files[0]).get_data() all_size = (len(args.files), ) + (15, 15, 15, 1, 3) #file.shape; data = torch.zeros(all_size) for i in range(0, len(args.files)): if args.momentum: cur_slice = torch.from_numpy( common.AsNPCopy(common.LoadITKField(args.files[i], ca.MEM_HOST))) else: cur_slice = nib.load(args.files[i]).get_data() if cur_slice.size == 3375: cur_slice = np.zeros([15, 15, 15, 1, 3]) cur_slice = torch.from_numpy(cur_slice) data[i] = cur_slice if args.momentum: # transpose the dataset to fit the training format data = data.numpy() data = np.transpose(data, [0, 4, 1, 2, 3]) data = torch.from_numpy(data) torch.save(data, args.output)
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 AtlasWriteOutput(cf, atlas, m_array, nodeSubjectsIds, isReporter): # save initial momenta for all individuals for itsub in range(len(nodeSubjectsIds)): common.SaveITKField( m_array[itsub], cf.io.outputPrefix + str(nodeSubjectsIds[itsub]).replace('.', '_') + "_m0.mhd") # save the atlas if isReporter: common.SaveITKImage(atlas, cf.io.outputPrefix + "atlas.mhd")
def GeoRegWriteOuput(subjectId, cf, p, t, Imsmts, cpinds, cpstates, msmtinds, gradAtMsmts, EnergyHistory): # save initial image and momenta for regression geodesic common.SaveITKImage(p.I0, cf.io.outputPrefix + subjectId + "I0.mhd") common.SaveITKField(p.m0, cf.io.outputPrefix + subjectId + "m0.mhd") # save residual images for regression geodesic # TODO: # write Energy details energyFilename = cf.io.outputPrefix + subjectId + "Energy.csv" with open(energyFilename, 'w') as f: csv_writer = csv.writer(f, delimiter='\t') csv_writer.writerows(EnergyHistory)
def MyQuiver(vf, sliceIdx=None, dim='z',every=1,thresh=None,scaleArrows=None,arrowCol='r',lineWidth=None, width=None): sliceArr = common.ExtractSliceArrVF(vf, sliceIdx, dim) if dim=='z': vy = np.squeeze(sliceArr[:,:,0]) vx = np.squeeze(sliceArr[:,:,1]) elif dim=='x': vy = np.squeeze(sliceArr[:,:,1]) vx = np.squeeze(sliceArr[:,:,2]) elif dim=='y': vy = np.squeeze(sliceArr[:,:,0]) vx = np.squeeze(sliceArr[:,:,2]) vxshow = np.zeros(np.shape(vx)) vyshow = np.zeros(np.shape(vy)) vxshow[::every,::every] = vx[::every,::every] vyshow[::every,::every] = vy[::every,::every] valindex = np.zeros(np.shape(vx),dtype=bool) valindex[::every,::every] = True if thresh is not None: valindex[(vx**2+vy**2)<thresh] = False #gridX, gridY = np.meshgrid(range(np.shape(vx)[0]),range(np.shape(vx)[1]-1,-1,-1)) gridX, gridY = np.meshgrid(range(np.shape(vx)[0]),range(np.shape(vx)[1])) quiverhandle = plt.quiver(gridX[valindex],gridY[valindex],vx[valindex],vy[valindex],scale=scaleArrows,color=arrowCol,linewidth=lineWidth,width=width,zorder=4) # change axes to match image axes plt.gca().invert_yaxis() # force redraw plt.draw()
def intensity_normalization_histeq(args): for i in range(0, len(args.input_images)): image = common.LoadITKImage(args.output_images[i], ca.MEM_HOST) grid = image.grid() image_np = common.AsNPCopy(image) nan_mask = np.isnan(image_np) image_np[nan_mask] = 0 image_np /= np.amax(image_np) # perform histogram equalization if needed if args.histeq: image_np[image_np != 0] = exposure.equalize_hist( image_np[image_np != 0]) image_result = common.ImFromNPArr(image_np, ca.MEM_HOST) image_result.setGrid(grid) common.SaveITKImage(image_result, args.output_images[i])
def randHSetUp(self): self.hRandH = \ common.RandField(self.sz, nSig=5.0, gSig=4.0, mType = MEM_HOST, sp = self.imSp) VtoH_I(self.hRandH) self.dRandH = self.hRandH.copy() self.dRandH.toType(MEM_DEVICE)
def GridPlot(vf, sliceIdx=None, dim='z', every=1, isVF=True, color='g', plotBase=True, colorbase='#A0A0FF'): sliceArr = np.squeeze(common.ExtractSliceArrVF(vf, sliceIdx, dim)) sz = sliceArr.shape hID = np.mgrid[0:sz[0], 0:sz[1]] d1 = np.squeeze(hID[1, ::every, ::every]) d2 = np.squeeze(hID[0, ::every, ::every]) sliceArr = sliceArr[::every, ::every, :] if plotBase: plt.plot(d1, d2, colorbase) plt.hold(True) plt.plot(d1.T, d2.T, colorbase) if not isVF: d1 = np.zeros(d1.shape) d2 = np.zeros(d2.shape) plt.plot(d1+np.squeeze(sliceArr[:,:,1]), d2+np.squeeze(sliceArr[:,:,0]), color) plt.hold(True) plt.plot((d1+np.squeeze(sliceArr[:,:,1])).T, (d2+np.squeeze(sliceArr[:,:,0])).T, color) plt.hold(False) # change axes to match image axes if not plt.gca().yaxis_inverted(): plt.gca().invert_yaxis() # force redraw plt.draw()
def randVPair(self): hV = common.RandField(self.sz, nSig=5.0, gSig=4.0, mType=MEM_HOST, sp=self.imSp) dV = hV.copy() dV.toType(MEM_DEVICE) return hV, dV
def randMaskSetUp(self): randArr = np.random.rand(self.sz[0], self.sz[1]) maskArr = np.zeros(randArr.shape) maskArr[randArr > 0.5] = 1.0 self.hRandMask = common.ImFromNPArr(maskArr, mType=MEM_HOST, sp=self.imSp) self.dRandMask = self.hRandMask.copy() self.dRandMask.toType(MEM_DEVICE)
def test_ResampleInterp(self, disp=False): # generate small integer-valued image initMax = 5 randArrSmall = (np.random.rand(10, 10) * initMax).astype(int) randImSmall = common.ImFromNPArr(randArrSmall) imLarge = Image3D(50, 50, 1) Resample(imLarge, randImSmall, BACKGROUND_STRATEGY_CLAMP, INTERP_NN) nUnique = len(np.unique(imLarge.asnp())) self.assertEqual(nUnique, initMax)
def Quiver(vf, sliceIdx=None, dim='z'): sliceArr = common.ExtractSliceArrVF(vf, sliceIdx, dim) plt.quiver(np.squeeze(sliceArr[:,:,0]).T, np.squeeze(sliceArr[:,:,1]).T, scale=None) # change axes to match image axes if not plt.gca().yaxis_inverted(): plt.gca().invert_yaxis() # force redraw plt.draw()
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 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 Loader(cfOb, memT): '''Function for loading all of the images. All images get normalized between 0 and 1''' #Load Source Images bfiSrc = cc.LoadColorMHA( pth.expanduser(secOb.bfiSrcPath + cfOb.bfiSrcName), memT) ssiSrc = common.LoadITKImage( pth.expanduser(secOb.ssiSrcPath + cfOb.ssiSrcName), memT) ssiSrc /= ca.Max(ssiSrc) #Load Mask Image bfiMsk = common.LoadITKImage( pth.expanduser(secOb.bfiMskPath + cfOb.bfiMskName), memT) bfiMsk /= ca.Max(bfiMsk) bfiMsk.setGrid(bfiSrc.grid()) ssiMsk = common.LoadITKImage( pth.expanduser(secOb.ssiMskPath + cfOb.ssiMskName), memT) ssiMsk /= ca.Max(ssiMsk) return ssiSrc, bfiSrc, ssiMsk, bfiMsk
def preprocess_image(image_pyca, histeq): image_np = common.AsNPCopy(image_pyca) nan_mask = np.isnan(image_np) image_np[nan_mask] = 0 image_np /= np.amax(image_np) # perform histogram equalization if needed if histeq: image_np[image_np != 0] = exposure.equalize_hist(image_np[image_np != 0]) return image_np
def HGMWriteOutput(cf, groupState, tDiscGroup, isReporter): # save initial momenta for residual geodesics, p, for all individuals for i in range(len(groupState.t)): if tDiscGroup[i].J is not None: common.SaveITKField( tDiscGroup[i].p0, cf.io.outputPrefix + str(tDiscGroup[i].subjectId).replace('.', '_') + "_p0.mhd") # write individual's energy history energyFilename = cf.io.outputPrefix + str( tDiscGroup[i].subjectId).replace('.', '_') + "ResidualEnergy.csv" HGMWriteEnergyHistoryToFile(tDiscGroup[i].Energy, energyFilename) # save initial image and momenta for group gedoesic if isReporter: common.SaveITKImage(groupState.I0, cf.io.outputPrefix + "I0.mhd") common.SaveITKField(groupState.m0, cf.io.outputPrefix + "m0.mhd") # write energy history energyFilename = cf.io.outputPrefix + "TotalEnergyHistory.csv" HGMWriteEnergyHistoryToFile(groupState.EnergyHistory, energyFilename)
def Load(spec, argv): """Load YAML file, validate it, given spec (inserting defaults) and convert to attributes """ if len(argv) < 2: print('# Usage: ' + argv[0] + ' <config.yaml>') print('# Below is a sample config YAML file') print(SpecToYAML(spec)) print('# PyCA Version: %s (%s)' % (common.PyCAVersion(), common.PyCABranch())) if '_resource' in spec: # this won't be printed by default, but let's keep track print("_resource: " + spec['_resource']) raise MissingConfigError() d = LoadYAMLDict(argv[1]) # TODO: process overrides (given on the cmdline as key=value pairs) return MkConfig(d, spec)
def test_AddMasked(self, disp=False): SetMem(self.hIm, 0.0) SetMem(self.dIm, 0.0) hIm2 = common.RandImage(self.sz, nSig=1.0, gSig=0.0, mType=MEM_HOST, sp=self.imSp) dIm2 = hIm2.copy() dIm2.toType(MEM_DEVICE) Add(self.hIm, self.hRandIm, hIm2, self.hRandMask) Add(self.dIm, self.dRandIm, dIm2, self.dRandMask) self.TestIm(self.hIm, self.dIm, name='AddMasked', disp=disp)
def JacDetPlot(vf, title='Jac. Det.', jd_max=10.0, cmap='PRGn', nonpos_clr=(1.0, 0.0, 0.0, 1.0), sliceIdx=None, dim='z', isVF=True, newFig=False): """ Plot the jacobian determinant using logmapped colors, and setting zero or negative values to 'nonpos_clr'. jd_max is the maximum value to display without clamping, and also defines the min value as 1.0/jd_max to assure 1.0 is centered in the colormap. If vf is a vector field, compute the jacobian determinant. If it is an Image3D, assume it is the jacobian determinant to be plotted. """ if common.IsField3D(vf): grid = vf.grid() mType = vf.memType() h = core.ManagedField3D(grid, mType) jacdet = core.ManagedImage3D(grid, mType) core.Copy(h, vf) if isVF: core.VtoH_I(h) core.JacDetH(jacdet, h) elif common.IsImage3D(vf): jacdet = vf else: raise Exception('unknown input type to JacDetPlot, %s'%\ str(type(vf))) jd_cmap = JacDetCMap(jd_max=jd_max, cmap=cmap, nonpos_clr=nonpos_clr) DispImage(jacdet, title=title, sliceIdx=sliceIdx, dim=dim, rng=[1.0/jd_max, jd_max], cmap=jd_cmap, log=True, newFig=newFig)
def MatchingImageMomentaWriteOuput(cf, geodesicState, EnergyHistory, m0, n1): grid = geodesicState.J0.grid() mType = geodesicState.J0.memType() # save momenta for the gedoesic common.SaveITKField(geodesicState.p0, cf.io.outputPrefix + "p0.mhd") # save matched momenta for the geodesic if cf.vectormomentum.matchImOnly: m0 = common.LoadITKField(cf.study.m, mType) ca.CoAd(geodesicState.p, geodesicState.rhoinv, m0) common.SaveITKField(geodesicState.p, cf.io.outputPrefix + "m1.mhd") # momenta match energy if cf.vectormomentum.matchImOnly: vecdiff = ca.ManagedField3D(grid, mType) ca.Sub_I(geodesicState.p, n1) ca.Copy(vecdiff, geodesicState.p) geodesicState.diffOp.applyInverseOperator(geodesicState.p) momentaMatchEnergy = ca.Dot(vecdiff, geodesicState.p) / ( float(geodesicState.p0.nVox()) * geodesicState.SigmaSlope * geodesicState.SigmaSlope) # save energy energyFilename = cf.io.outputPrefix + "testMomentaMatchEnergy.csv" with open(energyFilename, 'w') as f: print >> f, momentaMatchEnergy # save matched image for the geodesic tempim = ca.ManagedImage3D(grid, mType) ca.ApplyH(tempim, geodesicState.J0, geodesicState.rhoinv) common.SaveITKImage(tempim, cf.io.outputPrefix + "I1.mhd") # save energy energyFilename = cf.io.outputPrefix + "energy.csv" MatchingImageMomentaWriteEnergyHistoryToFile(EnergyHistory, energyFilename)
def SaveSlice(fname, im, sliceIdx=None, dim='z', cmap='gray', rng=None, t=True): sliceIm = common.ExtractSliceIm(im, sliceIdx, dim) sliceIm.toType(core.MEM_HOST) if rng is None: vmin = None vmax = None else: vmin = rng[0] vmax = rng[1] if t: plt.imsave(fname, np.squeeze(sliceIm.asnp()).T, cmap=cmap, vmin=vmin, vmax=vmax) else: plt.imsave(fname, np.squeeze(sliceIm.asnp()), cmap=cmap, vmin=vmin, vmax=vmax)
def __init__(self, methodName='runTest'): super(CpuGpuTestCase, self).__init__(methodName) self.cudaEnabled = (GetNumberOfCUDADevices() > 0) if self.cudaEnabled: # allowable average abs. diff self.AvEps = 1e-6 # allowable max abs. diff self.MaxEps = 1e-4 # image size self.sz = np.array([127, 119]) # spacing self.sp = np.array([1.5, 2.1]) # fluid parameters self.fluidParams = [1.0, 1.0, 0.0] self.vsz = np.append(self.sz, 2) self.imSz = Vec3Di(int(self.sz[0]), int(self.sz[1]), 1) self.imSp = Vec3Df(float(self.sp[0]), float(self.sp[1]), 1.0) # set up grid self.grid = GridInfo(self.imSz, self.imSp) # set up host / device images self.I0Arr = common.DrawEllipse(self.sz, self.sz / 2, self.sz[0] / 4, self.sz[1] / 3) self.I1Arr = common.DrawEllipse(self.sz, self.sz / 2, self.sz[0] / 3, self.sz[1] / 4) self.I0Arr = common.GaussianBlur(self.I0Arr, 1.5) self.I1Arr = common.GaussianBlur(self.I1Arr, 1.5) self.hI0Orig = common.ImFromNPArr(self.I0Arr, mType=MEM_HOST, sp=self.imSp) self.hI1Orig = common.ImFromNPArr(self.I1Arr, mType=MEM_HOST, sp=self.imSp) self.dI0Orig = common.ImFromNPArr(self.I0Arr, mType=MEM_DEVICE, sp=self.imSp) self.dI1Orig = common.ImFromNPArr(self.I1Arr, mType=MEM_DEVICE, sp=self.imSp)
def DefSeriesIter(I, V, t, func, args): grid = I.grid() mType = I.memType() tlen = len(t) h = core.Field3D(grid, mType) IDef = core.Image3D(grid, mType) core.SetToIdentity(h) scratchV1 = core.Field3D(grid, mType) scratchV2 = core.Field3D(grid, mType) rtnarr = [] for tidx in range(tlen): curt = t[tidx] h = common.ComposeDef(V, curt, inverse=True, asVField=False, scratchV1=scratchV1, scratchV2=scratchV2) core.ApplyH(IDef, I, h) r = func(IDef, curt, *args) rtnarr.append(r) return rtnarr
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")
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))