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