void hoSPIRITOperator<T>::compute_righ_hand_side(const ARRAY_TYPE& x, ARRAY_TYPE& b)
{
try
{
if (no_null_space_)
{
b.create(x.get_dimensions());
Gadgetron::clear(b);
}
else
{
// non-symmetric rhs: -(G-I)D'x
// need to be done for D'x, acquired points are already in place
// x to image domain
this->convert_to_image(x, complexIm_);
// apply kernel and sum
GADGET_CATCH_THROW(Gadgetron::multiply(forward_kernel_, complexIm_, res_after_apply_kernel_));
GADGET_CATCH_THROW(this->sum_over_src_channel(res_after_apply_kernel_, res_after_apply_kernel_sum_over_));
// go back to kspace
this->convert_to_kspace(res_after_apply_kernel_sum_over_, b);
// multiply by -1
Gadgetron::scal((typename realType<T>::Type)(-1.0), b);
}
}
catch (...)
{
GADGET_THROW("Errors in hoSPIRITOperator<T>::compute_righ_hand_side(...) ... ");
}
}
void apply_unmix_coeff_kspace(const hoNDArray<T>& kspace, const hoNDArray<T>& unmixCoeff, hoNDArray<T>& complexIm)
{
try
{
GADGET_CHECK_THROW(kspace.get_size(0) == unmixCoeff.get_size(0));
GADGET_CHECK_THROW(kspace.get_size(1) == unmixCoeff.get_size(1));
GADGET_CHECK_THROW(kspace.get_size(2) == unmixCoeff.get_size(2));
hoNDArray<T> buffer2DT(kspace);
GADGET_CATCH_THROW(Gadgetron::hoNDFFT<typename realType<T>::Type>::instance()->ifft2c(kspace, buffer2DT));
std::vector<size_t> dim;
kspace.get_dimensions(dim);
dim[2] = 1;
if (!complexIm.dimensions_equal(&dim))
{
complexIm.create(&dim);
}
Gadgetron::multiply(buffer2DT, unmixCoeff, buffer2DT);
Gadgetron::sum_over_dimension(buffer2DT, complexIm, 2);
}
catch (...)
{
GADGET_THROW("Errors in apply_unmix_coeff_kspace(const hoNDArray<T>& kspace, const hoNDArray<T>& unmixCoeff, hoNDArray<T>& complexIm) ... ");
}
}
void hoSPIRITOperator<T>::set_forward_kernel(ARRAY_TYPE& forward_kernel, bool compute_adjoint_forward_kernel)
{
try
{
std::vector<size_t> dim;
forward_kernel.get_dimensions(dim);
forward_kernel_.create(dim, forward_kernel.begin());
GADGET_CATCH_THROW(Gadgetron::spirit_image_domain_adjoint_kernel(forward_kernel_, adjoint_kernel_));
if (compute_adjoint_forward_kernel)
{
GADGET_CATCH_THROW(Gadgetron::spirit_adjoint_forward_kernel(adjoint_kernel_, forward_kernel_, adjoint_forward_kernel_));
}
// allocate the helper memory
std::vector<size_t> dims;
forward_kernel.get_dimensions(dims);
size_t NDim = dims.size();
std::vector<size_t> dimSrc(NDim - 1), dimDst(NDim - 1);
size_t ii;
for (ii = 0; ii < NDim - 2; ii++)
{
dimSrc[ii] = dims[ii];
dimDst[ii] = dims[ii];
}
dimSrc[NDim - 2] = dims[NDim - 2];
dimDst[NDim - 2] = dims[NDim - 1];
res_after_apply_kernel_.create(dims);
res_after_apply_kernel_sum_over_.create(dimDst);
kspace_dst_.create(dimDst);
}
catch (...)
{
GADGET_THROW("Errors in hoSPIRITOperator<T>::set_forward_kernel(...) ... ");
}
}
void grappa2d_calib_convolution_kernel(const hoNDArray<T>& dataSrc, const hoNDArray<T>& dataDst, hoNDArray<unsigned short>& dataMask, size_t accelFactor, double thres, size_t kRO, size_t kNE1, hoNDArray<T>& convKer)
{
try
{
bool fitItself = false;
if (&dataSrc != &dataDst) fitItself = true;
GADGET_CHECK_THROW(dataSrc.dimensions_equal(&dataMask));
GADGET_CHECK_THROW(dataDst.dimensions_equal(&dataMask));
// find the fully sampled region
size_t RO = dataMask.get_size(0);
size_t E1 = dataMask.get_size(1);
size_t srcCHA = dataSrc.get_size(2);
size_t dstCHA = dataDst.get_size(2);
size_t startRO(0), endRO(0), startE1(0), endE1(0);
size_t ro, e1, scha, dcha;
for (e1 = 0; e1 < E1; e1++)
{
for (ro = 0; ro < RO; ro++)
{
if (dataMask(ro, e1)>0)
{
if (ro < startRO) startRO = ro;
if (ro > endRO) endRO = ro;
if (e1 < startE1) startE1 = e1;
if (e1 > endE1) endE1 = e1;
}
}
}
GADGET_CHECK_THROW(endRO>startRO);
GADGET_CHECK_THROW(endE1>startE1 + accelFactor);
GADGET_CATCH_THROW(grappa2d_calib_convolution_kernel(dataSrc, dataDst, accelFactor, thres, kRO, kNE1, startRO, endRO, startE1, endE1, convKer));
}
catch (...)
{
GADGET_THROW("Errors in grappa2d_calib_convolution_kernel(dataMask) ... ");
}
}
void hoSPIRITOperator<T>::sum_over_src_channel(const ARRAY_TYPE& x, ARRAY_TYPE& r)
{
try
{
boost::shared_ptr< std::vector<size_t> > dim = x.get_dimensions();
size_t NDim = dim->size();
if (NDim < 2) return;
std::vector<size_t> dimR(NDim - 1);
std::vector<size_t> dimRInternal = *dim;
dimRInternal[NDim - 2] = 1;
size_t d;
for (d = 0; d<NDim - 2; d++)
{
dimR[d] = (*dim)[d];
}
dimR[NDim - 2] = (*dim)[NDim - 1];
if (!r.dimensions_equal(&dimR))
{
r.create(&dimR);
}
if (x.get_size(NDim - 2) <= 1)
{
memcpy(r.begin(), x.begin(), x.get_number_of_bytes());
return;
}
hoNDArray<T> rSum(dimRInternal, r.begin());
GADGET_CATCH_THROW(Gadgetron::sum_over_dimension(x, rSum, NDim - 2));
}
catch (...)
{
GADGET_THROW("Errors in hoSPIRITOperator<T>::sum_over_src_channel(const ARRAY_TYPE& x, ARRAY_TYPE& r) ... ");
}
}
