def restart(self, EpsilonNet=None, DiffeonEpsForNet=None, DiffeonSegmentationRatio=None, DecimationTarget=None):
if EpsilonNet==None:
if DecimationTarget==None:
if DiffeonEpsForNet==None:
if DiffeonSegmentationRatio==None:
c0 = np.copy(self.x0) ;
S0 = np.zeros([self.x0.shape[0], self.x0.shape[1], self.x0.shape[1]])
#net = range(c0.shape[0])
idx = range(c0.shape[0])
else:
(c0, S0, idx) = gd.generateDiffeonsFromSegmentation(self.fv0, DiffeonSegmentationRatio)
#self.S0 *= self.param.sigmaKernel**2;
else:
(c0, S0, idx) = gd.generateDiffeonsFromNet(self.fv0, DiffeonEpsForNet)
else:
(c0, S0, idx) = gd.generateDiffeonsFromDecimation(self.fv0, DecimationTarget)
else:
net = EspilonNet[2]
(c0, S0, idx) = gd.generateDiffeons(self.fv0, EpsilonNet[0], EpsilonNet[1])
(ctPrev, StPrev, ct, St) = evol.gaussianDiffeonsEvolutionEuler(self.c0, self.S0, self.at, self.param.sigmaKernel, withDiffeonSet=(c0, S0))
at = np.zeros([self.Tsize, c0.shape[0], self.x0.shape[1]])
#fvDef = surfaces.Surface(surf=self.fvDef)
for t in range(self.Tsize):
g1 = gd.computeProducts(np.squeeze(ct[t,:,:]),np.squeeze(St[t,:,:]), self.param.sigmaKernel)
g2 = gd.computeProductsAsym(np.squeeze(ct[t,:,:]),np.squeeze(St[t,:,:]), np.squeeze(ctPrev[t,:,:]),np.squeeze(StPrev[t,:,:]), self.param.sigmaKernel)
g2a = np.dot(g2, np.squeeze(self.at[t, :, :]))
at[t, :, :] = LA.solve(g1, g2a)
g0 = gd.computeProducts(np.squeeze(ctPrev[t,:,:]),np.squeeze(StPrev[t,:,:]), self.param.sigmaKernel)
n0 = np.multiply(self.at[t, :, :], np.dot(g0, self.at[t, :, :])).sum()
n1 = np.multiply(at[t, :, :], np.dot(g1, at[t, :, :])).sum()
print 'norms: ', n0, n1
# fvDef.updateVertices(np.squeeze(self.xt[t, :, :]))
# (AV, AF) = fvDef.computeVertexArea()
# weights = np.zeros([c0.shape[0], self.c0.shape[0]])
# diffArea = np.zeros(self.c0.shape[0])
# diffArea2 = np.zeros(c0.shape[0])
# for k in range(self.npt):
# diffArea[self.idx[k]] += AV[k]
# diffArea2[idx[k]] += AV[k]
# weights[idx[k], self.idx[k]] += AV[k]
# weights /= diffArea.reshape([1, self.c0.shape[0]])
# at[t] = np.dot(weights, self.at[t, :, :])
self.c0 = c0
self.idx = idx
self.S0 = S0
self.at = at
self.ndf = self.c0.shape[0]
self.ct = np.tile(self.c0, [self.Tsize+1, 1, 1])
self.St = np.tile(self.S0, [self.Tsize+1, 1, 1, 1])
if self.dcurr:
self.b0 = gd.approximateSurfaceCurrent(self.c0, self.S0, self.fv0, self.param.KparDist.sigma)
#print self.b0.shape
self.bt = np.tile(self.b0, [self.Tsize+1, 1, 1])
self.obj = None
self.objTry = None
self.gradCoeff = self.ndf
self.optimizeMatching()
def objectiveFunDef(self, at, Afft, withTrajectory = False, withJacobian=False, initial = None):
if initial == None:
x0 = self.x0
c0 = self.c0
S0 = self.S0
if self.dcurr:
b0 = self.b0
xS0 = self.xS0
else:
x0 = self.x0
if self.dcurr:
(c0, S0, b0, xS0) = initial
else:
(c0, S0) = initial
param = self.param
timeStep = 1.0/self.Tsize
dim2 = self.dim**2
A = [np.zeros([self.Tsize, self.dim, self.dim]), np.zeros([self.Tsize, self.dim])]
if self.affineDim > 0:
for t in range(self.Tsize):
AB = np.dot(self.affineBasis, Afft[t])
A[0][t] = AB[0:dim2].reshape([self.dim, self.dim])
A[1][t] = AB[dim2:dim2+self.dim]
if withJacobian:
if self.dcurr:
(ct, St, bt, xt, xSt, Jt) = evol.gaussianDiffeonsEvolutionEuler(c0, S0, at, param.sigmaKernel, affine=A, withJacobian=True, withNormals=b0, withDiffeonSet=(x0, xS0))
else:
(ct, St, xt, Jt) = evol.gaussianDiffeonsEvolutionEuler(c0, S0, at, param.sigmaKernel, affine=A, withPointSet = x0, withJacobian=True)
else:
if self.dcurr:
(ct, St, bt, xt, xSt) = evol.gaussianDiffeonsEvolutionEuler(c0, S0, at, param.sigmaKernel, affine=A, withNormals=b0, withDiffeonSet=(x0, xS0))
else:
(ct, St, xt) = evol.gaussianDiffeonsEvolutionEuler(c0, S0, at, param.sigmaKernel, affine=A, withPointSet = x0)
#print xt[-1, :, :]
#print obj
obj=0
#print St.shape
for t in range(self.Tsize):
c = np.squeeze(ct[t, :, :])
S = np.squeeze(St[t, :, :, :])
a = np.squeeze(at[t, :, :])
#rzz = kfun.kernelMatrix(param.KparDiff, z)
rcc = gd.computeProducts(c, S, param.sigmaKernel)
obj = obj + self.regweight*timeStep*np.multiply(a, np.dot(rcc,a)).sum()
if self.affineDim > 0:
obj += timeStep * np.multiply(self.affineWeight.reshape(Afft[t].shape), Afft[t]**2).sum()
#print xt.sum(), at.sum(), obj
if withJacobian:
if self.dcurr:
return obj, ct, St, bt, xt, xSt, Jt
else:
return obj, ct, St, xt, Jt
elif withTrajectory:
if self.dcurr:
return obj, ct, St, bt, xt, xSt
else:
return obj, ct, St, xt
else:
return obj
def dotProduct(self, g1, g2):
res = np.zeros(len(g2))
dim2 = self.dim**2
for t in range(self.Tsize):
c = np.squeeze(self.ct[t, :, :])
S = np.squeeze(self.St[t, :, :, :])
gg = np.squeeze(g1.diff[t, :, :])
rcc = gd.computeProducts(c, S, self.param.sigmaKernel)
(L, W) = LA.eigh(rcc)
rcc += (L.max()/1000)*np.eye(rcc.shape[0])
u = np.dot(rcc, gg)
uu = np.multiply(g1.aff[t], self.affineWeight.reshape(g1.aff[t].shape))
ll = 0
for gr in g2:
ggOld = np.squeeze(gr.diff[t, :, :])
res[ll] = res[ll] + np.multiply(ggOld,u).sum()
if self.affineDim > 0:
res[ll] += np.multiply(uu, gr.aff[t]).sum()
ll = ll + 1
return res