def makestate(im, pos, rad, slab=None, mem_level='hi'):
"""
Workhorse for creating & optimizing states with an initial centroid
guess.
This is an example function that works for a particular microscope. For
your own microscope, you'll need to change particulars such as the psf
type and the orders of the background and illumination.
Parameters
----------
im : :class:`~peri.util.RawImage`
A RawImage of the data.
pos : [N,3] element numpy.ndarray.
The initial guess for the N particle positions.
rad : N element numpy.ndarray.
The initial guess for the N particle radii.
slab : :class:`peri.comp.objs.Slab` or None, optional
If not None, a slab corresponding to that in the image. Default
is None.
mem_level : {'lo', 'med-lo', 'med', 'med-hi', 'hi'}, optional
A valid memory level for the state to control the memory overhead
at the expense of accuracy. Default is `'hi'`
Returns
-------
:class:`~peri.states.ImageState`
An ImageState with a linked z-scale, a ConfocalImageModel, and
all the necessary components with orders at which are useful for
my particular test case.
"""
if slab is not None:
o = comp.ComponentCollection(
[
objs.PlatonicSpheresCollection(pos, rad, zscale=zscale),
slab
],
category='obj'
)
else:
o = objs.PlatonicSpheresCollection(pos, rad, zscale=zscale)
p = exactpsf.FixedSSChebLinePSF()
npts, iorder = _calc_ilm_order(im.get_image().shape)
i = ilms.BarnesStreakLegPoly2P1D(npts=npts, zorder=iorder)
b = ilms.LegendrePoly2P1D(order=(9 ,3, 5), category='bkg')
c = comp.GlobalScalar('offset', 0.0)
s = states.ImageState(im, [o, i, b, c, p])
runner.link_zscale(s)
if mem_level != 'hi':
s.set_mem_level(mem_level)
opt.do_levmarq(s, ['ilm-scale'], max_iter=1, run_length=6, max_mem=1e4)
return s
def make_image_1():
P = objs.PlatonicSpheresCollection(pos, rad)
H = psfs.AnisotropicGaussian()
I = ilms.LegendrePoly3D(order=(5, 3, 3), constval=1.0)
B = ilms.Polynomial3D(order=(3, 1, 1), category='bkg', constval=0.01)
C = GlobalScalar('offset', 0.0)
return states.ImageState(im, [B, I, H, P, C], pad=16, model_as_data=True)
def make_image_0():
P = objs.PlatonicSpheresCollection(pos, rad)
H = psfs.AnisotropicGaussian()
I = ilms.BarnesStreakLegPoly2P1D(npts=(20, 10), local_updates=True)
B = GlobalScalar('bkg', 0.0)
C = GlobalScalar('offset', 0.0)
I.randomize_parameters()
return states.ImageState(im, [B, I, H, P, C], pad=16, model_as_data=True)
def create_state(image, pos, rad, slab=None, sigma=0.05, conf=conf_simple):
"""
Create a state from a blank image, set of pos and radii
Parameters:
-----------
image : `peri.util.Image` object
raw confocal image with which to compare.
pos : initial conditions for positions (in raw image coordinates)
rad : initial conditions for radii array (can be scalar)
sigma : float, noise level
slab : float
z-position of the microscope slide in the image (pixel units)
"""
# we accept radius as a scalar, so check if we need to expand it
if not hasattr(rad, '__iter__'):
rad = rad * np.ones(pos.shape[0])
model = models.models[conf.get('model')]()
# setup the components based on the configuration
components = []
for k, v in conf.get('comps', {}).iteritems():
args = conf.get('args').get(k, {})
comp = model.registry[k][v](**args)
components.append(comp)
sphs = objs.PlatonicSpheresCollection(pos, rad)
if slab is not None:
sphs = ComponentCollection([sphs, objs.Slab(zpos=slab + pad)],
category='obj')
components.append(sphs)
s = states.ImageState(image, components, sigma=sigma)
if isinstance(image, util.NullImage):
s.model_to_data()
return s
def create_img():
"""Creates an image, as a `peri.util.Image`, which is similar
to the image in the tutorial"""
# 1. particles + coverslip
rad = 0.5 * np.random.randn(POS.shape[0]) + 4.5 # 4.5 +- 0.5 px particles
part = objs.PlatonicSpheresCollection(POS, rad, zscale=0.89)
slab = objs.Slab(zpos=4.92, angles=(-4.7e-3, -7.3e-4))
objects = comp.ComponentCollection([part, slab], category='obj')
# 2. psf, ilm
p = exactpsf.FixedSSChebLinePSF(kfki=1.07, zslab=-29.3, alpha=1.17,
n2n1=0.98, sigkf=-0.33, zscale=0.89, laser_wavelength=0.45)
i = ilms.BarnesStreakLegPoly2P1D(npts=(16,10,8,4), zorder=8)
b = ilms.LegendrePoly2P1D(order=(7,2,2), category='bkg')
off = comp.GlobalScalar(name='offset', value=-2.11)
mdl = models.ConfocalImageModel()
st = states.ImageState(util.NullImage(shape=[48,64,64]),
[objects, p, i, b, off], mdl=mdl, model_as_data=True)
b.update(b.params, BKGVALS)
i.update(i.params, ILMVALS)
im = st.model + np.random.randn(*st.model.shape) * 0.03
return util.Image(im)
imFile = '/Volumes/PhD/expDesign/test/balls.tif'
blank_im = util.RawImage(imFile)
particle_positions=np.load('part_loc_davidImage.npy')
# particle_positions
n=100
# random_particles = np.c_[np.random.random(n), np.random.random(n),np.zeros(n)]*200.0
tile = util.Tile(200)
small_im = util.RawImage(imFile, tile=tile)
zpixel=1
xpixel=1
zscale=zpixel/xpixel
particle_radii = 8.0
particles = objs.PlatonicSpheresCollection(particle_positions, particle_radii, zscale=zscale)
objects = comp.comp.ComponentCollection([particles], category='obj')
background = comp.ilms.LegendrePoly2P1D(order=(4,2,2), category='bkg')
illumination = comp.ilms.BarnesStreakLegPoly2P1D(npts=(4, 2, 2))
offset = comp.GlobalScalar(name='offset', value=0.)
point_spread_function = comp.exactpsf.ChebyshevLineScanConfocalPSF(pxsize=xpixel)
model = models.ConfocalDyedParticlesModel()
st = states.ImageState(small_im, [objects, illumination, background, point_spread_function], mdl=model)
st.update('zscale', zscale)
savefile = "/Volumes/PhD/expDesign/test/"+datetime.now().strftime("%Y%m%d-%H%M%S") + "_unoptimized"
runner.link_zscale(st)
runner.optimize_from_initial(st)
savefile = "/Volumes/PhD/expDesign/test/"+datetime.now().strftime("%Y%m%d-%H%M%S") + "_inital_optimized"
from peri import states, util, models
from peri.comp import psfs, objs, ilms, GlobalScalar, ComponentCollection
from peri.test import nbody
import peri.opt.optimize as opt
import peri.opt.addsubtract as addsub
im = util.NullImage(shape=(32, ) * 3)
pos, rad, tile = nbody.create_configuration(3, im.tile)
P = ComponentCollection(
[objs.PlatonicSpheresCollection(pos, rad),
objs.Slab(2)], category='obj')
H = psfs.AnisotropicGaussian()
I = ilms.BarnesStreakLegPoly2P1D(npts=(25, 13, 3),
zorder=2,
local_updates=False)
B = ilms.LegendrePoly2P1D(order=(3, 1, 1), category='bkg', constval=0.01)
C = GlobalScalar('offset', 0.0)
I.randomize_parameters()
s = states.ImageState(im, [B, I, H, P, C], pad=16, model_as_data=True)
i.update(i.params, ILMVALS)
im = st.model + np.random.randn(*st.model.shape) * 0.03
return util.Image(im)
def print_info(i): print('~'*10 + '\t{}\t'.format(i)+ '~'*10)
if __name__ == '__main__':
im = create_img()
print_info('Creating Components')
coverslip = objs.Slab(zpos=6)
positions_guess = scramble_positions(POS) # a deliberately bad guess
particle_radii = 5.0 # a good guess for the particle radii, in pixels
particles = objs.PlatonicSpheresCollection(positions_guess, particle_radii)
objects = comp.ComponentCollection([particles, coverslip], category='obj')
illumination = ilms.BarnesStreakLegPoly2P1D(npts=(16, 10, 8, 4), zorder=8)
background = ilms.LegendrePoly2P1D(order=(7,2,2), category='bkg')
offset = comp.GlobalScalar(name='offset', value=0.)
point_spread_function = exactpsf.FixedSSChebLinePSF()
print_info('Creating Initial State')
model = models.ConfocalImageModel()
st = states.ImageState(im, [objects, illumination, background,
point_spread_function, offset], mdl=model)
print_info('Linking zscale ')
runner.link_zscale(st)
