void GenericReconCartesianGrappaGadget::compute_snr_map(ReconObjType &recon_obj,
hoNDArray<std::complex<float> > &snr_map) {
typedef std::complex<float> T;
snr_map = recon_obj.recon_res_.data_;
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);
size_t gN = recon_obj.gfactor_.get_size(4);
size_t gS = recon_obj.gfactor_.get_size(5);
GADGET_CHECK_THROW(recon_obj.gfactor_.get_size(0) == RO);
GADGET_CHECK_THROW(recon_obj.gfactor_.get_size(1) == E1);
GADGET_CHECK_THROW(recon_obj.gfactor_.get_size(2) == E2);
GADGET_CHECK_THROW(recon_obj.gfactor_.get_size(3) == CHA);
GADGET_CHECK_THROW(recon_obj.gfactor_.get_size(6) == SLC);
size_t n, s, slc;
for (slc = 0; slc < SLC; slc++) {
for (s = 0; s < S; s++) {
size_t usedS = s;
if (usedS >= gS) usedS = gS - 1;
for (n = 0; n < N; n++) {
size_t usedN = n;
if (usedN >= gN) usedN = gN - 1;
float *pG = &(recon_obj.gfactor_(0, 0, 0, 0, usedN, usedS, slc));
T *pIm = &(recon_obj.recon_res_.data_(0, 0, 0, 0, n, s, slc));
T *pSNR = &(snr_map(0, 0, 0, 0, n, s, slc));
for (size_t ii = 0; ii < RO * E1 * E2 * CHA; ii++) {
pSNR[ii] = pIm[ii] / pG[ii];
}
}
}
}
}
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 GenericReconCartesianGrappaGadget::perform_unwrapping(IsmrmrdReconBit &recon_bit, ReconObjType &recon_obj,
size_t e) {
typedef std::complex<float> T;
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);
size_t unmixingCoeff_CHA = recon_obj.unmixing_coeff_.get_size(3);
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);
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_);
}
// SNR unit scaling
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) {
// since the grappa in gadgetron is doing signal preserving scaling, to perserve noise level, we need this compensation factor
double grappaKernelCompensationFactor = 1.0 / (acceFactorE1_[e] * acceFactorE2_[e]);
Gadgetron::scal((float) (grappaKernelCompensationFactor * snr_scaling_ratio), complex_im_recon_buf_);
if (this->verbose.value()) GDEBUG_STREAM(
"GenericReconCartesianGrappaGadget, grappaKernelCompensationFactor*snr_scaling_ratio : "
<< grappaKernelCompensationFactor * snr_scaling_ratio);
}
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);
}
// 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, unmixingCoeff_CHA, 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));
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));
T *pRes = &(recon_obj.recon_res_.data_(0, 0, 0, 0, n, s, slc));
hoNDArray<std::complex<float> > res(RO, E1, E2, 1, pRes);
hoNDArray<std::complex<float> > unmixing(RO, E1, E2, unmixingCoeff_CHA, pUnmix);
hoNDArray<std::complex<float> > aliasedIm(RO, E1, E2,
((unmixingCoeff_CHA <= srcCHA) ? unmixingCoeff_CHA : srcCHA),
1, pIm);
Gadgetron::apply_unmix_coeff_aliased_image_3D(aliasedIm, unmixing, res);
}
}
if (!debug_folder_full_path_.empty()) {
std::stringstream os;
os << "encoding_" << e;
std::string suffix = os.str();
gt_exporter_.export_array_complex(recon_obj.recon_res_.data_,
debug_folder_full_path_ + "unwrappedIm_" + suffix);
}
}
void
GenericReconCartesianGrappaGadget::perform_calib(IsmrmrdReconBit &recon_bit, ReconObjType &recon_obj, size_t e) {
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_dst_;
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);
bool fitItself = this->downstream_coil_compression.value();
if (E2 > 1) {
std::vector<int> kE1, oE1;
std::vector<int> kE2, oE2;
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;
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;
// only allow this for loop openmp if num>1 and 2D recon
#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, fitItself) 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)));
if (fitItself)
{
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);
}
else
{
Gadgetron::grappa3d_calib_convolution_kernel(ref_src, ref_src, (size_t)acceFactorE1_[e],
(size_t)acceFactorE2_[e], grappa_reg_lamda.value(),
grappa_calib_over_determine_ratio.value(), kRO, kNE1,
kNE2, ker);
}
//if (!debug_folder_full_path_.empty())
//{
// gt_exporter_.export_array_complex(ker, debug_folder_full_path_ + "convKer3D_" + suffix);
//}
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);
//if (!debug_folder_full_path_.empty())
//{
// gt_exporter_.export_array_complex(unmixC, debug_folder_full_path_ + "unmixC_3D_" + suffix);
//}
//if (!debug_folder_full_path_.empty())
//{
// gt_exporter_.export_array(gFactor, debug_folder_full_path_ + "gFactor_3D_" + suffix);
//}
} 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)));
if (fitItself)
{
Gadgetron::grappa2d_calib_convolution_kernel(acsSrc, acsDst, (size_t)acceFactorE1_[e],
grappa_reg_lamda.value(), kRO, kNE1, convKer);
}
else
{
Gadgetron::grappa2d_calib_convolution_kernel(acsSrc, acsSrc, (size_t)acceFactorE1_[e],
grappa_reg_lamda.value(), kRO, kNE1, convKer);
}
Gadgetron::grappa2d_image_domain_kernel(convKer, RO, E1, kIm);
/*if (!debug_folder_full_path_.empty())
{
gt_exporter_.export_array_complex(convKer, debug_folder_full_path_ + "convKer_" + suffix);
}
if (!debug_folder_full_path_.empty())
{
gt_exporter_.export_array_complex(kIm, debug_folder_full_path_ + "kIm_" + suffix);
}*/
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());
/*if (!debug_folder_full_path_.empty())
{
gt_exporter_.export_array_complex(unmixC, debug_folder_full_path_ + "unmixC_" + suffix);
}
if (!debug_folder_full_path_.empty())
{
gt_exporter_.export_array(gFactor, debug_folder_full_path_ + "gFactor_" + suffix);
}*/
}
// -----------------------------------
}
}
}
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(...) ... ");
}
}
