def _call(self, X): """ Shooting equations and Integration Args: X = [I0, p] with I0 template image and p scalarvalued momentum Returns: I: deformed Image over time (N+1 timesteps) M: vectorvalued momentum in eulerian coordinates over time V: vectorfields over time """ template = X[0] P0 = X[1] series_image_space_integration = ProductSpace(template.space, self.N + 1) series_vector_space_integration = ProductSpace( template.space.tangent_bundle, self.N + 1) inv_N = 1 / self.N I = series_image_space_integration.element() I[0] = template.copy() P = series_image_space_integration.element() P[0] = P0.copy() U = series_vector_space_integration.element() # Create the gradient op grad_op = Gradient(domain=self.space, method='forward', pad_mode='symmetric') # Create the divergence op div_op = -grad_op.adjoint for i in range(self.N): # compute vectorvalued momentum from scalarvalued momentum gradI = grad_op(I[i]) m = self.space.tangent_bundle.element(-P[i] * gradI) # Kernel convolution to obtain velocity fields from momentum # u = K*m U[i] = (2 * np.pi)**( self.dim / 2.0) * self.vectorial_ft_fit_op.inverse( self.vectorial_ft_fit_op(m) * self.ft_kernel_fitting) # Integration step dtI = -sum(gradI * U[i]) dtP = -div_op(P[i] * U[i]) I[i + 1] = I[i] + inv_N * dtI P[i + 1] = P[i] + inv_N * dtP U[self.N] = (2 * np.pi)**( self.dim / 2.0) * self.vectorial_ft_fit_op.inverse( self.vectorial_ft_fit_op( self.space.tangent_bundle.element(-P[self.N] * gradI)) * self.ft_kernel_fitting) return I, P, U
def fitting_kernel(space, kernel): kspace = ProductSpace(space, self.dim) # Create the array of kernel values on the grid points discretized_kernel = kspace.element( [space.element(kernel) for _ in range(self.dim)]) return discretized_kernel
def IntegrateTemplateEvol(template,zeta,k0,k1): N=len(zeta)-1 inv_N=1/N series_image_space_integration = ProductSpace(template.space,N+1) I=series_image_space_integration.element() I[0]=template.copy() for i in range(k0,k1): I[i+1]=I[i]+ inv_N * zeta[i] return I
def ShootTemplateFromVectorFields(vector_field_list, template): N=len(vector_field_list)-1 inv_N=1/N series_image_space_integration = ProductSpace(template.space,N+1) I=series_image_space_integration.element() I[0]=template.copy() for i in range(0,N): I[i+1]=template.space.element( linear_deform(I[i], -inv_N * vector_field_list[i])).copy() return I
def ShootSourceTermBackwardlist(vector_field_list, zeta): N=len(vector_field_list)-1 inv_N=1/N series_image_space_integration = ProductSpace(zeta[0].space,N+1) zeta_transp=series_image_space_integration.element() space_zeta=zeta[0].space for i in range(0,N+1): temp=zeta[i].copy() for j in range(i): temp=space_zeta.element( linear_deform(temp, inv_N * vector_field_list[i-1-j])).copy() zeta_transp[i]=temp.copy() return zeta_transp
def _vectorized_kernel(space, kernel): """Compute the vectorized discrete kernel ``K``. Parameters ---------- space : the space used to define kernel ``K``. kernel : the used kernel function for data fitting term. Returns ------- discretized_kernel : `ProductSpaceElement` The vectorized discrete kernel with the space dimension """ kspace = ProductSpace(space, space.ndim) # Create the array of kernel values on the grid points discretized_kernel = kspace.element( [space.element(kernel) for _ in range(space.ndim)]) return discretized_kernel
def LDDMM_Beg_solver(template, reference, time_pts, niter, eps, lamb, kernel, callback=None): """ Solver for the shape-based reconstruction using LDDMM_Beg. Notes ----- The model is: .. math:: \min_{v(t) \in V, \phi_{0,1}^v \in G_v} \lambda \int_0^1 \|v(t)\|_V^2 dt + \int_\Omega |(\phi_{0,1}^v.I_0) - I_1|^2 dx Here :math:`I_0` is the template. :math:`v(t)` is the velocity vector. :math:`V` is a reproducing kernel Hilbert space for the velocity vector. :math:`I_1` is the reference. :math:`\lambda` is the regularization parameter. :math:`\phi_{0, 1}^v.I := I \circ \phi_{1, 0}^v` is for geometric deformation, :math:`\phi_{1, 0}^v` is the inverse of :math:`\phi_{0, 1}^v` i.e. the solution at :math:`t=1` of flow of diffeomorphisms. :math:`|D\phi_{1, 0}^v|` is the Jacobian determinant of :math:`\phi_{1, 0}^v`. Parameters ---------- template : `DiscreteLpElement` Fixed template. reference: `DiscreteLpElement` Fixed reference. time_pts : `int` The number of time intervals niter : `int` The given maximum iteration number. eps : `float` The given step size. lamb : `float` The given regularization parameter. It's a weighted value on the regularization-term side. kernel : `function` Kernel function in reproducing kernel Hilbert space. callback : `class`, optional Show the intermediate results of iteration. Returns ------- image_N0 : `ProductSpaceElement` The series of images produced by template and velocity field. E : `numpy.array` Storage of the energy values for iterations. """ # Give the number of time intervals N = time_pts # Get the inverse of time intervals inv_N = 1.0 / N # Create the space of images image_space = template.space #image_space= rec_space # Get the dimension of the space of images dim = image_space.ndim # Fourier transform setting for data matching term # The padded_size is the size of the padded domain padded_size = 2 * image_space.shape[0] # Create operator of Fourier transform composing with padded operator pad_ft_op = _padded_ft_op(image_space, padded_size) # Create vectorial Fourier transform operator # Construct the diagnal element of a matrix operator vectorial_ft_op = DiagonalOperator(*([pad_ft_op] * dim)) # Compute the FT of kernel in fitting term discretized_kernel = _vectorized_kernel(image_space, kernel) ft_kernel_fitting = vectorial_ft_op(discretized_kernel) # Create the space for series deformations and series Jacobian determinant pspace = image_space.tangent_bundle series_pspace = ProductSpace(pspace, N + 1) series_image_space = ProductSpace(image_space, N + 1) # Initialize vector fileds at different time points vector_fields = series_pspace.zero() # Give the initial two series deformations and series Jacobian determinant image_N0 = series_image_space.element() image_N1 = series_image_space.element() detDphi_N1 = series_image_space.element() for i in range(N + 1): image_N0[i] = image_space.element(template) image_N1[i] = image_space.element(reference) detDphi_N1[i] = image_space.one() # Create the gradient operator grad_op = Gradient(domain=image_space, method='forward', pad_mode='symmetric') # Create the divergence operator, which can be obtained from # the adjoint of gradient operator # div_op = Divergence(domain=pspace, method='forward', pad_mode='symmetric') div_op = -grad_op.adjoint # Store energy E = [] kE = len(E) E = np.hstack((E, np.zeros(niter))) # Begin iteration for k in range(niter): # Update the velocity field for i in range(N + 1): #first term term1_tmp1 = 2 * np.abs(image_N0[i] - image_N1[i]) * (detDphi_N1[i]) term1_tmp = grad_op(image_N0[i]) for j in range(dim): term1_tmp[j] *= term1_tmp1 tmp3 = (2 * np.pi)**(dim / 2.0) * vectorial_ft_op.inverse( vectorial_ft_op(term1_tmp) * ft_kernel_fitting) vector_fields[i] = (vector_fields[i] - eps * (lamb * vector_fields[i] - tmp3)) # Update image_N0,image_N1 and detDphi_N0 detDphi_N1 for i in range(N): # Update image_N0[i+1] by image_N0[i] and vector_fields[i+1] image_N0[i + 1] = image_space.element( _linear_deform(image_N0[i], -inv_N * vector_fields[i + 1])) # Update image_N1[N-i-1] by image_N1[N-i] and vector_fields[N-i-1] image_N1[N - i - 1] = image_space.element( _linear_deform(image_N1[N - i], inv_N * vector_fields[N - i - 1])) # # Update detDphi_N1[N-i-1] by detDphi_N1[N-i] # jacobian_det = image_domain.element( # np.exp(inv_N * div_o p(vector_fields[N-i-1]))) jacobian_det = image_space.element( 1.0 + inv_N * div_op(vector_fields[N - i - 1])) detDphi_N1[N - i - 1] = (jacobian_det * image_space.element( _linear_deform(detDphi_N1[N - i], inv_N * vector_fields[N - i - 1]))) # Update the deformed template PhiStarI = image_N0[N] # Show intermediate result if callback is not None: callback(PhiStarI) # Compute the energy of the data fitting term E[k + kE] += np.asarray((PhiStarI - reference)**2).sum() return image_N0, E
def ufunc_class_factory(name, nargin, nargout, docstring): """Create a Ufunc `Operator` from a given specification.""" assert 0 <= nargin <= 2 def __init__(self, space): """Initialize an instance. Parameters ---------- space : `TensorSpace` The domain of the operator. """ if not isinstance(space, LinearSpace): raise TypeError('`space` {!r} not a `LinearSpace`'.format(space)) if nargin == 1: domain = space0 = space dtypes = [space.dtype] elif nargin == len(space) == 2 and isinstance(space, ProductSpace): domain = space space0 = space[0] dtypes = [space[0].dtype, space[1].dtype] else: domain = ProductSpace(space, nargin) space0 = space dtypes = [space.dtype, space.dtype] dts_out = dtypes_out(name, dtypes) if nargout == 1: range = space0.astype(dts_out[0]) else: range = ProductSpace(space0.astype(dts_out[0]), space0.astype(dts_out[1])) linear = name in LINEAR_UFUNCS Operator.__init__(self, domain=domain, range=range, linear=linear) def _call(self, x, out=None): """Return ``self(x)``.""" # TODO: use `__array_ufunc__` when implemented on `ProductSpace`, # or try both if out is None: if nargin == 1: return getattr(x.ufuncs, name)() else: return getattr(x[0].ufuncs, name)(*x[1:]) else: if nargin == 1: return getattr(x.ufuncs, name)(out=out) else: return getattr(x[0].ufuncs, name)(*x[1:], out=out) def __repr__(self): """Return ``repr(self)``.""" return '{}({!r})'.format(name, self.domain) # Create example (also functions as doctest) if 'shift' in name or 'bitwise' in name or name == 'invert': dtype = int else: dtype = float space = tensor_space(3, dtype=dtype) if nargin == 1: vec = space.element([-1, 1, 2]) arg = '{}'.format(vec) with np.errstate(all='ignore'): result = getattr(vec.ufuncs, name)() else: vec = space.element([-1, 1, 2]) vec2 = space.element([3, 4, 5]) arg = '[{}, {}]'.format(vec, vec2) with np.errstate(all='ignore'): result = getattr(vec.ufuncs, name)(vec2) if nargout == 2: result_space = ProductSpace(vec.space, 2) result = repr(result_space.element(result)) examples_docstring = RAW_EXAMPLES_DOCSTRING.format(space=space, name=name, arg=arg, result=result) full_docstring = docstring + examples_docstring attributes = { "__init__": __init__, "_call": _call, "derivative": derivative_factory(name), "__repr__": __repr__, "__doc__": full_docstring } full_name = name + '_op' return type(full_name, (Operator, ), attributes)
def _call(self, X): """ Shooting equations and Integration Args: X = [I0, m] with I0 template image and m vectorvalued momentum Returns: I: deformed Image over time (N+1 timesteps) M: vectorvalued momentum in eulerian coordinates over time V: vectorfields over time """ template = X[0].copy() m0 = X[1].copy() # create spaces for time-dependent Image and vectorfields series_image_space_integration = ProductSpace(template.space, self.N + 1) series_vector_space_integration = ProductSpace(m0.space, self.N + 1) inv_N = 1 / self.N I = series_image_space_integration.element() I[0] = template.copy() M = series_vector_space_integration.element() M[0] = m0.copy() U = series_vector_space_integration.element() # Create the gradient op grad_op = Gradient(domain=self.space, method='forward', pad_mode='symmetric') # Create the divergence op div_op = -grad_op.adjoint for i in range(self.N): m = M[i] # Kernel convolution to obtain vectorfields from momentum # v = K*m U[i] = (2 * np.pi)**( self.dim / 2.0) * self.vectorial_ft_fit_op.inverse( self.vectorial_ft_fit_op(m) * self.ft_kernel_fitting) u = U[i] # shooting equation # d/dt m = - ad*_v m gradu = [grad_op(u[0]), grad_op(u[1])] dtM0 = sum(grad_op(m[0]) * u) + sum( [gradu[i][0] * m[i] for i in range(self.dim)]) + div_op(u) * m[0] dtM1 = sum(grad_op(m[1]) * u) + sum( [gradu[i][1] * m[i] for i in range(self.dim)]) + div_op(u) * m[1] # Integration step M[i + 1] = M[i] - inv_N * m0.space.element([dtM0, dtM1]) I[i + 1] = odl.deform.linear_deform(I[i], -inv_N * u) U[self.N] = (2 * np.pi)**( self.dim / 2.0) * self.vectorial_ft_fit_op.inverse( self.vectorial_ft_fit_op(M[self.N]) * self.ft_kernel_fitting) return I, M, U
def LDDMM_gradient_descent_solver_spatiotemporal(forward_op, noise_proj_data, template, vector_fields, gate_pts, discr_deg, niter, in_niter1, in_inter2, stepsize1, stepsize2, mu_1, mu_2, lamb, kernel, impl1='geom', impl2='least_square', callback=None): """ Solver for spatiotemporal image reconstruction using LDDMM. Notes ----- The model is: .. math:: \min_{v} \lambda * \int_0^1 \|v(t)\|_V^2 dt + \|T(\phi_1.I) - g\|_2^2, where :math:`\phi_1.I := |D\phi_1^{-1}| I(\phi_1^{-1})` is for mass-preserving deformation, instead, :math:`\phi_1.I := I(\phi_1^{-1})` is for geometric deformation. :math:`\phi_1^{-1}` is the inverse of the solution at :math:`t=1` of flow of doffeomorphisms. :math:`|D\phi_1^{-1}|` is the Jacobian determinant of :math:`\phi_1^{-1}`. :math:`T` is the forward operator. If :math:`T` is an identity operator, the above model reduces to image matching. If :math:`T` is a non-identity forward operator, the above model is for shape-based image reconstrction. :math:`g` is the detected data, `data_elem`. :math:`I` is the `template`. :math:`v(t)` is the velocity vector. :math:`V` is a reproducing kernel Hilbert space for velocity vector. :math:`lamb` is the regularization parameter. Parameters ---------- forward_op : `Operator` The forward operator of imaging. data_elem : `DiscreteLpElement` The given data. template : `DiscreteLpElement` Fixed template deformed by the deformation. time_pts : `int` The number of time intervals iter : `int` The given maximum iteration number. eps : `float` The given step size. lamb : `float` The given regularization parameter. It's a weighted value on the regularization-term side. kernel : `function` Kernel function in reproducing kernel Hilbert space. impl1 : {'geom', 'mp'}, optional The given implementation method for group action. The impl1 chooses 'mp' or 'geom', where 'mp' means using mass-preserving method, and 'geom' means using non-mass-preserving geometric method. Its defalt choice is 'geom'. impl2 : {'least square'}, optional The given implementation method for data matching term. Here the implementation only supports the case of least square. callback : `class`, optional Show the intermediate results of iteration. Returns ------- image_N0 : `ProductSpaceElement` The series of images produced by template and velocity field. mp_deformed_image_N0 : `ProductSpaceElement` The series of mass-preserving images produced by template and velocity field. E : `numpy.array` Storage of the energy values for iterations. """ # Max index of discretized points N = gate_pts # Discretized degree M = discr_deg # Compute the max index of discretized points MN = M * N MN1 = MN + 1 # Get the inverse of the number of discretized points inv_MN = 1.0 / MN N1 = N + 1 N2 = 2. / N ss1 = stepsize1 * N2 ss2 = stepsize2 * N2 ss3 = stepsize1 * mu_1 # Create the gradient operator for the squared L2 functional if impl2 == 'least_square': gradS = [forward_op[0].adjoint * (forward_op[0] - noise_proj_data[0])] * N1 for i in range(N): j = i + 1 gradS[j] = forward_op[j].adjoint * (forward_op[j] - noise_proj_data[j]) else: raise NotImplementedError('now only support least square') # Create the space of images image_space = template.space # Get the dimension of the space of images dim = image_space.ndim # Fourier transform setting for data matching term # The padded_size is the size of the padded domain padded_size = 2 * image_space.shape[0] # The pad_ft_op is the operator of Fourier transform # composing with padded operator pad_ft_op = padded_ft_op(image_space, padded_size) # The vectorial_ft_op is a vectorial Fourier transform operator, # which constructs the diagnal element of a matrix. vectorial_ft_op = DiagonalOperator(*([pad_ft_op] * dim)) # Compute the FT of kernel in fitting term discretized_kernel = fitting_kernel(image_space, kernel) ft_kernel_fitting = vectorial_ft_op(discretized_kernel) # Create the space for series deformations and series Jacobian determinant series_image_space = ProductSpace(image_space, MN1) series_backprojection_space = ProductSpace(image_space, N1) series_bp_all = [image_space.element()] * N1 for i in range(N): j = i + 1 series_bp_all[j] = [image_space.element()] * (j * M + 1) # Initialize vector fileds at different time points vector_fields = vector_fields # Initialize two series deformations and series Jacobian determinant image_MN0 = series_image_space.element() if impl1 == 'geom': eta_tt = series_backprojection_space.element() else: raise NotImplementedError('unknown group action') for j in range(MN1): image_MN0[j] = image_space.element(template) eta_tt[0] = gradS[0](image_MN0[0]) series_bp_all[0] = eta_tt[0] for i in range(1, N1): iM = i * M eta_tt[i] = gradS[i](image_MN0[iM]) for j in range(iM + 1): series_bp_all[i][j] = eta_tt[i] # Create the gradient operator grad_op = Gradient(domain=image_space, method='forward', pad_mode='symmetric') # Create the divergence operator, which can be obtained from # the adjoint of gradient operator # div_op = Divergence(domain=pspace, method='forward', pad_mode='symmetric') grad_op_adjoint = grad_op.adjoint div_op = -grad_op.adjoint # Begin iteration for non-mass-preserving case if impl1 == 'geom': print(impl1) # Outer iteration for k in range(niter): print('iter = {!r}'.format(k)) #%%%Setting for getting a proper initial template # Inner iteration for updating template if k == 0: niter1 = 50 # niter1 = in_niter1 else: niter1 = in_niter1 #%%%Solving TV-L2 by Gradient Descent # Store energy E = [] E = np.hstack((E, np.zeros(niter1))) for k1 in range(niter1): image_MN0[0] = template # Update partial of template grad_template = grad_op(template) grad_template_norm = np.sqrt(grad_template[0]**2 + grad_template[1]**2 + 1.0e-12) E[k1] += mu_1 * np.asarray( grad_template_norm).sum() * template.space.cell_volume for i in range(1, N1): E[k1] += 1. / N * np.asarray((forward_op[i](image_MN0[i*M]) - noise_proj_data[i])**2).sum() \ * noise_proj_data[0].space.cell_volume template = template - \ ss3 * grad_op_adjoint(grad_template/grad_template_norm) for j in range(MN): temp1 = j + 1 # Update image_MN0 image_MN0[temp1] = image_space.element( _linear_deform(image_MN0[j], -inv_MN * vector_fields[temp1])) if temp1 % M == 0: temp2 = temp1 // M # print(temp1) # print(temp2) # Update eta_tt eta_tt[temp2] = gradS[temp2](image_MN0[temp1]) # eta_tt[temp2].show('eta_tt[{!r}]'.format(temp2)) series_bp_all[temp2][temp1] = eta_tt[temp2] # the above two lines can be combined into one # series_bp_all[temp2][temp1] = gradS[temp2](image_MN0[temp1]) for l in range(temp1): jacobian_det = image_space.element( 1.0 + inv_MN * div_op(vector_fields[temp1 - l - 1])) # Update eta_tau_tnp series_bp_all[temp2][temp1-l-1] = \ jacobian_det * image_space.element( _linear_deform( series_bp_all[temp2][temp1-l], inv_MN * vector_fields[temp1-l-1])) # Update partial of template template = template - \ ss1 * series_bp_all[temp2][0] for k2 in range(in_inter2): image_MN0[0] = template series_bp_all[0] = gradS[0](image_MN0[0]) for j in range(MN): temp1 = j + 1 # Update image_MN0 image_MN0[temp1] = image_space.element( _linear_deform(image_MN0[j], -inv_MN * vector_fields[temp1])) if temp1 % M == 0: temp2 = temp1 // M # Update eta_tt eta_tt[temp2] = gradS[temp2](image_MN0[temp1]) series_bp_all[temp2][temp1] = eta_tt[temp2] for l in range(temp1): jacobian_det = image_space.element( 1.0 + inv_MN * div_op(vector_fields[temp1 - l - 1])) # Update eta_tau_t series_bp_all[temp2][temp1-l-1] = \ jacobian_det * image_space.element( _linear_deform( series_bp_all[temp2][temp1-l], inv_MN * vector_fields[temp1-l-1])) for j in range(MN1): tmp1 = grad_op(image_MN0[j]) tmp2 = int(np.ceil(j * 1. / M)) tmp0 = tmp2 + 1 # print(tmp2) if tmp2 == 0: tmp3 = image_space.zero() tmp4 = image_space.tangent_bundle.zero() else: tmp3 = series_bp_all[tmp2][j] tmp4 = vector_fields[j] for i in range(tmp0, N1): tmp3 = tmp3 + series_bp_all[i][j] tmp4 = tmp4 + vector_fields[j] for i in range(dim): tmp1[i] *= tmp3 tmp5 = (2 * np.pi)**(dim / 2.0) * vectorial_ft_op.inverse( vectorial_ft_op(tmp1) * ft_kernel_fitting) # Update vector_fields vector_fields[j] = vector_fields[j] + ss2 * (tmp5 - mu_2 * tmp4) return template, vector_fields, image_MN0 else: raise NotImplementedError('unknown group action')