Point test_long_array(size_t num, size_t size)
{
void* compar = &compar_long;
long* arri1 = random_long_array(num);
long* arri2 = (long*)duplicate_array(arri1, num, size);
return run(arri1, arri2, num, size, compar);
}
Point test_Point_array(size_t num, size_t size)
{
void* compar = &compar_point;
Point* arri1 = random_point_array(num);
Point* arri2 = (Point*)duplicate_array(arri1, num, size);
return run(arri1, arri2, num, size, compar);
}
Point test_double_array(size_t num, size_t size)
{
void* compar = &compar_double;
double* arri1 = random_double_array(num);
double* arri2 = (double*)duplicate_array(arri1, num, size);
return run(arri1, arri2, num, size, compar);
}
Point test_float_array(size_t num, size_t size)
{
void* compar = &compar_float;
float* arri1 = random_float_array(num);
float* arri2 = (float*)duplicate_array(arri1, num, size);
return run(arri1, arri2, num, size, compar);
}
Point run(void* arri_1, void* arri_2, size_t num, size_t size, int (*compar) (const void*, const void*))
{
clock_t start;
//assert(are_equal(arri_1, arri_2, num, size, compar));
clock_t difference; clock_t difference_std;
start = clock();
qsort(arri_2, num, size, compar);
difference_std = clock() - start;
//assert(!is_ordered(arri_2, num, size, compar));
//time the standard library
start = clock();
my_qsort(arri_1, num, size, compar);
difference = clock() - start;
//we're just testing for speed now
//print_int_array(arri_1, num);
//print_int_array(arri_2, num);
assert(are_equal(arri_1, arri_2, num, size, compar));
free(arri_1); free(arri_2);
Point p = { .x = difference * 1000/CLOCKS_PER_SEC, .y = difference_std * 1000/CLOCKS_PER_SEC};
return p;
}
Point test_int_array(size_t num, size_t size)
{
void* compar = &compar_int;
int* arri_1 = random_int_array(num);
int* arri_2 = (int*) duplicate_array(arri_1, num, size);
return run(arri_1, arri_2, num, size, compar);
}
double test_array(void* arri_1, size_t num, size_t size, int (*compar) (const void*, const void*))
{
void* arri_2 = duplicate_array(arri_1, num, size);
clock_t difference;
clock_t start = clock();
my_qsort(arri_1, num, size, compar);
difference = clock() - start;
//clock_t start = clock();
qsort(arri_2, num, size, compar);
//difference = clock() - start;
assert(are_equal(arri_1, arri_2, num, size, compar));
free(arri_2);
return difference * 1000/CLOCKS_PER_SEC;
}
void main()
{
int number;
int array[100];
int n;
printf("\n Input the number of elements in the list: ");
scanf("%d", &number);
input(array, number);
printf("\n Entered list is as follows:\n");
display(array,number);
n = duplicate_array(array,number);
printf("\nNumber of duplicate elements in the list are: %d", n);
printf("\nAfter removing duplicates from the list, the list is as follows:");
display(array,number-n);
}
int NFFT2DGadget::process(GadgetContainerMessage< ISMRMRD::AcquisitionHeader > *m1, // header
GadgetContainerMessage< hoNDArray< std::complex<float> > > *m2, // data
GadgetContainerMessage< hoNDArray<float> > *m3 ) // traj/dcw
{
// Throw away any noise samples if they have been allowed to pass this far down the chain...
//
bool is_noise = m1->getObjectPtr()->isFlagSet(ISMRMRD::ISMRMRD_ACQ_IS_NOISE_MEASUREMENT);
if (is_noise) {
m1->release();
return GADGET_OK;
}
// First pass initialization
//
if (frame_readout_queue_->message_count() == 0 ) {
samples_per_readout_ = m1->getObjectPtr()->number_of_samples;
num_coils_ = m1->getObjectPtr()->active_channels;
dimensions_.push_back(m1->getObjectPtr()->active_channels);
dimensions_.push_back(repetitions_);
num_trajectory_dims_ = m3->getObjectPtr()->get_size(0); // 2 for trajectories only, 3 for both trajectories + dcw
}
int samples = m1->getObjectPtr()->number_of_samples;
int readout = m1->getObjectPtr()->idx.kspace_encode_step_1;
int repetition = m1->getObjectPtr()->idx.kspace_encode_step_2;
// Enqueue incoming readouts and trajectories
//
frame_readout_queue_->enqueue_tail(duplicate_array(m2));
frame_traj_queue_->enqueue_tail(duplicate_array(m3));
// If the last readout for a slice has arrived then perform a reconstruction
//
bool is_last_scan_in_repetition =
m1->getObjectPtr()->isFlagSet(ISMRMRD::ISMRMRD_ACQ_LAST_IN_REPETITION);
if (is_last_scan_in_repetition) {
// Define the image header
//
GadgetContainerMessage<ISMRMRD::ImageHeader> *cm1 =
new GadgetContainerMessage<ISMRMRD::ImageHeader>();
GadgetContainerMessage< hoNDArray< std::complex<float> > > *cm2 =
new GadgetContainerMessage<hoNDArray< std::complex<float> > >();
cm1->getObjectPtr()->flags = 0;
cm1->cont(cm2);
cm1->getObjectPtr()->matrix_size[0] = dimensions_[0];
cm1->getObjectPtr()->matrix_size[1] = dimensions_[1];
cm1->getObjectPtr()->matrix_size[2] = 1;
cm1->getObjectPtr()->field_of_view[0] = field_of_view_[0];
cm1->getObjectPtr()->field_of_view[1] = field_of_view_[1];
cm1->getObjectPtr()->channels = num_coils_;
cm1->getObjectPtr()->repetition = m1->getObjectPtr()->idx.repetition;
memcpy(cm1->getObjectPtr()->position,
m1->getObjectPtr()->position,
sizeof(float)*3);
memcpy(cm1->getObjectPtr()->read_dir,
m1->getObjectPtr()->read_dir,
sizeof(float)*3);
memcpy(cm1->getObjectPtr()->phase_dir,
m1->getObjectPtr()->phase_dir,
sizeof(float)*3);
memcpy(cm1->getObjectPtr()->slice_dir,
m1->getObjectPtr()->slice_dir,
sizeof(float)*3);
memcpy(cm1->getObjectPtr()->patient_table_position,
m1->getObjectPtr()->patient_table_position, sizeof(float)*3);
cm1->getObjectPtr()->data_type = ISMRMRD::ISMRMRD_CXFLOAT;
cm1->getObjectPtr()->image_index = 0;
cm1->getObjectPtr()->image_series_index = 0;
//
// Perform reconstruction of repetition
//
// Get samples for frame
//
cuNDArray<float_complext> samples( extract_samples_from_queue( frame_readout_queue_.get()).get() );
// Get trajectories/dcw for frame
//
boost::shared_ptr< cuNDArray<floatd2> > traj(new cuNDArray<floatd2>);
boost::shared_ptr<cuNDArray<float> > dcw(new cuNDArray<float>);
extract_trajectory_and_dcw_from_queue( frame_traj_queue_.get(), traj.get(), dcw.get() );
//traj = compute_radial_trajectory_golden_ratio_2d<float>(samples_per_readout_,dimensions_[1],1,0,GR_ORIGINAL);
unsigned int num_profiles = samples.get_number_of_elements()/samples_per_readout_;
dcw = compute_radial_dcw_golden_ratio_2d<float>(samples_per_readout_,num_profiles,1.0,1.0f/samples_per_readout_/num_profiles,0,GR_ORIGINAL);
// Create output array
//
std::vector<size_t> img_dims(2);
img_dims[0] = dimensions_[0];
img_dims[1] = dimensions_[1];
cm2->getObjectPtr()->create(&img_dims);
cuNDArray<float_complext> image(&img_dims);
// Initialize plan
//
const float kernel_width = 5.5f;
cuNFFT_plan<float,2> plan( from_std_vector<size_t,2>(img_dims), from_std_vector<size_t,2>(img_dims)<<1, kernel_width );
plan.preprocess( traj.get(), cuNFFT_plan<float,2>::NFFT_PREP_NC2C );
/*
if( dcw->get_number_of_elements() == 0 ){
std::vector<size_t> dcw_dims; dcw_dims.push_back(samples_per_readout_);
hoNDArray<float> host_dcw( dcw_dims );
for( int i=0; i<(int)dcw_dims[0]; i++ )
host_dcw.get_data_ptr()[i]=abs(i-(int)dcw_dims[0]/2);
host_dcw.get_data_ptr()[dcw_dims[0]/2] = 0.25f; // ad hoc value (we do not want a DC component of 0)
dcw = expand(&host_dcw, traj->get_number_of_elements()/samples_per_readout_);
}
*/
// Gridder
//
plan.compute( &samples, &image,
(dcw->get_number_of_elements()>0) ? dcw.get() : 0x0,
cuNFFT_plan<float,2>::NFFT_BACKWARDS_NC2C );
// Download to host
//
image.to_host( (hoNDArray<float_complext>*)cm2->getObjectPtr() );
// Pass on data down the gadget chain
//
if (this->next()->putq(cm1) < 0) {
return GADGET_FAIL;
}
}
m1->release();
return GADGET_OK;
}
