void callback(const sensor_msgs::ImageConstPtr& img_msg, const sensor_msgs::ImageConstPtr& depth_msg) { // Convert images to OpenCV format cv::Mat input_frame; cv::Mat depth_frame; cv_bridge::CvImagePtr input_cv_ptr = cv_bridge::toCvCopy(img_msg, sensor_msgs::image_encodings::BGR8); cv_bridge::CvImagePtr depth_cv_ptr = cv_bridge::toCvCopy(depth_msg); input_frame = input_cv_ptr->image; depth_frame = depth_cv_ptr->image; ROS_INFO_STREAM("input_frame.type()" << input_frame.type()); cv::imshow("input_frame", input_frame); cv::imshow("depth_frame", depth_frame); cv::cvtColor(input_frame, input_frame, CV_RGB2BGR); // Save frames to disk cv::Mat depth_to_save(input_frame.size(), CV_16UC1); std::vector<int> params; params.push_back(CV_IMWRITE_PNG_COMPRESSION); params.push_back(0); for (int r = 0; r < depth_frame.rows; ++r) { for (int c = 0; c < depth_frame.cols; ++c) { if (isnan(depth_frame.at<float>(r,c))) depth_frame.at<float>(r,c) = 0.0; } } ROS_INFO_STREAM("Removed NaNs"); #ifdef SAVE_IMAGES std::stringstream intensity_name; intensity_name << "/home/thermans/Desktop/intensity" << img_count_ << ".png"; std::stringstream depth_name; depth_name << "/home/thermans/Desktop/depth" << img_count_++ << ".png"; depth_frame.convertTo(depth_to_save, depth_to_save.type(), 512.0); cv::imwrite(intensity_name.str(), input_frame, params); cv::imwrite(depth_name.str(), depth_to_save, params); ROS_INFO_STREAM("Saved images"); #endif // SAVE_IMAGES ROS_INFO_STREAM("Scaling image"); cv::Mat scaled_depth = depth_frame.clone(); cv::Mat scaled_depth_frame = csm.scaleMap(depth_frame); cv::imshow("scaled_frame", scaled_depth_frame); scaled_depth_frame.convertTo(scaled_depth, CV_32FC1); ROS_INFO_STREAM("Running saliency"); cv::Mat saliency_map = csm(input_frame, scaled_depth); // cv::Mat saliency_map = csm(input_frame, depth_frame); double min_val = 0; double max_val = 0; cv::minMaxLoc(saliency_map, &min_val, &max_val); ROS_INFO_STREAM("Minimum saliency unscaled: " << min_val << "\tmax: " << max_val); cv::imshow("unsaceled saliency", saliency_map); cv::waitKey(); }
void test2() { ses::EntityManager::Ptr sem = std::shared_ptr<ses::EntityManager>(new ServerEntityManager()); ses::SystemManager ssm(sem); ssm.addSystem<RenderSystem>(); ses::EntityManager::Ptr cem = std::shared_ptr<ses::EntityManager>(new ClientEntityManager()); ses::SystemManager csm(cem); csm.addSystem<RenderSystem>(); csm.addSystem<InputSystem>(); sf::RenderWindow wS(sf::VideoMode(500,500),"Server"); wS.setPosition({100,100}); sf::RenderWindow wC(sf::VideoMode(500,500),"Client"); wC.setPosition({700,100}); sem->usePrefab("Sprite"); sf::Clock clock; bool run = true; while (run) { sf::Event e; while (wS.pollEvent(e)) { if (e.type == sf::Event::Closed) { run = false; } } while (wC.pollEvent(e)) { if (e.type == sf::Event::Closed) { run = false; } } csm.getSystem<InputSystem>().update(clock.restart()); wS.clear(); ssm.getSystem<RenderSystem>().render(wS); wS.display(); wC.clear(); csm.getSystem<RenderSystem>().render(wC); wC.display(); } wC.close(); wS.close(); }
void StringCaseTest::TestCasingImpl(const UnicodeString &input, const UnicodeString &output, int32_t whichCase, void *iter, const char *localeID, uint32_t options) { // UnicodeString UnicodeString result; const char *name; Locale locale(localeID); result=input; switch(whichCase) { case TEST_LOWER: name="toLower"; result.toLower(locale); break; case TEST_UPPER: name="toUpper"; result.toUpper(locale); break; #if !UCONFIG_NO_BREAK_ITERATION case TEST_TITLE: name="toTitle"; result.toTitle((BreakIterator *)iter, locale, options); break; #endif case TEST_FOLD: name="foldCase"; result.foldCase(options); break; default: name=""; break; // won't happen } if(result!=output) { dataerrln("error: UnicodeString.%s() got a wrong result for a test case from casing.res", name); } #if !UCONFIG_NO_BREAK_ITERATION if(whichCase==TEST_TITLE && options==0) { result=input; result.toTitle((BreakIterator *)iter, locale); if(result!=output) { dataerrln("error: UnicodeString.toTitle(options=0) got a wrong result for a test case from casing.res"); } } #endif // UTF-8 char utf8In[100], utf8Out[100]; int32_t utf8InLength, utf8OutLength, resultLength; UChar *buffer; IcuTestErrorCode errorCode(*this, "TestCasingImpl"); LocalUCaseMapPointer csm(ucasemap_open(localeID, options, errorCode)); #if !UCONFIG_NO_BREAK_ITERATION if(iter!=NULL) { // Clone the break iterator so that the UCaseMap can safely adopt it. UBreakIterator *clone=ubrk_safeClone((UBreakIterator *)iter, NULL, NULL, errorCode); ucasemap_setBreakIterator(csm.getAlias(), clone, errorCode); } #endif u_strToUTF8(utf8In, (int32_t)sizeof(utf8In), &utf8InLength, input.getBuffer(), input.length(), errorCode); switch(whichCase) { case TEST_LOWER: name="ucasemap_utf8ToLower"; utf8OutLength=ucasemap_utf8ToLower(csm.getAlias(), utf8Out, (int32_t)sizeof(utf8Out), utf8In, utf8InLength, errorCode); break; case TEST_UPPER: name="ucasemap_utf8ToUpper"; utf8OutLength=ucasemap_utf8ToUpper(csm.getAlias(), utf8Out, (int32_t)sizeof(utf8Out), utf8In, utf8InLength, errorCode); break; #if !UCONFIG_NO_BREAK_ITERATION case TEST_TITLE: name="ucasemap_utf8ToTitle"; utf8OutLength=ucasemap_utf8ToTitle(csm.getAlias(), utf8Out, (int32_t)sizeof(utf8Out), utf8In, utf8InLength, errorCode); break; #endif case TEST_FOLD: name="ucasemap_utf8FoldCase"; utf8OutLength=ucasemap_utf8FoldCase(csm.getAlias(), utf8Out, (int32_t)sizeof(utf8Out), utf8In, utf8InLength, errorCode); break; default: name=""; utf8OutLength=0; break; // won't happen } buffer=result.getBuffer(utf8OutLength); u_strFromUTF8(buffer, result.getCapacity(), &resultLength, utf8Out, utf8OutLength, errorCode); result.releaseBuffer(errorCode.isSuccess() ? resultLength : 0); if(errorCode.isFailure()) { errcheckln(errorCode, "error: %s() got an error for a test case from casing.res - %s", name, u_errorName(errorCode)); errorCode.reset(); } else if(result!=output) { errln("error: %s() got a wrong result for a test case from casing.res", name); errln("expected \"" + output + "\" got \"" + result + "\"" ); } }
int gpuCgSpiritGadget::process(GadgetContainerMessage<ISMRMRD::ImageHeader> *m1, GadgetContainerMessage<GenericReconJob> *m2) { // Is this data for this gadget's set/slice? // if( m1->getObjectPtr()->set != set_number_ || m1->getObjectPtr()->slice != slice_number_ ) { // No, pass it downstream... return this->next()->putq(m1); } //GDEBUG("gpuCgSpiritGadget::process\n"); boost::shared_ptr<GPUTimer> process_timer; if( output_timing_ ) process_timer = boost::shared_ptr<GPUTimer>( new GPUTimer("gpuCgSpiritGadget::process()") ); if (!is_configured_) { GDEBUG("Data received before configuration was completed\n"); return GADGET_FAIL; } GenericReconJob* j = m2->getObjectPtr(); // Some basic validation of the incoming Spirit job if (!j->csm_host_.get() || !j->dat_host_.get() || !j->tra_host_.get() || !j->dcw_host_.get() || !j->reg_host_.get()) { GDEBUG("Received an incomplete Spirit job\n"); return GADGET_FAIL; } unsigned int samples = j->dat_host_->get_size(0); unsigned int channels = j->dat_host_->get_size(1); unsigned int rotations = samples / j->tra_host_->get_number_of_elements(); unsigned int frames = j->tra_host_->get_size(1)*rotations; if( samples%j->tra_host_->get_number_of_elements() ) { GDEBUG("Mismatch between number of samples (%d) and number of k-space coordinates (%d).\nThe first should be a multiplum of the latter.\n", samples, j->tra_host_->get_number_of_elements()); return GADGET_FAIL; } boost::shared_ptr< cuNDArray<floatd2> > traj(new cuNDArray<floatd2> (j->tra_host_.get())); boost::shared_ptr< cuNDArray<float> > dcw(new cuNDArray<float> (j->dcw_host_.get())); sqrt_inplace(dcw.get()); //Take square root to use for weighting boost::shared_ptr< cuNDArray<float_complext> > csm(new cuNDArray<float_complext> (j->csm_host_.get())); boost::shared_ptr< cuNDArray<float_complext> > device_samples(new cuNDArray<float_complext> (j->dat_host_.get())); cudaDeviceProp deviceProp; if( cudaGetDeviceProperties( &deviceProp, device_number_ ) != cudaSuccess) { GDEBUG( "Error: unable to query device properties.\n" ); return GADGET_FAIL; } unsigned int warp_size = deviceProp.warpSize; matrix_size_ = uint64d2( j->reg_host_->get_size(0), j->reg_host_->get_size(1) ); matrix_size_os_ = uint64d2(((static_cast<unsigned int>(std::ceil(matrix_size_[0]*oversampling_factor_))+warp_size-1)/warp_size)*warp_size, ((static_cast<unsigned int>(std::ceil(matrix_size_[1]*oversampling_factor_))+warp_size-1)/warp_size)*warp_size); if( !matrix_size_reported_ ) { GDEBUG("Matrix size : [%d,%d] \n", matrix_size_[0], matrix_size_[1]); GDEBUG("Matrix size OS : [%d,%d] \n", matrix_size_os_[0], matrix_size_os_[1]); matrix_size_reported_ = true; } std::vector<size_t> image_dims = to_std_vector(matrix_size_); image_dims.push_back(frames); image_dims.push_back(channels); GDEBUG("Number of coils: %d %d \n",channels,image_dims.size()); E_->set_domain_dimensions(&image_dims); E_->set_codomain_dimensions(device_samples->get_dimensions().get()); E_->set_dcw(dcw); E_->setup( matrix_size_, matrix_size_os_, static_cast<float>(kernel_width_) ); E_->preprocess(traj.get()); boost::shared_ptr< cuNDArray<float_complext> > csm_device( new cuNDArray<float_complext>( csm.get() )); S_->set_calibration_kernels(csm_device); S_->set_domain_dimensions(&image_dims); S_->set_codomain_dimensions(&image_dims); /* boost::shared_ptr< cuNDArray<float_complext> > reg_image(new cuNDArray<float_complext> (j->reg_host_.get())); R_->compute(reg_image.get()); // Define preconditioning weights boost::shared_ptr< cuNDArray<float> > _precon_weights = sum(abs_square(csm.get()).get(), 2); boost::shared_ptr<cuNDArray<float> > R_diag = R_->get(); *R_diag *= float(kappa_); *_precon_weights += *R_diag; R_diag.reset(); reciprocal_sqrt_inplace(_precon_weights.get()); boost::shared_ptr< cuNDArray<float_complext> > precon_weights = real_to_complex<float_complext>( _precon_weights.get() ); _precon_weights.reset(); D_->set_weights( precon_weights ); */ /*{ static int counter = 0; char filename[256]; sprintf((char*)filename, "_traj_%d.real", counter); write_nd_array<floatd2>( traj->to_host().get(), filename ); sprintf((char*)filename, "_dcw_%d.real", counter); write_nd_array<float>( dcw->to_host().get(), filename ); sprintf((char*)filename, "_csm_%d.cplx", counter); write_nd_array<float_complext>( csm->to_host().get(), filename ); sprintf((char*)filename, "_samples_%d.cplx", counter); write_nd_array<float_complext>( device_samples->to_host().get(), filename ); sprintf((char*)filename, "_reg_%d.cplx", counter); write_nd_array<float_complext>( reg_image->to_host().get(), filename ); counter++; }*/ // Invoke solver // boost::shared_ptr< cuNDArray<float_complext> > cgresult; { boost::shared_ptr<GPUTimer> solve_timer; if( output_timing_ ) solve_timer = boost::shared_ptr<GPUTimer>( new GPUTimer("gpuCgSpiritGadget::solve()") ); cgresult = cg_.solve(device_samples.get()); if( output_timing_ ) solve_timer.reset(); } if (!cgresult.get()) { GDEBUG("Iterative_spirit_compute failed\n"); return GADGET_FAIL; } /* static int counter = 0; char filename[256]; sprintf((char*)filename, "recon_%d.real", counter); write_nd_array<float>( abs(cgresult.get())->to_host().get(), filename ); counter++; */ // If the recon matrix size exceeds the sequence matrix size then crop if( matrix_size_seq_ != matrix_size_ ) cgresult = crop<float_complext,2>( (matrix_size_-matrix_size_seq_)>>1, matrix_size_seq_, cgresult.get() ); // Combine coil images // cgresult = real_to_complex<float_complext>(sqrt(sum(abs_square(cgresult.get()).get(), 3).get()).get()); // RSS //cgresult = sum(cgresult.get(), 2); // Pass on the reconstructed images // put_frames_on_que(frames,rotations,j,cgresult.get()); frame_counter_ += frames; if( output_timing_ ) process_timer.reset(); m1->release(); return GADGET_OK; }
/* Analyses function; done when cuc command is entered in (sim) prompt */ cuc_func * analyse_function (char *module_name, long orig_time, unsigned long start_addr, unsigned long end_addr, int memory_order, int num_runs) { cuc_timings timings; cuc_func *func = (cuc_func *) malloc (sizeof (cuc_func)); cuc_func *saved; int b, i, j; char tmp1[256]; char tmp2[256]; func->orig_time = orig_time; func->start_addr = start_addr; func->end_addr = end_addr; func->memory_order = memory_order; func->nfdeps = 0; func->fdeps = NULL; func->num_runs = num_runs; sprintf (tmp1, "%s.bin", module_name); cucdebug (2, "Loading %s.bin\n", module_name); if (cuc_load (tmp1)) { free (func); return NULL; } log ("Detecting basic blocks\n"); detect_bb (func); if (cuc_debug >= 2) print_cuc_insns ("WITH_BB_LIMITS", 0); //sprintf (tmp1, "%s.bin.mp", module_name); sprintf (tmp2, "%s.bin.bb", module_name); generate_bb_seq (func, config.sim.mprof_fn, tmp2); log ("Assuming %i clk cycle load (%i cyc burst)\n", runtime.cuc.mdelay[0], runtime.cuc.mdelay[2]); log ("Assuming %i clk cycle store (%i cyc burst)\n", runtime.cuc.mdelay[1], runtime.cuc.mdelay[3]); build_bb (func); if (cuc_debug >= 5) print_cuc_bb (func, "AFTER_BUILD_BB"); reg_dep (func); log ("Detecting dependencies\n"); if (cuc_debug >= 2) print_cuc_bb (func, "AFTER_REG_DEP"); cuc_optimize (func); #if 0 csm (func); #endif assert (saved = dup_func (func)); timings.preroll = timings.unroll = 1; timings.nshared = 0; add_latches (func); if (cuc_debug >= 1) print_cuc_bb (func, "AFTER_LATCHES"); analyse_timings (func, &timings); free_func (func); log ("Base option: pre%i,un%i,sha%i: %icyc %.1f\n", timings.preroll, timings.unroll, timings.nshared, timings.new_time, timings.size); saved->timings = timings; #if 1 /* detect and unroll simple loops */ for (b = 0; b < saved->num_bb; b++) { cuc_timings t[MAX_UNROLL * MAX_PREROLL]; cuc_timings *ut; cuc_timings *cut = &t[0]; int nt = 1; double csize; saved->bb[b].selected_tim = -1; /* Is it a loop? */ if (saved->bb[b].next[0] != b && saved->bb[b].next[1] != b) continue; log ("Found loop at BB%x. Trying to unroll.\n", b); t[0] = timings; t[0].b = b; t[0].preroll = 1; t[0].unroll = 1; t[0].nshared = 0; sprintf (tmp1, "%s.bin.bb", module_name); i = 1; do { cuc_timings *pt; cuc_timings *cpt = cut; j = 1; do { pt = cpt; cpt = preunroll_bb (tmp1, saved, &t[nt++], b, ++j, i); } while (j <= MAX_PREROLL && pt->new_time > cpt->new_time); i++; ut = cut; cut = preunroll_bb (tmp1, saved, &t[nt++], b, 1, i); } while (i <= MAX_UNROLL && ut->new_time > cut->new_time); /* Sort the timings */ #if 0 if (cuc_debug >= 3) for (i = 0; i < nt; i++) PRINTF ("%i:%i,%i: %icyc\n", t[i].b, t[i].preroll, t[i].unroll, t[i].new_time); #endif #if HAVE___COMPAR_FN_T qsort (t, nt, sizeof (cuc_timings), (__compar_fn_t) tim_comp); #else qsort (t, nt, sizeof (cuc_timings), (int (*) (const void *, const void *)) tim_comp); #endif /* Delete timings, that have worst time and bigger size than other */ j = 1; csize = t[0].size; for (i = 1; i < nt; i++) if (t[i].size < csize) t[j++] = t[i]; nt = j; cucdebug (1, "Available options\n"); for (i = 0; i < nt; i++) cucdebug (1, "%i:%i,%i: %icyc %.1f\n", t[i].b, t[i].preroll, t[i].unroll, t[i].new_time, t[i].size); /* Add results from CSM */ j = nt; for (i = 0; i < saved->bb[b].ntim; i++) { int i1; for (i1 = 0; i1 < nt; i1++) { t[j] = t[i1]; t[j].size += saved->bb[b].tim[i].size - timings.size; t[j].new_time += saved->bb[b].tim[i].new_time - timings.new_time; t[j].nshared = saved->bb[b].tim[i].nshared; t[j].shared = saved->bb[b].tim[i].shared; if (++j >= MAX_UNROLL * MAX_PREROLL) goto full; } } full: nt = j; cucdebug (1, "Available options:\n"); for (i = 0; i < nt; i++) cucdebug (1, "%i:%i,%i: %icyc %.1f\n", t[i].b, t[i].preroll, t[i].unroll, t[i].new_time, t[i].size); /* Sort again with new timings added */ #if HAVE___COMPAR_FN_T qsort (t, nt, sizeof (cuc_timings), (__compar_fn_t) tim_comp); #else qsort (t, nt, sizeof (cuc_timings), (int (*)(const void *, const void *)) tim_comp); #endif /* Delete timings, that have worst time and bigger size than other */ j = 1; csize = t[0].size; for (i = 1; i < nt; i++) if (t[i].size < csize) t[j++] = t[i]; nt = j; cucdebug (1, "Available options:\n"); for (i = 0; i < nt; i++) cucdebug (1, "%i:%i,%i: %icyc %.1f\n", t[i].b, t[i].preroll, t[i].unroll, t[i].new_time, t[i].size); if (saved->bb[b].ntim) free (saved->bb[b].tim); saved->bb[b].ntim = nt; assert (saved->bb[b].tim = (cuc_timings *) malloc (sizeof (cuc_timings) * nt)); /* Copy options in reverse order -- smallest first */ for (i = 0; i < nt; i++) saved->bb[b].tim[i] = t[nt - 1 - i]; log ("Available options:\n"); for (i = 0; i < saved->bb[b].ntim; i++) { log ("%i:pre%i,un%i,sha%i: %icyc %.1f\n", saved->bb[b].tim[i].b, saved->bb[b].tim[i].preroll, saved->bb[b].tim[i].unroll, saved->bb[b].tim[i].nshared, saved->bb[b].tim[i].new_time, saved->bb[b].tim[i].size); } } #endif return saved; }
int gpuOsSenseGadget::process(GadgetContainerMessage<ISMRMRD::ImageHeader> *m1, GadgetContainerMessage<GenericReconJob> *m2) { // Is this data for this gadget's set/slice? // GDEBUG("Starting gpuOsSenseGadget\n"); if( m1->getObjectPtr()->set != set_number_ || m1->getObjectPtr()->slice != slice_number_ ) { // No, pass it downstream... return this->next()->putq(m1); } //GDEBUG("gpuOsSenseGadget::process\n"); //GPUTimer timer("gpuOsSenseGadget::process"); if (!is_configured_) { GDEBUG("\nData received before configuration complete\n"); return GADGET_FAIL; } GenericReconJob* j = m2->getObjectPtr(); // Let's first check that this job has the required data... if (!j->csm_host_.get() || !j->dat_host_.get() || !j->tra_host_.get() || !j->dcw_host_.get()) { GDEBUG("Received an incomplete Sense job\n"); return GADGET_FAIL; } unsigned int samples = j->dat_host_->get_size(0); unsigned int channels = j->dat_host_->get_size(1); unsigned int rotations = samples / j->tra_host_->get_number_of_elements(); unsigned int frames = j->tra_host_->get_size(1)*rotations; if( samples%j->tra_host_->get_number_of_elements() ) { GDEBUG("Mismatch between number of samples (%d) and number of k-space coordinates (%d).\nThe first should be a multiplum of the latter.\n", samples, j->tra_host_->get_number_of_elements()); return GADGET_FAIL; } boost::shared_ptr< cuNDArray<floatd2> > traj(new cuNDArray<floatd2> (j->tra_host_.get())); boost::shared_ptr< cuNDArray<float> > dcw(new cuNDArray<float> (j->dcw_host_.get())); sqrt_inplace(dcw.get()); boost::shared_ptr< cuNDArray<float_complext> > csm(new cuNDArray<float_complext> (j->csm_host_.get())); boost::shared_ptr< cuNDArray<float_complext> > device_samples(new cuNDArray<float_complext> (j->dat_host_.get())); // Take the reconstruction matrix size from the regulariaztion image. // It could be oversampled from the sequence specified size... matrix_size_ = uint64d2( j->reg_host_->get_size(0), j->reg_host_->get_size(1) ); cudaDeviceProp deviceProp; if( cudaGetDeviceProperties( &deviceProp, device_number_ ) != cudaSuccess) { GDEBUG( "\nError: unable to query device properties.\n" ); return GADGET_FAIL; } unsigned int warp_size = deviceProp.warpSize; matrix_size_os_ = uint64d2(((static_cast<unsigned int>(std::ceil(matrix_size_[0]*oversampling_factor_))+warp_size-1)/warp_size)*warp_size, ((static_cast<unsigned int>(std::ceil(matrix_size_[1]*oversampling_factor_))+warp_size-1)/warp_size)*warp_size); GDEBUG("Matrix size : [%d,%d] \n", matrix_size_[0], matrix_size_[1]); GDEBUG("Matrix size OS : [%d,%d] \n", matrix_size_os_[0], matrix_size_os_[1]); std::vector<size_t> image_dims = to_std_vector(matrix_size_); image_dims.push_back(frames); E_->set_domain_dimensions(&image_dims); E_->set_codomain_dimensions(device_samples->get_dimensions().get()); E_->set_csm(csm); E_->setup( matrix_size_, matrix_size_os_, kernel_width_ ); E_->preprocess(traj.get()); { auto precon = boost::make_shared<cuNDArray<float_complext>>(image_dims); fill(precon.get(),float_complext(1.0f)); //solver_.set_preconditioning_image(precon); } reg_image_ = boost::shared_ptr< cuNDArray<float_complext> >(new cuNDArray<float_complext>(&image_dims)); // These operators need their domain/codomain set before being added to the solver // //E_->set_dcw(dcw); GDEBUG("Prepared\n"); // Expand the average image to the number of frames // { cuNDArray<float_complext> tmp(*j->reg_host_); *reg_image_ = expand( tmp, frames ); } PICS_->set_prior(reg_image_); // Define preconditioning weights // //Apply weights //*device_samples *= *dcw; // Invoke solver // boost::shared_ptr< cuNDArray<float_complext> > result; { GDEBUG("Running NLCG solver\n"); GPUTimer timer("Running NLCG solver"); // Optionally, allow exclusive (per device) access to the solver // This may not matter much in terms of speed, but it can in terms of memory consumption // if( exclusive_access_ ) _mutex[device_number_].lock(); result = solver_.solve(device_samples.get()); if( exclusive_access_ ) _mutex[device_number_].unlock(); } // Provide some info about the scaling between the regularization and reconstruction. // If it is not close to one, PICCS does not work optimally... // if( alpha_ > 0.0 ){ cuNDArray<float_complext> gpureg(j->reg_host_.get()); boost::shared_ptr< cuNDArray<float_complext> > gpurec = sum(result.get(),2); *gpurec /= float(result->get_size(2)); float scale = abs(dot(gpurec.get(), gpurec.get())/dot(gpurec.get(),&gpureg)); GDEBUG("Scaling factor between regularization and reconstruction is %f.\n", scale); } if (!result.get()) { GDEBUG("\nNon-linear conjugate gradient solver failed\n"); return GADGET_FAIL; } /* static int counter = 0; char filename[256]; sprintf((char*)filename, "recon_sb_%d.cplx", counter); write_nd_array<float_complext>( sbresult->to_host().get(), filename ); counter++; */ // If the recon matrix size exceeds the sequence matrix size then crop if( matrix_size_seq_ != matrix_size_ ) *result = crop<float_complext,2>( (matrix_size_-matrix_size_seq_)>>1, matrix_size_seq_, *result ); // Now pass on the reconstructed images // this->put_frames_on_que(frames,rotations,j,result.get(),channels); frame_counter_ += frames; m1->release(); return GADGET_OK; }