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