def get(fixed=None, visualize=False, order=2, moving=None):
"""
get point SSD similarity
"""
# data
qf = fixed[0]
N = qf.shape[0]
DIM = qf.shape[1]
## visualization
reggrid = None
if visualize:
plt.figure(0)
plt.clf()
plt.plot(qf[:, 0], qf[:, 1], "bo")
if moving: # moving points needed in order to find grid size
qm = moving[0]
reggrid = pg.getGrid(
np.vstack((qf, qm))[:, 0].min() - 1,
np.vstack((qf, qm))[:, 0].max() + 1,
np.vstack((qf, qm))[:, 1].min() - 1,
np.vstack((qf, qm))[:, 1].max() + 1,
xpts=10,
ypts=10,
)
pg.plotGrid(*reggrid)
f = partial(psim, fixed=fixed, N=N, DIM=DIM, visualize=visualize, order=order, grid=reggrid)
sim = {"f": f, "N": N, "DIM": DIM}
return sim
def get(fixed=None, visualize=False, moving=None):
"""
get point SSD similarity
"""
# data
qf = fixed[0]
N = qf.shape[0]
DIM = qf.shape[1]
## visualization
reggrid = None
if visualize:
if moving: # moving points needed in order to find grid size
qm = moving[0]
reggrid = pg.getGrid(np.vstack((qf,qm))[:,0].min()-1,np.vstack((qf,qm))[:,0].max()+1,np.vstack((qf,qm))[:,1].min()-1,np.vstack((qf,qm))[:,1].max()+1,xpts=40,ypts=40)
#pg.plotGrid(*reggrid,coloring=True)
f = partial(psim, fixed=fixed, moving=moving, N=N, DIM=DIM, visualize=visualize, grid=reggrid)
sim = {'f': f, 'N': N, 'DIM': DIM}
return sim
def get(pointsPerAxis, immname, imfname, immT=None, visualize=False, border=0, normalize=False, order=2, smoothscaleFactor=0.5, SIGMAF=2., h=None, splineS=None, visRes=25j):
"""
get image similarity measure
"""
logging.info("Image sim parameters: visualize %s, border %d, normalize %s, order %d, smoothscaleFactor %g, sigmaF %g, splineS %s, visRes %s",visualize,border,normalize,order,smoothscaleFactor,SIGMAF,splineS,visRes)
# load
imm = np.double(np.load(immname))
imf = np.double(np.load(imfname))
imshape = imf.shape
Nx = np.shape(imm)[0]-2*border
Ny = np.shape(imm)[1]-2*border
assert Nx == Ny
assert Nx > 0
N = Nx*Ny
Ns = pointsPerAxis**2 # sample points
relsmoothscale = smoothscaleFactor/sqrt(Ns)
if not h:
h = sqrt(N)/sqrt(Ns) # length scale h, dist h between particles
logging.info("h: " + str(h))
smoothscale = relsmoothscale*sqrt(N)
logging.info("smoothscale: " + str(smoothscale))
SIGMA = SIGMAF*sqrt(N)/sqrt(Ns)
logging.info("SIGMA: " + str(SIGMA))
# smooth
imms = smooth(imm, smoothscale)
imfs = smooth(imf, smoothscale)
# normalize
if normalize:
imms = imms-np.min(imms)
if np.max(imms) > 1e-5:
imms = imms/np.max(imms)
imfs = imfs-np.min(imfs)
if np.max(imfs) > 1e-5:
imfs = imfs/np.max(imfs)
# grid
indent = Nx/(2*sqrt(Ns))
sgrid = np.mgrid[border+indent:border+Nx-indent:complex(0,sqrt(Ns)),border+indent:border+Ny-indent:complex(0,sqrt(Ns))]
sgridxy = (sgrid[0,:,0], sgrid[0,0,:])
# plot
if visualize:
# plotting setup
mpl.rcParams['image.interpolation'] = 'nearest'
mpl.rcParams['image.origin'] = 'lower'
# splot befine spline interpolation
plt.figure(0)
plt.imshow(imfs.T)
plt.figure(1)
plt.imshow(imms.T)
#plt.show(block=True)
# spline
imfs = splineIM(imfs, splineS=splineS)
imms = splineIM(imms, T=immT, splineS=splineS)
# original images for visualization
imf = splineIM(imf, kind='cubic', splineS=splineS)
imm = splineIM(imm, T=immT, kind='cubic', splineS=splineS)
# downsample
samplesgrid = partial(sample,sgrid, hscaling=h*sqrt(Ns)/sqrt(N))
simfs = samplesgrid(imfs)
#sDimfs = [apply_2d_slices(samplesgrid, Dimfs[i]) for i in range(np.shape(Dimfs)[0])]
sDimfs = [apply_2d_slices(partial(samplesgrid, imfs), derivs[i]) for i in range(len(derivs))]
f = partial(imsim, N=Ns, imshape=imshape, DIM=2, h=h, imms=imms, simfs=simfs, sDimfs=sDimfs, hscaling=h*sqrt(Ns)/sqrt(N), SIGMA=SIGMA, order=order)
## visualization
reggrid = None
if visualize:
plt.figure(1)
reggrid = pg.getGrid(border,border+Nx,border,border+Ny,xpts=40,ypts=40)
pg.plotGrid(*reggrid)
# attach grids
f = partial(f, sgrid=sgrid, grid=reggrid)
# image grid for warping
pointsPerAxis = complex(0,visRes)
imborder = 0 # -15
imgrid = d2zip(np.mgrid[border+imborder:border+Nx-imborder:pointsPerAxis,border+imborder:border+Ny-imborder:pointsPerAxis])
f = partial(f, imgrid=imgrid, imf=imf, imm=imm, imfs=imfs)
plt.figure(0)
plt.clf()
x = np.arange(imshape[0])
y = np.arange(imshape[1])
scimfs = samplecross((x,y),imfs).reshape(imshape)
cmin = np.min([np.min(simfs),np.min(scimfs)])
cmax = np.max([np.max(simfs),np.max(scimfs)])
plt.imshow(scimfs.T,vmin=cmin,vmax=cmax)
plt.gray()
plt.colorbar()
q = d2zip(sgrid)
plt.plot(q[:,0],q[:,1],'bo')
plt.xlim(0,imshape[0])
plt.ylim(0,imshape[1])
# Jacobians
DIM = 2
N = q.shape[0]
q_1 = np.outer(np.ones(N),np.eye(DIM)).reshape([N,DIM,DIM])
plotJacobians(q,q_1)
plt.figure(11)
plt.clf()
x = np.arange(imshape[0])
y = np.arange(imshape[1])
scimms = samplecross((x,y),imms).reshape(imshape)
plt.imshow(scimms.T)
plt.gray()
plt.colorbar()
plt.plot(d2zip(sgrid)[:,0],d2zip(sgrid)[:,1],'bo')
plt.xlim(0,imshape[0])
plt.ylim(0,imshape[1])
plt.figure(12)
plt.clf()
scDimms = samplecross((x,y),imms,(1,0),hscaling=h*sqrt(Ns)/sqrt(N)).reshape(imshape)
plt.imshow(scDimms.T)
plt.gray()
plt.colorbar()
plt.figure(13)
plt.clf()
scDimms = samplecross((x,y),imms,(2,0),hscaling=h*sqrt(Ns)/sqrt(N)).reshape(imshape)
plt.imshow(scDimms.T)
plt.gray()
plt.colorbar()
sim = {'f': f, 'N': Ns, 'SIGMA': SIGMA, 'DIM': 2, 'order': order, 'initial': (d2zip(sgrid),)}
return sim
# default
q_1 = np.outer(np.ones(N),np.eye(DIM)).reshape([N,DIM,DIM])
q_2 = np.zeros([N,DIM,DIM,DIM])
#tj.test_functions(0)
state0 = tj.weinstein_darboux_to_state(q, q_1, q_2, p, mu_1, mu_2 )
(t_span, y_span) = tj.integrate(state0, T=1.)
print 'initial energy was \n' + str(tj.energy(y_span[0]))
print 'final energy is \n' + str(tj.energy(y_span[-1]))
# plot
save = True
xlim = (-2.5,2.5)
ylim = (-2.5,2.5)
reggrid = pg.getGrid(xlim[0],xlim[1],ylim[0],ylim[1],xpts=40,ypts=40)
(ggrid,gNx,gNy) = reggrid
(_,_,mgridts) = tj.integrate(state0,pts=ggrid)
mgridT = mgridts[-1:].reshape(-1,DIM)
#plt.figure(1)
#pg.plotGrid(*reggrid)
#pg.axis('equal')
plt.figure(2)
pg.plotGrid(mgridT,gNx,gNy,coloring=True)
plt.plot(y_span[:,0:DIM*N:2],y_span[:,1:DIM*N:2],'r-',linewidth=2)
plt.plot(q[:,0],q[:,1],'bo',markersize=10,markeredgewidth=3)
plt.plot(y_span[-1,0:DIM*N:2],y_span[-1,1:DIM*N:2],'rx',markersize=10,markeredgewidth=3)
plt.axis('equal')
plt.xlim(xlim)
