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(...) ... ");
}
}
typename hoSPIRITOperator<T>::REAL hoSPIRITOperator<T>::magnitude(ARRAY_TYPE* x)
{
try
{
if (no_null_space_)
{
// L2 norm of ||(G-I)x||2
this->convert_to_image(*x, complexIm_);
}
else
{
// L2 norm of ||(G-I)(D'y+Dc'x)||2
// D'y+Dc'x
Gadgetron::multiply(unacquired_points_indicator_, *x, kspace_);
Gadgetron::add(acquired_points_, kspace_, kspace_);
// x to image domain
this->convert_to_image(kspace_, complexIm_);
}
// apply kernel and sum
Gadgetron::multiply(forward_kernel_, complexIm_, res_after_apply_kernel_);
this->sum_over_src_channel(res_after_apply_kernel_, res_after_apply_kernel_sum_over_);
// L2 norm
T obj(0);
Gadgetron::dotc(res_after_apply_kernel_sum_over_, res_after_apply_kernel_sum_over_, obj);
return std::abs(obj);
}
catch (...)
{
GADGET_THROW("Errors in hoSPIRITOperator<T>::magnitude(...) ... ");
}
}
void apply_unmix_coeff_aliased_image(const hoNDArray<T>& aliasedIm, const hoNDArray<T>& unmixCoeff, hoNDArray<T>& complexIm)
{
try
{
GADGET_CHECK_THROW(aliasedIm.get_size(0) == unmixCoeff.get_size(0));
GADGET_CHECK_THROW(aliasedIm.get_size(1) == unmixCoeff.get_size(1));
GADGET_CHECK_THROW(aliasedIm.get_size(2) == unmixCoeff.get_size(2));
std::vector<size_t> dim;
aliasedIm.get_dimensions(dim);
dim[2] = 1;
if (!complexIm.dimensions_equal(&dim))
{
complexIm.create(&dim);
}
hoNDArray<T> buffer2DT(aliasedIm);
Gadgetron::multiply(aliasedIm, unmixCoeff, buffer2DT);
Gadgetron::sum_over_dimension(buffer2DT, complexIm, 2);
}
catch (...)
{
GADGET_THROW("Errors in apply_unmix_coeff_aliased_image(const hoNDArray<T>& aliasedIm, const hoNDArray<T>& unmixCoeff, hoNDArray<T>& complexIm) ... ");
}
}
void MultiChannelCartesianGrappaReconGadget::perform_coil_map_estimation(IsmrmrdReconBit& recon_bit, ReconObjType& recon_obj, size_t e)
{
try
{
recon_obj.coil_map_ = recon_obj.ref_coil_map_;
Gadgetron::clear(recon_obj.coil_map_);
size_t E2 = recon_obj.ref_coil_map_.get_size(2);
if (E2 > 1)
{
Gadgetron::hoNDFFT<float>::instance()->ifft3c(recon_obj.ref_coil_map_, complex_im_recon_buf_);
}
else
{
Gadgetron::hoNDFFT<float>::instance()->ifft2c(recon_obj.ref_coil_map_, complex_im_recon_buf_);
}
size_t ks = 7;
size_t kz = 5;
size_t power = 3;
Gadgetron::coil_map_Inati(complex_im_recon_buf_, recon_obj.coil_map_, ks, kz, power);
}
catch (...)
{
GADGET_THROW("Errors happened in MultiChannelCartesianGrappaReconGadget::perform_coil_map_estimation(...) ... ");
}
}
void grappa2d_calib_convolution_kernel(const hoNDArray<T>& acsSrc, const hoNDArray<T>& acsDst, size_t accelFactor, double thres, size_t kRO, size_t kNE1, size_t startRO, size_t endRO, size_t startE1, size_t endE1, hoNDArray<T>& convKer)
{
try
{
std::vector<int> kE1, oE1;
bool fitItself = false;
if (&acsSrc != &acsDst) fitItself = true;
size_t convkRO, convkE1;
grappa2d_kerPattern(kE1, oE1, convkRO, convkE1, accelFactor, kRO, kNE1, fitItself);
hoNDArray<T> ker;
grappa2d_calib(acsSrc, acsDst, thres, kRO, kE1, oE1, startRO, endRO, startE1, endE1, ker);
grappa2d_convert_to_convolution_kernel(ker, kRO, kE1, oE1, convKer);
}
catch (...)
{
GADGET_THROW("Errors in grappa2d_calib_convolution_kernel(...) ... ");
}
return;
}
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 correct_time_stamp_with_fitting(hoNDArray<float>& time_stamp, size_t startE1, size_t endE1)
{
try
{
size_t E1 = time_stamp.get_size(0);
size_t N = time_stamp.get_size(1);
size_t rE1 = endE1 - startE1 + 1;
size_t e1, n;
size_t num_acq_read_outs = 0;
for ( n=0; n<N; n++ )
{
for ( e1=0; e1<E1; e1++ )
{
if ( time_stamp(e1, n) > 0 )
{
num_acq_read_outs++;
}
}
}
GDEBUG_STREAM(" Number of acquired lines : " << num_acq_read_outs);
float a, b; // y = a + b*x
{
std::vector<float> x(num_acq_read_outs), y(num_acq_read_outs);
size_t ind = 0;
for ( n=0; n<N; n++ )
{
for ( e1=startE1; e1<=endE1; e1++ )
{
float acq_time = time_stamp(e1, n);
if ( acq_time > 0 )
{
x[ind] = (float)(e1-startE1 + n*rE1);
y[ind] = acq_time;
ind++;
}
}
}
Gadgetron::simple_line_fit(x, y, a, b);
}
for ( n=0; n<N; n++ )
{
for ( e1=startE1; e1<=endE1; e1++ )
{
float x_v = (float)(e1-startE1 + n*rE1);
time_stamp(e1, n) = a + b*x_v;
}
}
}
catch(...)
{
GADGET_THROW("Exceptions happened in correct_time_stamp_with_fitting(...) ... ");
}
}
void hoSPIRITOperator<T>::restore_acquired_kspace(const ARRAY_TYPE& acquired, ARRAY_TYPE& y)
{
try
{
GADGET_CHECK_THROW(acquired.get_number_of_elements() == y.get_number_of_elements());
size_t N = acquired.get_number_of_elements();
const T* pA = acquired.get_data_ptr();
T* pY = y.get_data_ptr();
int n(0);
#pragma omp parallel for default(none) private(n) shared(N, pA, pY)
for (n = 0; n<(int)N; n++)
{
if (std::abs(pA[n]) > 0)
{
pY[n] = pA[n];
}
}
}
catch (...)
{
GADGET_THROW("Errors happened in hoSPIRITOperator<T>::restore_acquired_kspace(...) ... ");
}
}
void grappa2d_image_domain_kernel(const hoNDArray<T>& convKer, size_t RO, size_t E1, hoNDArray<T>& kIm)
{
try
{
hoNDArray<T> convKerScaled(convKer);
Gadgetron::scal((typename realType<T>::Type)(std::sqrt((double)(RO*E1))), convKerScaled);
Gadgetron::pad(RO, E1, &convKerScaled, &kIm);
Gadgetron::hoNDFFT<typename realType<T>::Type>::instance()->ifft2c(kIm);
}
catch(...)
{
GADGET_THROW("Errors in grappa2d_image_domain_kernel(...) ... ");
}
return;
}
void hoSPIRITOperator<T>::gradient(ARRAY_TYPE* x, ARRAY_TYPE* g, bool accumulate)
{
try
{
if (accumulate)
{
kspace_ = *g;
}
if (no_null_space_)
{
// gradient of L2 norm is 2*Dc*(G-I)'(G-I)x
this->convert_to_image(*x, complexIm_);
}
else
{
// gradient of L2 norm is 2*Dc*(G-I)'(G-I)(D'y+Dc'x)
Gadgetron::multiply(unacquired_points_indicator_, *x, kspace_);
Gadgetron::add(acquired_points_, kspace_, kspace_);
// x to image domain
this->convert_to_image(kspace_, complexIm_);
}
// apply kernel and sum
Gadgetron::multiply(adjoint_forward_kernel_, complexIm_, res_after_apply_kernel_);
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_, *g);
// apply Dc
Gadgetron::multiply(unacquired_points_indicator_, *g, *g);
// multiply by 2
Gadgetron::scal((typename realType<T>::Type)(2.0), *g);
if (accumulate)
{
Gadgetron:add(kspace_, *g, *g);
}
}
catch (...)
{
GADGET_THROW("Errors in hoSPIRITOperator<T>::gradient(...) ... ");
}
}
void compute_phase_time_stamp(const hoNDArray<float>& time_stamp, const hoNDArray<float>& cpt_time_stamp, size_t startE1, size_t endE1,
hoNDArray<float>& phs_time_stamp, hoNDArray<float>& phs_cpt_time_stamp)
{
try
{
size_t E1 = time_stamp.get_size(0);
size_t N = time_stamp.get_size(1);
size_t rE1 = endE1 - startE1 + 1;
size_t e1, n;
for ( n=0; n<N; n++ )
{
// phase time stamp as the mean of all aquired lines
size_t num = 0;
float tt = 0.0f;
for ( e1=startE1; e1<=endE1; e1++ )
{
if(time_stamp(e1, n)>0)
{
tt += time_stamp(e1, n);
num++;
}
}
phs_time_stamp(n, 0) = tt/((num>0) ? num : 1);
//// phase cpt time as the median of all acquired lines
//std::vector<float> cpt_buf(rE1, 0);
//for ( e1=startE1; e1<=endE1; e1++ )
//{
// if(cpt_time_stamp(e1, n)>=0)
// cpt_buf[e1-startE1] = cpt_time_stamp(e1, n);
//}
//std::sort(cpt_buf.begin(), cpt_buf.end());
//phs_cpt_time_stamp(n, 0) = cpt_buf[E1/2-startE1];
// phase cpt time as the cpt time of center line
phs_cpt_time_stamp(n, 0) = cpt_time_stamp(E1/2, n);
}
}
catch(...)
{
GADGET_THROW("Exceptions happened in compute_phase_time_stamp(...) ... ");
}
}
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 simple_line_fit(const std::vector<T>& x, const std::vector<T>& y, T& a, T& b)
{
try
{
size_t num = x.size();
if(num<2)
{
a = 0;
b = 0;
return;
}
T sx(0), sy(0);
size_t n;
for (n=0; n<num; n++)
{
sx += x[n];
sy += y[n];
}
T mx = sx / (T)(num);
T syy = 0;
b = 0;
for (n=0; n<num; n++)
{
T v = (x[n] - mx);
syy += v*v;
b += v*y[n];
}
syy = (std::abs(syy) > 0 ? syy : boost::math::sign(syy)*FLT_EPSILON);
b /= syy;
a = (sy - sx*b) / (T)(num);
}
catch(...)
{
GADGET_THROW("Exceptions happened in simple_line_fit ... ");
}
}
void hoSPIRITOperator<T>::mult_M(ARRAY_TYPE* x, ARRAY_TYPE* y, bool accumulate)
{
try
{
if (accumulate)
{
kspace_dst_ = *y;
}
if(no_null_space_)
{
// (G-I)x
this->convert_to_image(*x, complexIm_);
}
else
{
// (G-I)Dc'x
Gadgetron::multiply(unacquired_points_indicator_, *x, *y);
// x to image domain
this->convert_to_image(*y, complexIm_);
}
// apply kernel and sum
Gadgetron::multiply(forward_kernel_, complexIm_, res_after_apply_kernel_);
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_, *y);
if(accumulate)
{
Gadgetron::add(kspace_dst_, *y, *y);
}
}
catch (...)
{
GADGET_THROW("Errors in hoSPIRITOperator<T>::mult_M(...) ... ");
}
}
void maxValue(const hoNDArray<T>& a, T& v)
{
typedef T ValueType;
try
{
const ValueType* pA = a.begin();
size_t n = a.get_number_of_elements();
v = pA[0];
size_t ii;
for (ii=1; ii<n; ii++)
{
if (pA[ii]>v) v = pA[ii];
}
}
catch(...)
{
GADGET_THROW("Errors in maxValue(const hoNDArray<T>& a, T& v) ... ");
}
}
void hoSPIRITOperator<T>::set_acquired_points(ARRAY_TYPE& kspace)
{
try
{
std::vector<size_t> dim;
kspace.get_dimensions(dim);
acquired_points_.create(dim, kspace.begin());
acquired_points_indicator_.create(kspace.get_dimensions());
Gadgetron::clear(acquired_points_indicator_);
unacquired_points_indicator_.create(kspace.get_dimensions());
Gadgetron::clear(unacquired_points_indicator_);
size_t N = kspace.get_number_of_elements();
long long ii(0);
#pragma omp parallel for default(shared) private(ii) shared(N, kspace)
for (ii = 0; ii<(long long)N; ii++)
{
if (std::abs(kspace(ii)) < DBL_EPSILON)
{
unacquired_points_indicator_(ii) = T(1.0);
}
else
{
acquired_points_indicator_(ii) = T(1.0);
}
}
// allocate the helper memory
kspace_.create(kspace.get_dimensions());
complexIm_.create(kspace.get_dimensions());
}
catch (...)
{
GADGET_THROW("Errors in hoSPIRITOperator<T>::set_acquired_points(...) ... ");
}
}
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 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) ... ");
}
}
void hoSPIRIT3DOperator<T>::convert_to_image(const ARRAY_TYPE& x, ARRAY_TYPE& im)
{
try
{
if (this->use_non_centered_fft_)
{
Gadgetron::hoNDFFT<typename realType<T>::Type>::instance()->ifft3(x, im);
}
else
{
if (!complexIm_.dimensions_equal(&x))
{
complexIm_.create(x.get_dimensions());
}
Gadgetron::hoNDFFT<typename realType<T>::Type>::instance()->ifft3c(x, im, complexIm_);
}
}
catch (...)
{
GADGET_THROW("Errors happened in hoSPIRIT3DOperator<T>::convert_to_image(...) ... ");
}
}
void hoSPIRIT3DOperator<T>::convert_to_kspace(const ARRAY_TYPE& im, ARRAY_TYPE& x)
{
try
{
if (this->use_non_centered_fft_)
{
Gadgetron::hoNDFFT<typename realType<T>::Type>::instance()->fft3(im, x);
}
else
{
if (!kspace_.dimensions_equal(&im))
{
kspace_.create(im.get_dimensions());
}
Gadgetron::hoNDFFT<typename realType<T>::Type>::instance()->fft3c(im, x, kspace_);
}
}
catch (...)
{
GADGET_THROW("Errors happened in hoSPIRIT3DOperator<T>::convert_to_kspace(...) ... ");
}
}
void hoSPIRITOperator<T>::mult_MH(ARRAY_TYPE* x, ARRAY_TYPE* y, bool accumulate)
{
try
{
// Dc(G-I)'x or if no_null_space_ == true, (G-I)'x
if(accumulate)
{
kspace_ = *y;
}
// x to image domain
this->convert_to_image(*x, complexIm_);
// apply kernel and sum
Gadgetron::multiply(adjoint_kernel_, complexIm_, res_after_apply_kernel_);
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_, *y);
if (!no_null_space_)
{
// apply Dc
Gadgetron::multiply(unacquired_points_indicator_, *y, *y);
}
if (accumulate)
{
Gadgetron::add(kspace_, *y, *y);
}
}
catch (...)
{
GADGET_THROW("Errors in hoSPIRITOperator<T>::mult_MH(...) ... ");
}
}
void GenericReconCartesianNonLinearSpirit2DTGadget::perform_unwrapping(IsmrmrdReconBit& recon_bit, ReconObjType& recon_obj, size_t e)
{
try
{
size_t RO = recon_bit.data_.data_.get_size(0);
size_t E1 = recon_bit.data_.data_.get_size(1);
size_t E2 = recon_bit.data_.data_.get_size(2);
size_t dstCHA = recon_bit.data_.data_.get_size(3);
size_t N = recon_bit.data_.data_.get_size(4);
size_t S = recon_bit.data_.data_.get_size(5);
size_t SLC = recon_bit.data_.data_.get_size(6);
hoNDArray< std::complex<float> >& src = recon_obj.ref_calib_;
size_t ref_RO = src.get_size(0);
size_t ref_E1 = src.get_size(1);
size_t ref_E2 = src.get_size(2);
size_t srcCHA = src.get_size(3);
size_t ref_N = src.get_size(4);
size_t ref_S = src.get_size(5);
size_t ref_SLC = src.get_size(6);
size_t convkRO = recon_obj.kernel_.get_size(0);
size_t convkE1 = recon_obj.kernel_.get_size(1);
size_t convkE2 = recon_obj.kernel_.get_size(2);
recon_obj.recon_res_.data_.create(RO, E1, E2, 1, N, S, SLC);
Gadgetron::clear(recon_obj.recon_res_.data_);
recon_obj.full_kspace_ = recon_bit.data_.data_;
Gadgetron::clear(recon_obj.full_kspace_);
std::stringstream os;
os << "encoding_" << e;
std::string suffix = os.str();
if (!debug_folder_full_path_.empty()) { gt_exporter_.export_array_complex(recon_bit.data_.data_, debug_folder_full_path_ + "data_src_" + suffix); }
// ------------------------------------------------------------------
// compute effective acceleration factor
// ------------------------------------------------------------------
float effective_acce_factor(1), snr_scaling_ratio(1);
this->compute_snr_scaling_factor(recon_bit, effective_acce_factor, snr_scaling_ratio);
if (effective_acce_factor > 1)
{
Gadgetron::scal(snr_scaling_ratio, recon_bit.data_.data_);
}
Gadgetron::GadgetronTimer timer(false);
// ------------------------------------------------------------------
// compute the reconstruction
// ------------------------------------------------------------------
if(this->acceFactorE1_[e]<=1 && this->acceFactorE2_[e]<=1)
{
recon_obj.full_kspace_ = recon_bit.data_.data_;
}
else
{
hoNDArray< std::complex<float> >& kspace = recon_bit.data_.data_;
hoNDArray< std::complex<float> >& res = recon_obj.full_kspace_;
hoNDArray< std::complex<float> >& ref = recon_obj.ref_calib_;
GDEBUG_CONDITION_STREAM(this->verbose.value(), "spirit_parallel_imaging_lamda : " << this->spirit_parallel_imaging_lamda.value());
GDEBUG_CONDITION_STREAM(this->verbose.value(), "spirit_image_reg_lamda : " << this->spirit_image_reg_lamda.value());
GDEBUG_CONDITION_STREAM(this->verbose.value(), "spirit_data_fidelity_lamda : " << this->spirit_data_fidelity_lamda.value());
GDEBUG_CONDITION_STREAM(this->verbose.value(), "spirit_nl_iter_max : " << this->spirit_nl_iter_max.value());
GDEBUG_CONDITION_STREAM(this->verbose.value(), "spirit_nl_iter_thres : " << this->spirit_nl_iter_thres.value());
GDEBUG_CONDITION_STREAM(this->verbose.value(), "spirit_reg_name : " << this->spirit_reg_name.value());
GDEBUG_CONDITION_STREAM(this->verbose.value(), "spirit_reg_level : " << this->spirit_reg_level.value());
GDEBUG_CONDITION_STREAM(this->verbose.value(), "spirit_reg_keep_approx_coeff : " << this->spirit_reg_keep_approx_coeff.value());
GDEBUG_CONDITION_STREAM(this->verbose.value(), "spirit_reg_keep_redundant_dimension_coeff : " << this->spirit_reg_keep_redundant_dimension_coeff.value());
GDEBUG_CONDITION_STREAM(this->verbose.value(), "spirit_reg_proximity_across_cha : " << this->spirit_reg_proximity_across_cha.value());
GDEBUG_CONDITION_STREAM(this->verbose.value(), "spirit_reg_use_coil_sen_map : " << this->spirit_reg_use_coil_sen_map.value());
GDEBUG_CONDITION_STREAM(this->verbose.value(), "spirit_reg_RO_weighting_ratio : " << this->spirit_reg_RO_weighting_ratio.value());
GDEBUG_CONDITION_STREAM(this->verbose.value(), "spirit_reg_E1_weighting_ratio : " << this->spirit_reg_E1_weighting_ratio.value());
GDEBUG_CONDITION_STREAM(this->verbose.value(), "spirit_reg_N_weighting_ratio : " << this->spirit_reg_N_weighting_ratio.value());
size_t slc, s;
for (slc = 0; slc < SLC; slc++)
{
for (s = 0; s < S; s++)
{
std::stringstream os;
os << "encoding_" << e << "_s" << s << "_slc" << slc;
std::string suffix_2DT = os.str();
// ------------------------------
std::complex<float>* pKspace = &kspace(0, 0, 0, 0, 0, s, slc);
hoNDArray< std::complex<float> > kspace2DT(RO, E1, E2, dstCHA, N, 1, 1, pKspace);
// ------------------------------
long long kernelS = s;
if (kernelS >= (long long)ref_S) kernelS = (long long)ref_S - 1;
std::complex<float>* pKIm = &recon_obj.kernelIm2D_(0, 0, 0, 0, 0, kernelS, slc);
hoNDArray< std::complex<float> > kIm2DT(RO, E1, srcCHA, dstCHA, ref_N, 1, 1, pKIm);
// ------------------------------
std::complex<float>* pRef = &ref(0, 0, 0, 0, 0, kernelS, slc);
hoNDArray< std::complex<float> > ref2DT(ref.get_size(0), ref.get_size(1), ref.get_size(2), dstCHA, ref_N, 1, 1, pRef);
// ------------------------------
hoNDArray< std::complex<float> > coilMap2DT;
if (recon_obj.coil_map_.get_size(6) == SLC)
{
size_t coil_S = recon_obj.coil_map_.get_size(5);
std::complex<float>* pCoilMap = &recon_obj.coil_map_(0, 0, 0, 0, 0, ((s>=coil_S) ? coil_S-1 : s), slc);
coilMap2DT.create(RO, E1, E2, dstCHA, ref_N, 1, 1, pCoilMap);
}
// ------------------------------
std::complex<float>* pRes = &res(0, 0, 0, 0, 0, s, slc);
hoNDArray< std::complex<float> > res2DT(RO, E1, E2, dstCHA, N, 1, 1, pRes);
// ------------------------------
if (!debug_folder_full_path_.empty()) { gt_exporter_.export_array_complex(kspace2DT, debug_folder_full_path_ + "kspace2DT_nl_spirit_" + suffix_2DT); }
if (!debug_folder_full_path_.empty()) { gt_exporter_.export_array_complex(kIm2DT, debug_folder_full_path_ + "kIm2DT_nl_spirit_" + suffix_2DT); }
if (!debug_folder_full_path_.empty()) { gt_exporter_.export_array_complex(ref2DT, debug_folder_full_path_ + "ref2DT_nl_spirit_" + suffix_2DT); }
// ------------------------------
std::string timing_str = "SPIRIT, Non-linear unwrapping, 2DT_" + suffix_2DT;
if (this->perform_timing.value()) timer.start(timing_str.c_str());
this->perform_nonlinear_spirit_unwrapping(kspace2DT, kIm2DT, ref2DT, coilMap2DT, res2DT, e);
if (this->perform_timing.value()) timer.stop();
if (!debug_folder_full_path_.empty()) { gt_exporter_.export_array_complex(res2DT, debug_folder_full_path_ + "res_nl_spirit_2DT_" + suffix_2DT); }
}
}
}
// ---------------------------------------------------------------------
// compute coil combined images
// ---------------------------------------------------------------------
if (this->perform_timing.value()) timer.start("SPIRIT Non linear, coil combination ... ");
this->perform_spirit_coil_combine(recon_obj);
if (this->perform_timing.value()) timer.stop();
if (!debug_folder_full_path_.empty()) { gt_exporter_.export_array_complex(recon_obj.recon_res_.data_, debug_folder_full_path_ + "unwrappedIm_" + suffix); }
}
catch (...)
{
GADGET_THROW("Errors happened in GenericReconCartesianNonLinearSpirit2DTGadget::perform_unwrapping(...) ... ");
}
}
void GenericReconCartesianNonLinearSpirit2DTGadget::perform_nonlinear_spirit_unwrapping(hoNDArray< std::complex<float> >& kspace,
hoNDArray< std::complex<float> >& kerIm, hoNDArray< std::complex<float> >& ref2DT, hoNDArray< std::complex<float> >& coilMap2DT, hoNDArray< std::complex<float> >& res, size_t e)
{
try
{
bool print_iter = this->spirit_print_iter.value();
size_t RO = kspace.get_size(0);
size_t E1 = kspace.get_size(1);
size_t E2 = kspace.get_size(2);
size_t CHA = kspace.get_size(3);
size_t N = kspace.get_size(4);
size_t S = kspace.get_size(5);
size_t SLC = kspace.get_size(6);
size_t ref_N = kerIm.get_size(4);
size_t ref_S = kerIm.get_size(5);
hoNDArray< std::complex<float> > kspaceLinear(kspace);
res = kspace;
// detect whether random sampling is used
bool use_random_sampling = false;
std::vector<long long> sampled_step_size;
long long n, e1;
for (n=0; n<(long long)N; n++)
{
long long prev_sampled_line = -1;
for (e1=0; e1<(long long)E1; e1++)
{
if(std::abs(kspace(RO/2, e1, 0, 0, 0, 0, 0))>0 && std::abs(kspace(RO/2, e1, 0, CHA-1, 0, 0, 0))>0)
{
if(prev_sampled_line>0)
{
sampled_step_size.push_back(e1 - prev_sampled_line);
}
prev_sampled_line = e1;
}
}
}
if(sampled_step_size.size()>4)
{
size_t s;
for (s=2; s<sampled_step_size.size()-1; s++)
{
if(sampled_step_size[s]!=sampled_step_size[s-1])
{
use_random_sampling = true;
break;
}
}
}
if(use_random_sampling)
{
GDEBUG_STREAM("SPIRIT Non linear, random sampling is detected ... ");
}
Gadgetron::GadgetronTimer timer(false);
boost::shared_ptr< hoNDArray< std::complex<float> > > coilMap;
bool hasCoilMap = false;
if (coilMap2DT.get_size(0) == RO && coilMap2DT.get_size(1) == E1 && coilMap2DT.get_size(3)==CHA)
{
if (ref_N < N)
{
coilMap = boost::shared_ptr< hoNDArray< std::complex<float> > >(new hoNDArray< std::complex<float> >(RO, E1, CHA, coilMap2DT.begin()));
}
else
{
coilMap = boost::shared_ptr< hoNDArray< std::complex<float> > >(new hoNDArray< std::complex<float> >(RO, E1, CHA, ref_N, coilMap2DT.begin()));
}
hasCoilMap = true;
}
hoNDArray<float> gFactor;
float gfactorMedian = 0;
float smallest_eigen_value(0);
// -----------------------------------------------------
// estimate gfactor
// -----------------------------------------------------
// mean over N
hoNDArray< std::complex<float> > meanKSpace;
if(calib_mode_[e]==ISMRMRD_interleaved)
{
Gadgetron::compute_averaged_data_N_S(kspace, true, true, true, meanKSpace);
}
else
{
Gadgetron::compute_averaged_data_N_S(ref2DT, true, true, true, meanKSpace);
}
if (!debug_folder_full_path_.empty()) { gt_exporter_.export_array_complex(meanKSpace, debug_folder_full_path_ + "spirit_nl_2DT_meanKSpace"); }
hoNDArray< std::complex<float> > acsSrc(meanKSpace.get_size(0), meanKSpace.get_size(1), CHA, meanKSpace.begin());
hoNDArray< std::complex<float> > acsDst(meanKSpace.get_size(0), meanKSpace.get_size(1), CHA, meanKSpace.begin());
double grappa_reg_lamda = 0.0005;
size_t kRO = 5;
size_t kE1 = 4;
hoNDArray< std::complex<float> > convKer;
hoNDArray< std::complex<float> > kIm(RO, E1, CHA, CHA);
Gadgetron::grappa2d_calib_convolution_kernel(acsSrc, acsDst, (size_t)this->acceFactorE1_[e], grappa_reg_lamda, kRO, kE1, convKer);
Gadgetron::grappa2d_image_domain_kernel(convKer, RO, E1, kIm);
hoNDArray< std::complex<float> > unmixC;
if(hasCoilMap)
{
Gadgetron::grappa2d_unmixing_coeff(kIm, *coilMap, (size_t)acceFactorE1_[e], unmixC, gFactor);
if (!debug_folder_full_path_.empty()) gt_exporter_.export_array(gFactor, debug_folder_full_path_ + "spirit_nl_2DT_gFactor");
hoNDArray<float> gfactorSorted(gFactor);
std::sort(gfactorSorted.begin(), gfactorSorted.begin()+RO*E1);
gfactorMedian = gFactor((RO*E1 / 2));
GDEBUG_STREAM("SPIRIT Non linear, the median gfactor is found to be : " << gfactorMedian);
}
if (!debug_folder_full_path_.empty()) gt_exporter_.export_array_complex(kIm, debug_folder_full_path_ + "spirit_nl_2DT_kIm");
hoNDArray< std::complex<float> > complexIm;
// compute linear solution as the initialization
if(use_random_sampling)
{
if (this->perform_timing.value()) timer.start("SPIRIT Non linear, perform linear spirit recon ... ");
this->perform_spirit_unwrapping(kspace, kerIm, kspaceLinear);
if (this->perform_timing.value()) timer.stop();
}
else
{
if (this->perform_timing.value()) timer.start("SPIRIT Non linear, perform linear recon ... ");
//size_t ref2DT_RO = ref2DT.get_size(0);
//size_t ref2DT_E1 = ref2DT.get_size(1);
//// mean over N
//hoNDArray< std::complex<float> > meanKSpace;
//Gadgetron::sum_over_dimension(ref2DT, meanKSpace, 4);
//if (!debug_folder_full_path_.empty()) { gt_exporter_.export_array_complex(meanKSpace, debug_folder_full_path_ + "spirit_nl_2DT_meanKSpace"); }
//hoNDArray< std::complex<float> > acsSrc(ref2DT_RO, ref2DT_E1, CHA, meanKSpace.begin());
//hoNDArray< std::complex<float> > acsDst(ref2DT_RO, ref2DT_E1, CHA, meanKSpace.begin());
//double grappa_reg_lamda = 0.0005;
//size_t kRO = 5;
//size_t kE1 = 4;
//hoNDArray< std::complex<float> > convKer;
//hoNDArray< std::complex<float> > kIm(RO, E1, CHA, CHA);
//Gadgetron::grappa2d_calib_convolution_kernel(acsSrc, acsDst, (size_t)this->acceFactorE1_[e], grappa_reg_lamda, kRO, kE1, convKer);
//Gadgetron::grappa2d_image_domain_kernel(convKer, RO, E1, kIm);
//if (!debug_folder_full_path_.empty()) gt_exporter_.export_array_complex(kIm, debug_folder_full_path_ + "spirit_nl_2DT_kIm");
Gadgetron::hoNDFFT<float>::instance()->ifft2c(kspace, complex_im_recon_buf_);
if (!debug_folder_full_path_.empty()) gt_exporter_.export_array_complex(complex_im_recon_buf_, debug_folder_full_path_ + "spirit_nl_2DT_aliasedImage");
hoNDArray< std::complex<float> > resKSpace(RO, E1, CHA, N);
hoNDArray< std::complex<float> > aliasedImage(RO, E1, CHA, N, complex_im_recon_buf_.begin());
Gadgetron::grappa2d_image_domain_unwrapping_aliased_image(aliasedImage, kIm, resKSpace);
if (!debug_folder_full_path_.empty()) gt_exporter_.export_array_complex(resKSpace, debug_folder_full_path_ + "spirit_nl_2DT_linearImage");
Gadgetron::hoNDFFT<float>::instance()->fft2c(resKSpace);
memcpy(kspaceLinear.begin(), resKSpace.begin(), resKSpace.get_number_of_bytes());
Gadgetron::apply_unmix_coeff_aliased_image(aliasedImage, unmixC, complexIm);
if (this->perform_timing.value()) timer.stop();
}
if (!debug_folder_full_path_.empty()) gt_exporter_.export_array_complex(kspaceLinear, debug_folder_full_path_ + "spirit_nl_2DT_kspaceLinear");
if(hasCoilMap)
{
if(N>=spirit_reg_minimal_num_images_for_noise_floor.value())
{
// estimate the noise level
if(use_random_sampling)
{
Gadgetron::hoNDFFT<float>::instance()->ifft2c(kspaceLinear, complex_im_recon_buf_);
hoNDArray< std::complex<float> > complexLinearImage(RO, E1, CHA, N, complex_im_recon_buf_.begin());
Gadgetron::coil_combine(complexLinearImage, *coilMap, 2, complexIm);
}
if (!debug_folder_full_path_.empty()) gt_exporter_.export_array_complex(complexIm, debug_folder_full_path_ + "spirit_nl_2DT_linearImage_complexIm");
// if N is sufficiently large, we can estimate the noise floor by the smallest eigen value
hoMatrix< std::complex<float> > data;
data.createMatrix(RO*E1, N, complexIm.begin(), false);
hoNDArray< std::complex<float> > eigenVectors, eigenValues, eigenVectorsPruned;
// compute eigen
hoNDKLT< std::complex<float> > klt;
klt.prepare(data, (size_t)1, (size_t)0);
klt.eigen_value(eigenValues);
if (this->verbose.value())
{
GDEBUG_STREAM("SPIRIT Non linear, computes eigen values for all 2D kspaces ... ");
eigenValues.print(std::cout);
for (size_t i = 0; i<eigenValues.get_size(0); i++)
{
GDEBUG_STREAM(i << " = " << eigenValues(i));
}
}
smallest_eigen_value = std::sqrt( std::abs(eigenValues(N - 1).real()) / (RO*E1) );
GDEBUG_STREAM("SPIRIT Non linear, the smallest eigen value is : " << smallest_eigen_value);
}
}
// perform nonlinear reconstruction
{
boost::shared_ptr<hoNDArray< std::complex<float> > > ker(new hoNDArray< std::complex<float> >(RO, E1, CHA, CHA, ref_N, kerIm.begin()));
boost::shared_ptr<hoNDArray< std::complex<float> > > acq(new hoNDArray< std::complex<float> >(RO, E1, CHA, N, kspace.begin()));
hoNDArray< std::complex<float> > kspaceInitial(RO, E1, CHA, N, kspaceLinear.begin());
hoNDArray< std::complex<float> > res2DT(RO, E1, CHA, N, res.begin());
if (this->spirit_data_fidelity_lamda.value() > 0)
{
GDEBUG_STREAM("Start the NL SPIRIT data fidelity iteration - regularization strength : " << this->spirit_image_reg_lamda.value()
<< " - number of iteration : " << this->spirit_nl_iter_max.value()
<< " - proximity across cha : " << this->spirit_reg_proximity_across_cha.value()
<< " - redundant dimension weighting ratio : " << this->spirit_reg_N_weighting_ratio.value()
<< " - using coil sen map : " << this->spirit_reg_use_coil_sen_map.value()
<< " - iter thres : " << this->spirit_nl_iter_thres.value()
<< " - wavelet name : " << this->spirit_reg_name.value()
);
typedef hoGdSolver< hoNDArray< std::complex<float> >, hoWavelet2DTOperator< std::complex<float> > > SolverType;
SolverType solver;
solver.iterations_ = this->spirit_nl_iter_max.value();
solver.set_output_mode(this->spirit_print_iter.value() ? SolverType::OUTPUT_VERBOSE : SolverType::OUTPUT_SILENT);
solver.grad_thres_ = this->spirit_nl_iter_thres.value();
if(spirit_reg_estimate_noise_floor.value() && std::abs(smallest_eigen_value)>0)
{
solver.scale_factor_ = smallest_eigen_value;
solver.proximal_strength_ratio_ = this->spirit_image_reg_lamda.value() * gfactorMedian;
GDEBUG_STREAM("SPIRIT Non linear, eigen value is used to derive the regularization strength : " << solver.proximal_strength_ratio_ << " - smallest eigen value : " << solver.scale_factor_);
}
else
{
solver.proximal_strength_ratio_ = this->spirit_image_reg_lamda.value();
}
boost::shared_ptr< hoNDArray< std::complex<float> > > x0 = boost::make_shared< hoNDArray< std::complex<float> > >(kspaceInitial);
solver.set_x0(x0);
// parallel imaging term
std::vector<size_t> dims;
acq->get_dimensions(dims);
hoSPIRIT2DTDataFidelityOperator< std::complex<float> > spirit(&dims);
spirit.set_forward_kernel(*ker, false);
spirit.set_acquired_points(*acq);
// image reg term
hoWavelet2DTOperator< std::complex<float> > wav3DOperator(&dims);
wav3DOperator.set_acquired_points(*acq);
wav3DOperator.scale_factor_first_dimension_ = this->spirit_reg_RO_weighting_ratio.value();
wav3DOperator.scale_factor_second_dimension_ = this->spirit_reg_E1_weighting_ratio.value();
wav3DOperator.scale_factor_third_dimension_ = this->spirit_reg_N_weighting_ratio.value();
wav3DOperator.with_approx_coeff_ = !this->spirit_reg_keep_approx_coeff.value();
wav3DOperator.change_coeffcients_third_dimension_boundary_ = !this->spirit_reg_keep_redundant_dimension_coeff.value();
wav3DOperator.proximity_across_cha_ = this->spirit_reg_proximity_across_cha.value();
wav3DOperator.no_null_space_ = true;
wav3DOperator.input_in_kspace_ = true;
wav3DOperator.select_wavelet(this->spirit_reg_name.value());
if (this->spirit_reg_use_coil_sen_map.value() && hasCoilMap)
{
wav3DOperator.coil_map_ = *coilMap;
}
// set operators
solver.oper_system_ = &spirit;
solver.oper_reg_ = &wav3DOperator;
if (this->perform_timing.value()) timer.start("NonLinear SPIRIT solver for 2DT with data fidelity ... ");
solver.solve(*acq, res2DT);
if (this->perform_timing.value()) timer.stop();
if (!debug_folder_full_path_.empty()) gt_exporter_.export_array_complex(res2DT, debug_folder_full_path_ + "spirit_nl_2DT_data_fidelity_res");
}
else
{
GDEBUG_STREAM("Start the NL SPIRIT iteration with regularization strength : "<< this->spirit_image_reg_lamda.value()
<< " - number of iteration : " << this->spirit_nl_iter_max.value()
<< " - proximity across cha : " << this->spirit_reg_proximity_across_cha.value()
<< " - redundant dimension weighting ratio : " << this->spirit_reg_N_weighting_ratio.value()
<< " - using coil sen map : " << this->spirit_reg_use_coil_sen_map.value()
<< " - iter thres : " << this->spirit_nl_iter_thres.value()
<< " - wavelet name : " << this->spirit_reg_name.value()
);
typedef hoGdSolver< hoNDArray< std::complex<float> >, hoWavelet2DTOperator< std::complex<float> > > SolverType;
SolverType solver;
solver.iterations_ = this->spirit_nl_iter_max.value();
solver.set_output_mode(this->spirit_print_iter.value() ? SolverType::OUTPUT_VERBOSE : SolverType::OUTPUT_SILENT);
solver.grad_thres_ = this->spirit_nl_iter_thres.value();
if(spirit_reg_estimate_noise_floor.value() && std::abs(smallest_eigen_value)>0)
{
solver.scale_factor_ = smallest_eigen_value;
solver.proximal_strength_ratio_ = this->spirit_image_reg_lamda.value() * gfactorMedian;
GDEBUG_STREAM("SPIRIT Non linear, eigen value is used to derive the regularization strength : " << solver.proximal_strength_ratio_ << " - smallest eigen value : " << solver.scale_factor_);
}
else
{
solver.proximal_strength_ratio_ = this->spirit_image_reg_lamda.value();
}
boost::shared_ptr< hoNDArray< std::complex<float> > > x0 = boost::make_shared< hoNDArray< std::complex<float> > >(kspaceInitial);
solver.set_x0(x0);
// parallel imaging term
std::vector<size_t> dims;
acq->get_dimensions(dims);
hoSPIRIT2DTOperator< std::complex<float> > spirit(&dims);
spirit.set_forward_kernel(*ker, false);
spirit.set_acquired_points(*acq);
spirit.no_null_space_ = true;
spirit.use_non_centered_fft_ = false;
// image reg term
std::vector<size_t> dim;
acq->get_dimensions(dim);
hoWavelet2DTOperator< std::complex<float> > wav3DOperator(&dim);
wav3DOperator.set_acquired_points(*acq);
wav3DOperator.scale_factor_first_dimension_ = this->spirit_reg_RO_weighting_ratio.value();
wav3DOperator.scale_factor_second_dimension_ = this->spirit_reg_E1_weighting_ratio.value();
wav3DOperator.scale_factor_third_dimension_ = this->spirit_reg_N_weighting_ratio.value();
wav3DOperator.with_approx_coeff_ = !this->spirit_reg_keep_approx_coeff.value();
wav3DOperator.change_coeffcients_third_dimension_boundary_ = !this->spirit_reg_keep_redundant_dimension_coeff.value();
wav3DOperator.proximity_across_cha_ = this->spirit_reg_proximity_across_cha.value();
wav3DOperator.no_null_space_ = true;
wav3DOperator.input_in_kspace_ = true;
wav3DOperator.select_wavelet(this->spirit_reg_name.value());
if (this->spirit_reg_use_coil_sen_map.value() && hasCoilMap)
{
wav3DOperator.coil_map_ = *coilMap;
}
// set operators
solver.oper_system_ = &spirit;
solver.oper_reg_ = &wav3DOperator;
// set call back
solverCallBack cb;
cb.solver_ = &solver;
solver.call_back_ = &cb;
hoNDArray< std::complex<float> > b(kspaceInitial);
Gadgetron::clear(b);
if (this->perform_timing.value()) timer.start("NonLinear SPIRIT solver for 2DT ... ");
solver.solve(b, res2DT);
if (this->perform_timing.value()) timer.stop();
if (!debug_folder_full_path_.empty()) gt_exporter_.export_array_complex(res2DT, debug_folder_full_path_ + "spirit_nl_2DT_res");
spirit.restore_acquired_kspace(kspace, res2DT);
if (!debug_folder_full_path_.empty()) gt_exporter_.export_array_complex(res2DT, debug_folder_full_path_ + "spirit_nl_2DT_res_restored");
}
}
}
catch (...)
{
GADGET_THROW("Errors happened in GenericReconCartesianNonLinearSpirit2DTGadget::perform_nonlinear_spirit_unwrapping(...) ... ");
}
}
void GenericReconCartesianNonLinearSpirit2DTGadget::perform_nonlinear_spirit_unwrapping(hoNDArray< std::complex<float> >& kspace,
hoNDArray< std::complex<float> >& kerIm, hoNDArray< std::complex<float> >& ref2DT, hoNDArray< std::complex<float> >& coilMap2DT, hoNDArray< std::complex<float> >& res, size_t e)
{
try
{
bool print_iter = this->spirit_print_iter.value();
size_t RO = kspace.get_size(0);
size_t E1 = kspace.get_size(1);
size_t E2 = kspace.get_size(2);
size_t CHA = kspace.get_size(3);
size_t N = kspace.get_size(4);
size_t S = kspace.get_size(5);
size_t SLC = kspace.get_size(6);
size_t ref_N = kerIm.get_size(4);
size_t ref_S = kerIm.get_size(5);
hoNDArray< std::complex<float> > kspaceLinear(kspace);
res = kspace;
// detect whether random sampling is used
bool use_random_sampling = false;
std::vector<long long> sampled_step_size;
long long n, e1;
for (n=0; n<(long long)N; n++)
{
long long prev_sampled_line = -1;
for (e1=0; e1<(long long)E1; e1++)
{
if(std::abs(kspace(RO/2, e1, 0, 0, 0, 0, 0))>0 && std::abs(kspace(RO/2, e1, 0, CHA-1, 0, 0, 0))>0)
{
if(prev_sampled_line>0)
{
sampled_step_size.push_back(e1 - prev_sampled_line);
}
prev_sampled_line = e1;
}
}
}
if(sampled_step_size.size()>4)
{
size_t s;
for (s=2; s<sampled_step_size.size()-1; s++)
{
if(sampled_step_size[s]!=sampled_step_size[s-1])
{
use_random_sampling = true;
break;
}
}
}
if(use_random_sampling)
{
GDEBUG_STREAM("SPIRIT Non linear, random sampling is detected ... ");
}
Gadgetron::GadgetronTimer timer(false);
// compute linear solution as the initialization
if(use_random_sampling)
{
if (this->perform_timing.value()) timer.start("SPIRIT Non linear, perform linear spirit recon ... ");
this->perform_spirit_unwrapping(kspace, kerIm, kspaceLinear);
if (this->perform_timing.value()) timer.stop();
}
else
{
if (this->perform_timing.value()) timer.start("SPIRIT Non linear, perform linear recon ... ");
size_t ref2DT_RO = ref2DT.get_size(0);
size_t ref2DT_E1 = ref2DT.get_size(1);
// mean over N
hoNDArray< std::complex<float> > meanKSpace;
Gadgetron::sum_over_dimension(ref2DT, meanKSpace, 4);
// if (!debug_folder_full_path_.empty()) { gt_exporter_.export_array_complex(meanKSpace, debug_folder_full_path_ + "spirit_nl_2DT_meanKSpace"); }
hoNDArray< std::complex<float> > acsSrc(ref2DT_RO, ref2DT_E1, CHA, meanKSpace.begin());
hoNDArray< std::complex<float> > acsDst(ref2DT_RO, ref2DT_E1, CHA, meanKSpace.begin());
double grappa_reg_lamda = 0.0005;
size_t kRO = 5;
size_t kE1 = 4;
hoNDArray< std::complex<float> > convKer;
hoNDArray< std::complex<float> > kIm(RO, E1, CHA, CHA);
Gadgetron::grappa2d_calib_convolution_kernel(acsSrc, acsDst, (size_t)this->acceFactorE1_[e], grappa_reg_lamda, kRO, kE1, convKer);
Gadgetron::grappa2d_image_domain_kernel(convKer, RO, E1, kIm);
// if (!debug_folder_full_path_.empty()) gt_exporter_.export_array_complex(kIm, debug_folder_full_path_ + "spirit_nl_2DT_kIm");
Gadgetron::hoNDFFT<float>::instance()->ifft2c(kspace, complex_im_recon_buf_);
// if (!debug_folder_full_path_.empty()) gt_exporter_.export_array_complex(complex_im_recon_buf_, debug_folder_full_path_ + "spirit_nl_2DT_aliasedImage");
hoNDArray< std::complex<float> > resKSpace(RO, E1, CHA, N);
hoNDArray< std::complex<float> > aliasedImage(RO, E1, CHA, N, complex_im_recon_buf_.begin());
Gadgetron::grappa2d_image_domain_unwrapping_aliased_image(aliasedImage, kIm, resKSpace);
// if (!debug_folder_full_path_.empty()) gt_exporter_.export_array_complex(resKSpace, debug_folder_full_path_ + "spirit_nl_2DT_linearImage");
Gadgetron::hoNDFFT<float>::instance()->fft2c(resKSpace);
memcpy(kspaceLinear.begin(), resKSpace.begin(), resKSpace.get_number_of_bytes());
if (this->perform_timing.value()) timer.stop();
}
// if (!debug_folder_full_path_.empty()) gt_exporter_.export_array_complex(kspaceLinear, debug_folder_full_path_ + "spirit_nl_2DT_kspaceLinear");
// perform nonlinear reconstruction
{
boost::shared_ptr< hoNDArray< std::complex<float> > > coilMap;
bool hasCoilMap = false;
if (coilMap2DT.get_size(0) == RO && coilMap2DT.get_size(1) == E1 && coilMap2DT.get_size(3)==CHA)
{
if (ref_N < N)
{
coilMap = boost::shared_ptr< hoNDArray< std::complex<float> > >(new hoNDArray< std::complex<float> >(RO, E1, CHA, coilMap2DT.begin()));
}
else
{
coilMap = boost::shared_ptr< hoNDArray< std::complex<float> > >(new hoNDArray< std::complex<float> >(RO, E1, CHA, ref_N, coilMap2DT.begin()));
}
hasCoilMap = true;
}
boost::shared_ptr<hoNDArray< std::complex<float> > > ker(new hoNDArray< std::complex<float> >(RO, E1, CHA, CHA, ref_N, kerIm.begin()));
boost::shared_ptr<hoNDArray< std::complex<float> > > acq(new hoNDArray< std::complex<float> >(RO, E1, CHA, N, kspace.begin()));
hoNDArray< std::complex<float> > kspaceInitial(RO, E1, CHA, N, kspaceLinear.begin());
hoNDArray< std::complex<float> > res2DT(RO, E1, CHA, N, res.begin());
if (this->spirit_data_fidelity_lamda.value() > 0)
{
GDEBUG_STREAM("Start the NL SPIRIT data fidelity iteration - regularization strength : "
<< this->spirit_image_reg_lamda.value()
<< " - number of iteration : " << this->spirit_nl_iter_max.value()
<< " - proximity across cha : " << this->spirit_reg_proximity_across_cha.value()
<< " - redundant dimension weighting ratio : " << this->spirit_reg_N_weighting_ratio.value()
<< " - using coil sen map : " << this->spirit_reg_use_coil_sen_map.value()
<< " - iter thres : " << this->spirit_nl_iter_thres.value());
typedef hoGdSolver< hoNDArray< std::complex<float> >, hoWavelet2DTOperator< std::complex<float> > > SolverType;
SolverType solver;
solver.iterations_ = this->spirit_nl_iter_max.value();
solver.set_output_mode(this->spirit_print_iter.value() ? SolverType::OUTPUT_VERBOSE : SolverType::OUTPUT_SILENT);
solver.grad_thres_ = this->spirit_nl_iter_thres.value();
solver.proximal_strength_ratio_ = this->spirit_image_reg_lamda.value();
boost::shared_ptr< hoNDArray< std::complex<float> > > x0 = boost::make_shared< hoNDArray< std::complex<float> > >(kspaceInitial);
solver.set_x0(x0);
// parallel imaging term
std::vector<size_t> dims;
acq->get_dimensions(dims);
hoSPIRIT2DTDataFidelityOperator< std::complex<float> > spirit(&dims);
spirit.set_forward_kernel(*ker, false);
spirit.set_acquired_points(*acq);
// image reg term
hoWavelet2DTOperator< std::complex<float> > wav3DOperator(&dims);
wav3DOperator.set_acquired_points(*acq);
wav3DOperator.scale_factor_first_dimension_ = this->spirit_reg_RO_weighting_ratio.value();
wav3DOperator.scale_factor_second_dimension_ = this->spirit_reg_E1_weighting_ratio.value();
wav3DOperator.scale_factor_third_dimension_ = this->spirit_reg_N_weighting_ratio.value();
wav3DOperator.with_approx_coeff_ = !this->spirit_reg_keep_approx_coeff.value();
wav3DOperator.change_coeffcients_third_dimension_boundary_ = !this->spirit_reg_keep_redundant_dimension_coeff.value();
wav3DOperator.proximity_across_cha_ = this->spirit_reg_proximity_across_cha.value();
wav3DOperator.no_null_space_ = true;
wav3DOperator.input_in_kspace_ = true;
if (this->spirit_reg_use_coil_sen_map.value() && hasCoilMap)
{
wav3DOperator.coil_map_ = *coilMap;
}
// set operators
solver.oper_system_ = &spirit;
solver.oper_reg_ = &wav3DOperator;
if (this->perform_timing.value()) timer.start("NonLinear SPIRIT solver for 2DT with data fidelity ... ");
solver.solve(*acq, res2DT);
if (this->perform_timing.value()) timer.stop();
// if (!debug_folder_full_path_.empty()) gt_exporter_.export_array_complex(res2DT, debug_folder_full_path_ + "spirit_nl_2DT_data_fidelity_res");
}
else
{
GDEBUG_STREAM("Start the NL SPIRIT iteration with regularization strength : "
<< this->spirit_image_reg_lamda.value()
<< " - number of iteration : " << this->spirit_nl_iter_max.value()
<< " - proximity across cha : " << this->spirit_reg_proximity_across_cha.value()
<< " - redundant dimension weighting ratio : " << this->spirit_reg_N_weighting_ratio.value()
<< " - using coil sen map : " << this->spirit_reg_use_coil_sen_map.value()
<< " - iter thres : " << this->spirit_nl_iter_thres.value());
typedef hoGdSolver< hoNDArray< std::complex<float> >, hoWavelet2DTOperator< std::complex<float> > > SolverType;
SolverType solver;
solver.iterations_ = this->spirit_nl_iter_max.value();
solver.set_output_mode(this->spirit_print_iter.value() ? SolverType::OUTPUT_VERBOSE : SolverType::OUTPUT_SILENT);
solver.grad_thres_ = this->spirit_nl_iter_thres.value();
solver.proximal_strength_ratio_ = this->spirit_image_reg_lamda.value();
boost::shared_ptr< hoNDArray< std::complex<float> > > x0 = boost::make_shared< hoNDArray< std::complex<float> > >(kspaceInitial);
solver.set_x0(x0);
// parallel imaging term
std::vector<size_t> dims;
acq->get_dimensions(dims);
hoSPIRIT2DTOperator< std::complex<float> > spirit(&dims);
spirit.set_forward_kernel(*ker, false);
spirit.set_acquired_points(*acq);
spirit.no_null_space_ = true;
spirit.use_non_centered_fft_ = false;
// image reg term
std::vector<size_t> dim;
acq->get_dimensions(dim);
hoWavelet2DTOperator< std::complex<float> > wav3DOperator(&dim);
wav3DOperator.set_acquired_points(*acq);
wav3DOperator.scale_factor_first_dimension_ = this->spirit_reg_RO_weighting_ratio.value();
wav3DOperator.scale_factor_second_dimension_ = this->spirit_reg_E1_weighting_ratio.value();
wav3DOperator.scale_factor_third_dimension_ = this->spirit_reg_N_weighting_ratio.value();
wav3DOperator.with_approx_coeff_ = !this->spirit_reg_keep_approx_coeff.value();
wav3DOperator.change_coeffcients_third_dimension_boundary_ = !this->spirit_reg_keep_redundant_dimension_coeff.value();
wav3DOperator.proximity_across_cha_ = this->spirit_reg_proximity_across_cha.value();
wav3DOperator.no_null_space_ = true;
wav3DOperator.input_in_kspace_ = true;
if (this->spirit_reg_use_coil_sen_map.value() && hasCoilMap)
{
wav3DOperator.coil_map_ = *coilMap;
}
// set operators
solver.oper_system_ = &spirit;
solver.oper_reg_ = &wav3DOperator;
// set call back
solverCallBack cb;
cb.solver_ = &solver;
solver.call_back_ = &cb;
hoNDArray< std::complex<float> > b(kspaceInitial);
Gadgetron::clear(b);
if (this->perform_timing.value()) timer.start("NonLinear SPIRIT solver for 2DT ... ");
solver.solve(b, res2DT);
if (this->perform_timing.value()) timer.stop();
// if (!debug_folder_full_path_.empty()) gt_exporter_.export_array_complex(res2DT, debug_folder_full_path_ + "spirit_nl_2DT_res");
spirit.restore_acquired_kspace(kspace, res2DT);
// if (!debug_folder_full_path_.empty()) gt_exporter_.export_array_complex(res2DT, debug_folder_full_path_ + "spirit_nl_2DT_res_restored");
}
}
}
catch (...)
{
GADGET_THROW("Errors happened in GenericReconCartesianNonLinearSpirit2DTGadget::perform_nonlinear_spirit_unwrapping(...) ... ");
}
}
void MultiChannelCartesianGrappaReconGadget::compute_image_header(IsmrmrdReconBit& recon_bit, ReconObjType& recon_obj, size_t e)
{
try
{
size_t RO = recon_obj.recon_res_.data_.get_size(0);
size_t E1 = recon_obj.recon_res_.data_.get_size(1);
size_t E2 = recon_obj.recon_res_.data_.get_size(2);
size_t CHA = recon_obj.recon_res_.data_.get_size(3);
size_t N = recon_obj.recon_res_.data_.get_size(4);
size_t S = recon_obj.recon_res_.data_.get_size(5);
size_t SLC = recon_obj.recon_res_.data_.get_size(6);
GADGET_CHECK_THROW(N == recon_bit.data_.headers_.get_size(2));
GADGET_CHECK_THROW(S == recon_bit.data_.headers_.get_size(3));
recon_obj.recon_res_.headers_.create(N, S, SLC);
recon_obj.recon_res_.meta_.resize(N*S*SLC);
size_t n, s, slc;
for (slc = 0; slc < SLC; slc++)
{
for (s = 0; s < S; s++)
{
for (n = 0; n < N; n++)
{
size_t header_E1 = recon_bit.data_.headers_.get_size(0);
size_t header_E2 = recon_bit.data_.headers_.get_size(1);
// for every kspace, find the recorded header which is closest to the kspace center [E1/2 E2/2]
ISMRMRD::AcquisitionHeader acq_header;
long long bestE1 = E1 + 1;
long long bestE2 = E2 + 1;
size_t e1, e2;
for (e2 = 0; e2 < header_E2; e2++)
{
for (e1 = 0; e1 < header_E1; e1++)
{
ISMRMRD::AcquisitionHeader& curr_header = recon_bit.data_.headers_(e1, e2, n, s, slc);
// if (curr_header.measurement_uid != 0) // a valid header
{
if (E2 > 1)
{
if (std::abs((long long)curr_header.idx.kspace_encode_step_1 - (long long)(E1 / 2)) < bestE1
&& std::abs((long long)curr_header.idx.kspace_encode_step_2 - (long long)(E2 / 2)) < bestE2)
{
bestE1 = std::abs((long long)curr_header.idx.kspace_encode_step_1 - (long long)E1 / 2);
bestE2 = std::abs((long long)curr_header.idx.kspace_encode_step_2 - (long long)E2 / 2);
acq_header = curr_header;
}
}
else
{
if (std::abs((long long)curr_header.idx.kspace_encode_step_1 - (long long)(E1 / 2)) < bestE1)
{
bestE1 = std::abs((long long)curr_header.idx.kspace_encode_step_1 - (long long)E1 / 2);
acq_header = curr_header;
}
}
}
}
}
//if (acq_header.measurement_uid == 0)
//{
// std::ostringstream ostr;
// ostr << "Cannot create valid image header : n = " << n << ", s = " << s << ", slc = " << slc;
// GADGET_THROW(ostr.str());
//}
//else
//{
ISMRMRD::ImageHeader& im_header = recon_obj.recon_res_.headers_(n, s, slc);
ISMRMRD::MetaContainer& meta = recon_obj.recon_res_.meta_[n + s*N + slc*N*S];
im_header.version = acq_header.version;
im_header.data_type = ISMRMRD::ISMRMRD_CXFLOAT;
im_header.flags = acq_header.flags;
im_header.measurement_uid = acq_header.measurement_uid;
im_header.matrix_size[0] = (uint16_t)RO;
im_header.matrix_size[1] = (uint16_t)E1;
im_header.matrix_size[2] = (uint16_t)E2;
im_header.field_of_view[0] = recon_bit.data_.sampling_.recon_FOV_[0];
im_header.field_of_view[1] = recon_bit.data_.sampling_.recon_FOV_[1];
im_header.field_of_view[2] = recon_bit.data_.sampling_.recon_FOV_[2];
im_header.channels = (uint16_t)CHA;
im_header.position[0] = acq_header.position[0];
im_header.position[1] = acq_header.position[1];
im_header.position[2] = acq_header.position[2];
im_header.read_dir[0] = acq_header.read_dir[0];
im_header.read_dir[1] = acq_header.read_dir[1];
im_header.read_dir[2] = acq_header.read_dir[2];
im_header.phase_dir[0] = acq_header.phase_dir[0];
im_header.phase_dir[1] = acq_header.phase_dir[1];
im_header.phase_dir[2] = acq_header.phase_dir[2];
im_header.slice_dir[0] = acq_header.slice_dir[0];
im_header.slice_dir[1] = acq_header.slice_dir[1];
im_header.slice_dir[2] = acq_header.slice_dir[2];
im_header.patient_table_position[0] = acq_header.patient_table_position[0];
im_header.patient_table_position[1] = acq_header.patient_table_position[1];
im_header.patient_table_position[2] = acq_header.patient_table_position[2];
im_header.average = acq_header.idx.average;
im_header.slice = acq_header.idx.slice;
im_header.contrast = acq_header.idx.contrast;
im_header.phase = acq_header.idx.phase;
im_header.repetition = acq_header.idx.repetition;
im_header.set = acq_header.idx.set;
im_header.acquisition_time_stamp = acq_header.acquisition_time_stamp;
im_header.physiology_time_stamp[0] = acq_header.physiology_time_stamp[0];
im_header.physiology_time_stamp[1] = acq_header.physiology_time_stamp[1];
im_header.physiology_time_stamp[2] = acq_header.physiology_time_stamp[2];
im_header.image_type = ISMRMRD::ISMRMRD_IMTYPE_MAGNITUDE;
im_header.image_index = (uint16_t)(n + s*N + slc*N*S);
im_header.image_series_index = 0;
memcpy(im_header.user_int, acq_header.user_int, sizeof(int32_t)*ISMRMRD::ISMRMRD_USER_INTS);
memcpy(im_header.user_float, acq_header.user_float, sizeof(float)*ISMRMRD::ISMRMRD_USER_FLOATS);
im_header.attribute_string_len = 0;
meta.set("encoding", (long)e);
meta.set("encoding_FOV", recon_bit.data_.sampling_.encoded_FOV_[0]);
meta.append("encoding_FOV", recon_bit.data_.sampling_.encoded_FOV_[1]);
meta.append("encoding_FOV", recon_bit.data_.sampling_.encoded_FOV_[2]);
meta.set("recon_FOV", recon_bit.data_.sampling_.recon_FOV_[0]);
meta.append("recon_FOV", recon_bit.data_.sampling_.recon_FOV_[1]);
meta.append("recon_FOV", recon_bit.data_.sampling_.recon_FOV_[2]);
meta.set("encoded_matrix", (long)recon_bit.data_.sampling_.encoded_matrix_[0]);
meta.append("encoded_matrix", (long)recon_bit.data_.sampling_.encoded_matrix_[1]);
meta.append("encoded_matrix", (long)recon_bit.data_.sampling_.encoded_matrix_[2]);
meta.set("recon_matrix", (long)recon_bit.data_.sampling_.recon_matrix_[0]);
meta.append("recon_matrix", (long)recon_bit.data_.sampling_.recon_matrix_[1]);
meta.append("recon_matrix", (long)recon_bit.data_.sampling_.recon_matrix_[2]);
meta.set("sampling_limits_RO", (long)recon_bit.data_.sampling_.sampling_limits_[0].min_);
meta.append("sampling_limits_RO", (long)recon_bit.data_.sampling_.sampling_limits_[0].center_);
meta.append("sampling_limits_RO", (long)recon_bit.data_.sampling_.sampling_limits_[0].max_);
meta.set("sampling_limits_E1", (long)recon_bit.data_.sampling_.sampling_limits_[1].min_);
meta.append("sampling_limits_E1", (long)recon_bit.data_.sampling_.sampling_limits_[1].center_);
meta.append("sampling_limits_E1", (long)recon_bit.data_.sampling_.sampling_limits_[1].max_);
meta.set("sampling_limits_E2", (long)recon_bit.data_.sampling_.sampling_limits_[2].min_);
meta.append("sampling_limits_E2", (long)recon_bit.data_.sampling_.sampling_limits_[2].center_);
meta.append("sampling_limits_E2", (long)recon_bit.data_.sampling_.sampling_limits_[2].max_);
//}
}
}
}
}
catch (...)
{
GADGET_THROW("Errors happened in MultiChannelCartesianGrappaReconGadget::compute_image_header(...) ... ");
}
}
void MultiChannelCartesianGrappaReconGadget::perform_unwrapping(IsmrmrdReconBit& recon_bit, ReconObjType& recon_obj, size_t e)
{
try
{
typedef std::complex<float> T;
size_t RO = recon_bit.data_.data_.get_size(0);
size_t E1 = recon_bit.data_.data_.get_size(1);
size_t E2 = recon_bit.data_.data_.get_size(2);
size_t dstCHA = recon_bit.data_.data_.get_size(3);
size_t N = recon_bit.data_.data_.get_size(4);
size_t S = recon_bit.data_.data_.get_size(5);
size_t SLC = recon_bit.data_.data_.get_size(6);
hoNDArray< std::complex<float> >& src = recon_obj.ref_calib_;
hoNDArray< std::complex<float> >& dst = recon_obj.ref_calib_;
size_t ref_RO = src.get_size(0);
size_t ref_E1 = src.get_size(1);
size_t ref_E2 = src.get_size(2);
size_t srcCHA = src.get_size(3);
size_t ref_N = src.get_size(4);
size_t ref_S = src.get_size(5);
size_t ref_SLC = src.get_size(6);
size_t convkRO = recon_obj.kernel_.get_size(0);
size_t convkE1 = recon_obj.kernel_.get_size(1);
size_t convkE2 = recon_obj.kernel_.get_size(2);
recon_obj.recon_res_.data_.create(RO, E1, E2, dstCHA, N, S, SLC);
// compute aliased images
data_recon_buf_.create(RO, E1, E2, dstCHA, N, S, SLC);
if (E2>1)
{
Gadgetron::hoNDFFT<float>::instance()->ifft3c(recon_bit.data_.data_, complex_im_recon_buf_, data_recon_buf_);
}
else
{
Gadgetron::hoNDFFT<float>::instance()->ifft2c(recon_bit.data_.data_, complex_im_recon_buf_, data_recon_buf_);
}
// SNR unit scaling
float effectiveAcceFactor = acceFactorE1_[e] * acceFactorE2_[e];
if (effectiveAcceFactor > 1)
{
float fftCompensationRatio = (float)(1.0 / std::sqrt(effectiveAcceFactor));
Gadgetron::scal(fftCompensationRatio, complex_im_recon_buf_);
}
// unwrapping
long long num = N*S*SLC;
long long ii;
#pragma omp parallel default(none) private(ii) shared(num, N, S, RO, E1, E2, srcCHA, convkRO, convkE1, convkE2, ref_N, ref_S, recon_obj, dstCHA, e) if(num>1)
{
#pragma omp for
for (ii = 0; ii < num; ii++)
{
size_t slc = ii / (N*S);
size_t s = (ii - slc*N*S) / N;
size_t n = ii - slc*N*S - s*N;
// combined channels
T* pIm = &(complex_im_recon_buf_(0, 0, 0, 0, n, s, slc));
hoNDArray< std::complex<float> > aliasedIm(RO, E1, E2, srcCHA, 1, pIm);
size_t usedN = n;
if (n >= ref_N) usedN = ref_N - 1;
size_t usedS = s;
if (s >= ref_S) usedS = ref_S - 1;
T* pUnmix = &(recon_obj.unmixing_coeff_(0, 0, 0, 0, usedN, usedS, slc));
hoNDArray< std::complex<float> > unmixing(RO, E1, E2, srcCHA, pUnmix);
T* pRes = &(recon_obj.recon_res_.data_(0, 0, 0, 0, n, s, slc));
hoNDArray< std::complex<float> > res(RO, E1, E2, dstCHA, pRes);
Gadgetron::apply_unmix_coeff_aliased_image_3D(aliasedIm, unmixing, res);
}
}
}
catch (...)
{
GADGET_THROW("Errors happened in MultiChannelCartesianGrappaReconGadget::perform_unwrapping(...) ... ");
}
}
void MultiChannelCartesianGrappaReconGadget::perform_calib(IsmrmrdReconBit& recon_bit, ReconObjType& recon_obj, size_t e)
{
try
{
size_t RO = recon_bit.data_.data_.get_size(0);
size_t E1 = recon_bit.data_.data_.get_size(1);
size_t E2 = recon_bit.data_.data_.get_size(2);
hoNDArray< std::complex<float> >& src = recon_obj.ref_calib_;
hoNDArray< std::complex<float> >& dst = recon_obj.ref_calib_;
size_t ref_RO = src.get_size(0);
size_t ref_E1 = src.get_size(1);
size_t ref_E2 = src.get_size(2);
size_t srcCHA = src.get_size(3);
size_t ref_N = src.get_size(4);
size_t ref_S = src.get_size(5);
size_t ref_SLC = src.get_size(6);
size_t dstCHA = dst.get_size(3);
recon_obj.unmixing_coeff_.create(RO, E1, E2, srcCHA, ref_N, ref_S, ref_SLC);
recon_obj.gfactor_.create(RO, E1, E2, 1, ref_N, ref_S, ref_SLC);
Gadgetron::clear(recon_obj.unmixing_coeff_);
Gadgetron::clear(recon_obj.gfactor_);
if (acceFactorE1_[e] <= 1 && acceFactorE2_[e] <= 1)
{
Gadgetron::conjugate(recon_obj.coil_map_, recon_obj.unmixing_coeff_);
}
else
{
// allocate buffer for kernels
size_t kRO = grappa_kSize_RO.value();
size_t kNE1 = grappa_kSize_E1.value();
size_t kNE2 = grappa_kSize_E2.value();
size_t convKRO(1), convKE1(1), convKE2(1);
if (E2 > 1)
{
std::vector<int> kE1, oE1;
std::vector<int> kE2, oE2;
bool fitItself = true;
grappa3d_kerPattern(kE1, oE1, kE2, oE2, convKRO, convKE1, convKE2, (size_t)acceFactorE1_[e], (size_t)acceFactorE2_[e], kRO, kNE1, kNE2, fitItself);
}
else
{
std::vector<int> kE1, oE1;
bool fitItself = true;
Gadgetron::grappa2d_kerPattern(kE1, oE1, convKRO, convKE1, (size_t)acceFactorE1_[e], kRO, kNE1, fitItself);
recon_obj.kernelIm_.create(RO, E1, 1, srcCHA, dstCHA, ref_N, ref_S, ref_SLC);
}
recon_obj.kernel_.create(convKRO, convKE1, convKE2, srcCHA, dstCHA, ref_N, ref_S, ref_SLC);
Gadgetron::clear(recon_obj.kernel_);
Gadgetron::clear(recon_obj.kernelIm_);
long long num = ref_N*ref_S*ref_SLC;
long long ii;
#pragma omp parallel for default(none) private(ii) shared(src, dst, recon_obj, e, num, ref_N, ref_S, ref_RO, ref_E1, ref_E2, RO, E1, E2, dstCHA, srcCHA, convKRO, convKE1, convKE2, kRO, kNE1, kNE2) if(num>1)
for (ii = 0; ii < num; ii++)
{
size_t slc = ii / (ref_N*ref_S);
size_t s = (ii - slc*ref_N*ref_S) / (ref_N);
size_t n = ii - slc*ref_N*ref_S - s*ref_N;
std::stringstream os;
os << "n" << n << "_s" << s << "_slc" << slc << "_encoding_" << e;
std::string suffix = os.str();
std::complex<float>* pSrc = &(src(0, 0, 0, 0, n, s, slc));
hoNDArray< std::complex<float> > ref_src(ref_RO, ref_E1, ref_E2, srcCHA, pSrc);
std::complex<float>* pDst = &(dst(0, 0, 0, 0, n, s, slc));
hoNDArray< std::complex<float> > ref_dst(ref_RO, ref_E1, ref_E2, dstCHA, pDst);
// -----------------------------------
if (E2 > 1)
{
hoNDArray< std::complex<float> > ker(convKRO, convKE1, convKE2, srcCHA, dstCHA, &(recon_obj.kernel_(0, 0, 0, 0, 0, n, s, slc)));
Gadgetron::grappa3d_calib_convolution_kernel(ref_src, ref_dst, (size_t)acceFactorE1_[e], (size_t)acceFactorE2_[e], grappa_reg_lamda.value(), grappa_calib_over_determine_ratio.value(), kRO, kNE1, kNE2, ker);
hoNDArray< std::complex<float> > coilMap(RO, E1, E2, dstCHA, &(recon_obj.coil_map_(0, 0, 0, 0, n, s, slc)));
hoNDArray< std::complex<float> > unmixC(RO, E1, E2, srcCHA, &(recon_obj.unmixing_coeff_(0, 0, 0, 0, n, s, slc)));
hoNDArray<float> gFactor(RO, E1, E2, 1, &(recon_obj.gfactor_(0, 0, 0, 0, n, s, slc)));
Gadgetron::grappa3d_unmixing_coeff(ker, coilMap, (size_t)acceFactorE1_[e], (size_t)acceFactorE2_[e], unmixC, gFactor);
}
else
{
hoNDArray< std::complex<float> > acsSrc(ref_RO, ref_E1, srcCHA, const_cast< std::complex<float>*>(ref_src.begin()));
hoNDArray< std::complex<float> > acsDst(ref_RO, ref_E1, dstCHA, const_cast< std::complex<float>*>(ref_dst.begin()));
hoNDArray< std::complex<float> > convKer(convKRO, convKE1, srcCHA, dstCHA, &(recon_obj.kernel_(0, 0, 0, 0, 0, n, s, slc)));
hoNDArray< std::complex<float> > kIm(RO, E1, srcCHA, dstCHA, &(recon_obj.kernelIm_(0, 0, 0, 0, 0, n, s, slc)));
Gadgetron::grappa2d_calib_convolution_kernel(acsSrc, acsDst, (size_t)acceFactorE1_[e], grappa_reg_lamda.value(), kRO, kNE1, convKer);
Gadgetron::grappa2d_image_domain_kernel(convKer, RO, E1, kIm);
hoNDArray< std::complex<float> > coilMap(RO, E1, dstCHA, &(recon_obj.coil_map_(0, 0, 0, 0, n, s, slc)));
hoNDArray< std::complex<float> > unmixC(RO, E1, srcCHA, &(recon_obj.unmixing_coeff_(0, 0, 0, 0, n, s, slc)));
hoNDArray<float> gFactor;
Gadgetron::grappa2d_unmixing_coeff(kIm, coilMap, (size_t)acceFactorE1_[e], unmixC, gFactor);
memcpy(&(recon_obj.gfactor_(0, 0, 0, 0, n, s, slc)), gFactor.begin(), gFactor.get_number_of_bytes());
}
// -----------------------------------
}
}
}
catch (...)
{
GADGET_THROW("Errors happened in MultiChannelCartesianGrappaReconGadget::perform_calib(...) ... ");
}
}
void grappa2d_calib(const hoNDArray<T>& acsSrc, const hoNDArray<T>& acsDst, double thres, size_t kRO, const std::vector<int>& kE1, const std::vector<int>& oE1, size_t startRO, size_t endRO, size_t startE1, size_t endE1, hoNDArray<T>& ker)
{
try
{
GADGET_CHECK_THROW(acsSrc.get_size(0)==acsDst.get_size(0));
GADGET_CHECK_THROW(acsSrc.get_size(1)==acsDst.get_size(1));
GADGET_CHECK_THROW(acsSrc.get_size(2)>=acsDst.get_size(2));
size_t RO = acsSrc.get_size(0);
size_t E1 = acsSrc.get_size(1);
size_t srcCHA = acsSrc.get_size(2);
size_t dstCHA = acsDst.get_size(2);
const T* pSrc = acsSrc.begin();
const T* pDst = acsDst.begin();
long long kROhalf = kRO/2;
if ( 2*kROhalf == kRO )
{
GWARN_STREAM("grappa<T>::calib(...) - 2*kROhalf == kRO " << kRO);
}
kRO = 2*kROhalf + 1;
size_t kNE1 = kE1.size();
size_t oNE1 = oE1.size();
/// allocate kernel
ker.create(kRO, kNE1, srcCHA, dstCHA, oNE1);
/// loop over the calibration region and assemble the equation
/// Ax = b
size_t sRO = startRO + kROhalf;
size_t eRO = endRO - kROhalf;
size_t sE1 = std::abs(kE1[0]) + startE1;
size_t eE1 = endE1 - kE1[kNE1-1];
size_t lenRO = eRO - sRO + 1;
size_t rowA = (eE1-sE1+1)*lenRO;
size_t colA = kRO*kNE1*srcCHA;
size_t colB = dstCHA*oNE1;
hoMatrix<T> A;
hoMatrix<T> B;
hoMatrix<T> x( colA, colB );
hoNDArray<T> A_mem(rowA, colA);
A.createMatrix( rowA, colA, A_mem.begin() );
T* pA = A.begin();
hoNDArray<T> B_mem(rowA, colB);
B.createMatrix( A.rows(), colB, B_mem.begin() );
T* pB = B.begin();
long long e1;
for ( e1=(long long)sE1; e1<=(long long)eE1; e1++ )
{
for ( long long ro=sRO; ro<=(long long)eRO; ro++ )
{
long long rInd = (e1-sE1)*lenRO+ro-kROhalf;
size_t src, dst, ke1, oe1;
long long kro;
/// fill matrix A
size_t col = 0;
size_t offset = 0;
for ( src=0; src<srcCHA; src++ )
{
for ( ke1=0; ke1<kNE1; ke1++ )
{
offset = src*RO*E1 + (e1+kE1[ke1])*RO;
for ( kro=-kROhalf; kro<=kROhalf; kro++ )
{
/// A(rInd, col++) = acsSrc(ro+kro, e1+kE1[ke1], src);
pA[rInd + col*rowA] = pSrc[ro+kro+offset];
col++;
}
}
}
/// fill matrix B
col = 0;
for ( oe1=0; oe1<oNE1; oe1++ )
{
for ( dst=0; dst<dstCHA; dst++ )
{
B(rInd, col++) = acsDst(ro, e1+oE1[oe1], dst);
}
}
}
}
SolveLinearSystem_Tikhonov(A, B, x, thres);
memcpy(ker.begin(), x.begin(), ker.get_number_of_bytes());
}
catch(...)
{
GADGET_THROW("Errors in grappa2d_calib(...) ... ");
}
return;
}
void MultiChannelCartesianGrappaReconGadget::make_ref_coil_map(IsmrmrdDataBuffered& ref_, std::vector<size_t> recon_dims, ReconObjType& recon_obj, size_t encoding)
{
try
{
hoNDArray< std::complex<float> >& ref_data = ref_.data_;
hoNDArray< std::complex<float> >& ref_calib = recon_obj.ref_calib_;
hoNDArray< std::complex<float> >& ref_coil_map = recon_obj.ref_coil_map_;
// sampling limits
size_t sRO = ref_.sampling_.sampling_limits_[0].min_;
size_t eRO = ref_.sampling_.sampling_limits_[0].max_;
size_t cRO = ref_.sampling_.sampling_limits_[0].center_;
size_t sE1 = ref_.sampling_.sampling_limits_[1].min_;
size_t eE1 = ref_.sampling_.sampling_limits_[1].max_;
size_t cE1 = ref_.sampling_.sampling_limits_[1].center_;
size_t sE2 = ref_.sampling_.sampling_limits_[2].min_;
size_t eE2 = ref_.sampling_.sampling_limits_[2].max_;
size_t cE2 = ref_.sampling_.sampling_limits_[2].center_;
// recon size
size_t recon_RO = recon_dims[0];
size_t recon_E1 = recon_dims[1];
size_t recon_E2 = recon_dims[2];
// ref array size
size_t CHA = ref_data.get_size(3);
size_t N = ref_data.get_size(4);
size_t S = ref_data.get_size(5);
size_t SLC = ref_data.get_size(6);
// determine the ref_coil_map size
size_t RO = 2 * cRO;
if (sRO>0 || eRO<RO - 1)
{
RO = 2 * std::max(cRO - sRO, eRO - cRO+1);
if (RO>recon_RO) RO = recon_RO;
}
size_t E1 = eE1 - sE1 + 1;
size_t E2 = eE2 - sE2 + 1;
if ((calib_mode_[encoding] == Gadgetron::ISMRMRD_interleaved) || (calib_mode_[encoding] == Gadgetron::ISMRMRD_noacceleration))
{
E1 = 2 * std::max(cE1 - sE1, eE1 - cE1+1);
if (E1>recon_E1) E1 = recon_E1;
if (E2 > 1)
{
E2 = 2 * std::max(cE2 - sE2, eE2 - cE2 + 1);
if (E2 > recon_E2) E2 = recon_E2;
}
}
ref_coil_map.create(RO, E1, E2, CHA, N, S, SLC);
Gadgetron::clear(ref_coil_map);
size_t slc, s, n, cha, e2, e1;
for (slc = 0; slc < SLC; slc++)
{
for (s = 0; s < S; s++)
{
for (n = 0; n < N; n++)
{
for (cha = 0; cha < CHA; cha++)
{
for (e2 = sE2; e2 <= eE2; e2++)
{
for (e1 = sE1; e1 <= eE1; e1++)
{
std::complex<float>* pSrc = &(ref_data(0, e1-sE1, e2-sE2, cha, n, s, slc));
std::complex<float>* pDst = &(ref_coil_map(0, e1, e2, cha, n, s, slc));
memcpy(pDst + sRO, pSrc, sizeof(std::complex<float>)*(eRO - sRO + 1));
}
}
}
}
}
}
// filter the ref_coil_map
if (filter_RO_ref_coi_map_.get_size(0) != RO)
{
Gadgetron::generate_symmetric_filter_ref(ref_coil_map.get_size(0), ref_.sampling_.sampling_limits_[0].min_, ref_.sampling_.sampling_limits_[0].max_, filter_RO_ref_coi_map_);
}
if (filter_E1_ref_coi_map_.get_size(0) != E1)
{
Gadgetron::generate_symmetric_filter_ref(ref_coil_map.get_size(1), ref_.sampling_.sampling_limits_[1].min_, ref_.sampling_.sampling_limits_[1].max_, filter_E1_ref_coi_map_);
}
if ( (E2 > 1) && (filter_E2_ref_coi_map_.get_size(0) != E2) )
{
Gadgetron::generate_symmetric_filter_ref(ref_coil_map.get_size(2), ref_.sampling_.sampling_limits_[2].min_, ref_.sampling_.sampling_limits_[2].max_, filter_E2_ref_coi_map_);
}
hoNDArray< std::complex<float> > ref_recon_buf;
if (E2 > 1)
{
Gadgetron::apply_kspace_filter_ROE1E2(ref_coil_map, filter_RO_ref_coi_map_, filter_E1_ref_coi_map_, filter_E2_ref_coi_map_, ref_recon_buf);
}
else
{
Gadgetron::apply_kspace_filter_ROE1(ref_coil_map, filter_RO_ref_coi_map_, filter_E1_ref_coi_map_, ref_recon_buf);
}
// pad the ref_coil_map into the data array
Gadgetron::pad(recon_RO, recon_E1, recon_E2, &ref_recon_buf, &ref_coil_map);
std::vector<size_t> dim = *ref_data.get_dimensions();
ref_calib.create(dim, ref_data.begin());
}
catch (...)
{
GADGET_THROW("Errors happened in MultiChannelCartesianGrappaReconGadget::make_ref_coil_map(...) ... ");
}
}
void GenericReconCartesianFFTGadget::perform_fft_combine(IsmrmrdReconBit& recon_bit, ReconObjType& recon_obj, size_t e)
{
try
{
typedef std::complex<float> T;
size_t RO = recon_bit.data_.data_.get_size(0);
size_t E1 = recon_bit.data_.data_.get_size(1);
size_t E2 = recon_bit.data_.data_.get_size(2);
size_t dstCHA = recon_bit.data_.data_.get_size(3);
size_t N = recon_bit.data_.data_.get_size(4);
size_t S = recon_bit.data_.data_.get_size(5);
size_t SLC = recon_bit.data_.data_.get_size(6);
hoNDArray< std::complex<float> >& src = recon_obj.ref_calib_;
size_t ref_RO = src.get_size(0);
size_t ref_E1 = src.get_size(1);
size_t ref_E2 = src.get_size(2);
size_t srcCHA = src.get_size(3);
size_t ref_N = src.get_size(4);
size_t ref_S = src.get_size(5);
size_t ref_SLC = src.get_size(6);
recon_obj.recon_res_.data_.create(RO, E1, E2, 1, N, S, SLC);
if (!debug_folder_full_path_.empty())
{
std::stringstream os;
os << "encoding_" << e;
std::string suffix = os.str();
gt_exporter_.export_array_complex(recon_bit.data_.data_, debug_folder_full_path_ + "data_src_" + suffix);
}
// compute aliased images
data_recon_buf_.create(RO, E1, E2, dstCHA, N, S, SLC);
if (E2>1)
{
Gadgetron::hoNDFFT<float>::instance()->ifft3c(recon_bit.data_.data_, complex_im_recon_buf_, data_recon_buf_);
}
else
{
Gadgetron::hoNDFFT<float>::instance()->ifft2c(recon_bit.data_.data_, complex_im_recon_buf_, data_recon_buf_);
}
if (!debug_folder_full_path_.empty())
{
std::stringstream os;
os << "encoding_" << e;
std::string suffix = os.str();
gt_exporter_.export_array_complex(complex_im_recon_buf_, debug_folder_full_path_ + "aliasedIm_" + suffix);
}
// combine channels
recon_obj.recon_res_.data_.create(RO, E1, E2, 1, N, S, SLC);
Gadgetron::sum_over_dimension(complex_im_recon_buf_, recon_obj.recon_res_.data_, 3);
}
catch (...)
{
GADGET_THROW("Errors happened in GenericReconCartesianFFTGadget::perform_fft_combine(...) ... ");
}
}