void write_int_data(std::string const& filename, array_2d_t const& array) { h5xx::file file(filename, h5xx::file::trunc); std::string name; // (1) create and write chunked and compressed dataset { name = "integer array"; std::vector<size_t> chunk_dims(2,2); // derive dataspace and datatype from the array internally h5xx::create_dataset(file, name, array , h5xx::policy::storage::chunked(chunk_dims) /* optional argument */ .add(h5xx::policy::filter::deflate()) ); h5xx::write_dataset(file, name, array); } // (2) create and write a dataset, using default settings, // explicitly derive dataspace and datatype from input arrray { name = "integer array, 2"; // construct dataspace from a Boost multi_array h5xx::dataspace dataspace = h5xx::create_dataspace(array); // pull datatype from a Boost multi_array h5xx::datatype datatype(array); h5xx::create_dataset(file, name, datatype, dataspace); h5xx::write_dataset(file, name, array); } }
// --- try various storage layouts and filters, integer void write_int_data_2(std::string const& filename, array_2d_t const& array) { h5xx::file file(filename, h5xx::file::out); std::string name; { name = "A -- integer array, compact"; h5xx::create_dataset(file, name, array , h5xx::policy::storage::compact() ); h5xx::write_dataset(file, name, array); } { name = "B -- integer array, contiguous"; h5xx::create_dataset(file, name, array , h5xx::policy::storage::contiguous() ); h5xx::write_dataset(file, name, array); } { name = "C -- integer array, compact, fill_value"; h5xx::create_dataset(file, name, array , h5xx::policy::storage::compact() .set(h5xx::policy::storage::fill_value(int(42))) ); // h5xx::write_dataset(file, name, array); } { name = "D -- integer array, compact, track_times"; h5xx::create_dataset(file, name, array , h5xx::policy::storage::compact() .set(h5xx::policy::storage::track_times()) ); h5xx::write_dataset(file, name, array); } { name = "E -- integer array, chunked, fill_value, deflate"; std::vector<size_t> chunk_dims(2,2); h5xx::create_dataset(file, name, array , h5xx::policy::storage::chunked(chunk_dims) .set(h5xx::policy::storage::fill_value(42)) .add(h5xx::policy::filter::deflate()) ); // h5xx::write_dataset(file, name, array); } { name = "F -- integer array, chunked, shuffle"; std::vector<size_t> chunk_dims(2,2); h5xx::create_dataset(file, name, array , h5xx::policy::storage::chunked(chunk_dims) .add(h5xx::policy::filter::shuffle()) ); h5xx::write_dataset(file, name, array); } { name = "G -- integer array, chunked, fletcher32"; std::vector<size_t> chunk_dims(2,2); h5xx::create_dataset(file, name, array , h5xx::policy::storage::chunked(chunk_dims) .add(h5xx::policy::filter::fletcher32()) ); h5xx::write_dataset(file, name, array); } { name = "H -- integer array, chunked, scaleoffset"; std::vector<size_t> chunk_dims(2,2); h5xx::create_dataset(file, name, array , h5xx::policy::storage::chunked(chunk_dims) .add(h5xx::policy::filter::scaleoffset<int>()) ); h5xx::write_dataset(file, name, array); } { name = "I -- integer array, chunked, nbit"; std::vector<size_t> chunk_dims(2,2); h5xx::create_dataset(file, name, array , h5xx::policy::storage::chunked(chunk_dims) .add(h5xx::policy::filter::nbit()) ); h5xx::write_dataset(file, name, array); } }
int SimpleReconGadget::process( GadgetContainerMessage<IsmrmrdReconData>* m1) { //Iterate over all the recon bits for(std::vector<IsmrmrdReconBit>::iterator it = m1->getObjectPtr()->rbit_.begin(); it != m1->getObjectPtr()->rbit_.end(); ++it) { //Grab a reference to the buffer containing the imaging data //We are ignoring the reference data IsmrmrdDataBuffered & dbuff = it->data_; //Data 7D, fixed order [E0, E1, E2, CHA, N, S, LOC] uint16_t E0 = dbuff.data_.get_size(0); uint16_t E1 = dbuff.data_.get_size(1); uint16_t E2 = dbuff.data_.get_size(2); uint16_t CHA = dbuff.data_.get_size(3); uint16_t N = dbuff.data_.get_size(4); uint16_t S = dbuff.data_.get_size(5); uint16_t LOC = dbuff.data_.get_size(6); //Create an image array message GadgetContainerMessage<IsmrmrdImageArray>* cm1 = new GadgetContainerMessage<IsmrmrdImageArray>(); //Grab references to the image array data and headers IsmrmrdImageArray & imarray = *cm1->getObjectPtr(); //The image array data will be [E0,E1,E2,1,N,S,LOC] big //Will collapse across coils at the end std::vector<size_t> data_dims(7); data_dims[0] = E0; data_dims[1] = E1; data_dims[2] = E2; data_dims[3] = 1; data_dims[4] = N; data_dims[5] = S; data_dims[6] = LOC; imarray.data_.create(&data_dims); //ImageHeaders will be [N, S, LOC] std::vector<size_t> header_dims(3); header_dims[0] = N; header_dims[1] = S; header_dims[2] = LOC; imarray.headers_.create(&header_dims); //We will not add any meta data //so skip the meta_ part //Loop over S and N and LOC for (uint16_t loc=0; loc < LOC; loc++) { for (uint16_t s=0; s < S; s++) { for (uint16_t n=0; n < N; n++) { //Set some information into the image header //Use the middle acquisition header for some info //[E1, E2, N, S, LOC] ISMRMRD::AcquisitionHeader & acqhdr = dbuff.headers_(dbuff.sampling_.sampling_limits_[1].center_, dbuff.sampling_.sampling_limits_[2].center_, n, s, loc); imarray.headers_(n,s,loc).matrix_size[0] = E0; imarray.headers_(n,s,loc).matrix_size[1] = E1; imarray.headers_(n,s,loc).matrix_size[2] = E2; imarray.headers_(n,s,loc).field_of_view[0] = dbuff.sampling_.recon_FOV_[0]; imarray.headers_(n,s,loc).field_of_view[1] = dbuff.sampling_.recon_FOV_[1]; imarray.headers_(n,s,loc).field_of_view[2] = dbuff.sampling_.recon_FOV_[2]; imarray.headers_(n,s,loc).channels = 1; imarray.headers_(n,s,loc).average = acqhdr.idx.average; imarray.headers_(n,s,loc).slice = acqhdr.idx.slice; imarray.headers_(n,s,loc).contrast = acqhdr.idx.contrast; imarray.headers_(n,s,loc).phase = acqhdr.idx.phase; imarray.headers_(n,s,loc).repetition = acqhdr.idx.repetition; imarray.headers_(n,s,loc).set = acqhdr.idx.set; imarray.headers_(n,s,loc).acquisition_time_stamp = acqhdr.acquisition_time_stamp; imarray.headers_(n,s,loc).position[0] = acqhdr.position[0]; imarray.headers_(n,s,loc).position[1] = acqhdr.position[1]; imarray.headers_(n,s,loc).position[2] = acqhdr.position[2]; imarray.headers_(n,s,loc).read_dir[0] = acqhdr.read_dir[0]; imarray.headers_(n,s,loc).read_dir[1] = acqhdr.read_dir[1]; imarray.headers_(n,s,loc).read_dir[2] = acqhdr.read_dir[2]; imarray.headers_(n,s,loc).phase_dir[0] = acqhdr.phase_dir[0]; imarray.headers_(n,s,loc).phase_dir[1] = acqhdr.phase_dir[1]; imarray.headers_(n,s,loc).phase_dir[2] = acqhdr.phase_dir[2]; imarray.headers_(n,s,loc).slice_dir[0] = acqhdr.slice_dir[0]; imarray.headers_(n,s,loc).slice_dir[1] = acqhdr.slice_dir[1]; imarray.headers_(n,s,loc).slice_dir[2] = acqhdr.slice_dir[2]; imarray.headers_(n,s,loc).patient_table_position[0] = acqhdr.patient_table_position[0]; imarray.headers_(n,s,loc).patient_table_position[1] = acqhdr.patient_table_position[1]; imarray.headers_(n,s,loc).patient_table_position[2] = acqhdr.patient_table_position[2]; imarray.headers_(n,s,loc).data_type = ISMRMRD::ISMRMRD_CXFLOAT; imarray.headers_(n,s,loc).image_index = ++image_counter_; //Grab a wrapper around the relevant chunk of data [E0,E1,E2,CHA] for this loc, n, and s //Each chunk will be [E0,E1,E2,CHA] big std::vector<size_t> chunk_dims(4); chunk_dims[0] = E0; chunk_dims[1] = E1; chunk_dims[2] = E2; chunk_dims[3] = CHA; hoNDArray<std::complex<float> > chunk = hoNDArray<std::complex<float> >(chunk_dims, &dbuff.data_(0,0,0,0,n,s,loc)); //Do the FFTs in place hoNDFFT<float>::instance()->ifft(&chunk,0); hoNDFFT<float>::instance()->ifft(&chunk,1); if (E2>1) { hoNDFFT<float>::instance()->ifft(&chunk,2); } //Square root of the sum of squares //Each image will be [E0,E1,E2,1] big std::vector<size_t> img_dims(3); img_dims[0] = E0; img_dims[1] = E1; img_dims[2] = E2; hoNDArray<std::complex<float> > output = hoNDArray<std::complex<float> >(img_dims, &imarray.data_(0,0,0,0,n,s,loc)); //Zero out the output clear(output); //Compute d* d in place multiplyConj(chunk,chunk,chunk); //Add up for (size_t c = 0; c < CHA; c++) { output += hoNDArray<std::complex<float> >(img_dims, &chunk(0,0,0,c)); } //Take the square root in place sqrt_inplace(&output); } } } //Pass the image array down the chain if (this->next()->putq(cm1) < 0) { m1->release(); return GADGET_FAIL; } } m1->release(); return GADGET_OK; }