def send_reconstructed_images(connection, data_array,acq_header):
# the fonction creates an new ImageHeader for each 4D dataset [RO,E1,E2,CHA]
# copy information from the acquisitonHeader
# fill additionnal fields
# and send the reconstructed image and ImageHeader to the next gadget
# some field are not correctly filled like image_type that floattofix point doesn't recognize , why ?
dims=data_array.shape
base_header=ismrmrd.ImageHeader()
base_header.version=2
ndims_image=(dims[0], dims[1], dims[2], dims[3])
base_header.channels = ndims_image[3]
base_header.matrix_size = (data_array.shape[0],data_array.shape[1],data_array.shape[2])
base_header.position = acq_header.position
base_header.read_dir = acq_header.read_dir
base_header.phase_dir = acq_header.phase_dir
base_header.slice_dir = acq_header.slice_dir
base_header.patient_table_position = acq_header.patient_table_position
base_header.acquisition_time_stamp = acq_header.acquisition_time_stamp
base_header.image_index = 0
base_header.image_series_index = 0
base_header.data_type = ismrmrd.DATATYPE_CXFLOAT
base_header.image_type= ismrmrd.IMTYPE_COMPLEX
base_header.repetition=acq_header.idx.repetition
I=np.zeros((dims[0], dims[1], dims[2], dims[3]))
for slc in range(0, dims[6]):
for n in range(0, dims[5]):
for s in range(0, dims[4]):
I=data_array[:,:,:,:,s,n,slc]
base_header.image_type= ismrmrd.IMTYPE_COMPLEX
base_header.slice=slc
image_array= ismrmrd.image.Image.from_array(I, headers=base_header)
connection.send(image_array)
def process(self, recondata):
print(np.shape(recondata[0].data.data))
image = cifftn(recondata[0].data.data, axes=(0, 1, 2))
image = np.reshape(
image,
(image.shape[0], image.shape[1], image.shape[2], image.shape[3]))
#Create a new image header and transfer value
acq = np.ravel(recondata[0].data.headers)[0]
img_head = ismrmrd.ImageHeader()
img_head.channels = acq.active_channels
img_head.slice = acq.idx.slice
img_head.matrix_size = (image.shape[0], image.shape[1], image.shape[2])
img_head.position = acq.position
img_head.read_dir = acq.read_dir
img_head.phase_dir = acq.phase_dir
img_head.slice_dir = acq.slice_dir
img_head.patient_table_position = acq.patient_table_position
img_head.acquisition_time_stamp = acq.acquisition_time_stamp
img_head.image_index = 0
img_head.image_series_index = 0
img_head.data_type = ismrmrd.DATATYPE_CXFLOAT
#Return image to Gadgetron
self.put_next(img_head, image)
print("Slice ", img_head.slice)
print("----------------------------------------------")
return 0
def create_array_of_image_header(image,acq, dims_header):
headers_list = []
base_header=ismrmrd.ImageHeader()
base_header.version=2
ndims_image=np.shape(image)
base_header.channels = ndims_image[3]
base_header.matrix_size = (image.shape[0],image.shape[1],image.shape[2])
print((image.shape[0],image.shape[1],image.shape[2]))
base_header.position = acq.position
base_header.read_dir = acq.read_dir
base_header.phase_dir = acq.phase_dir
base_header.slice_dir = acq.slice_dir
base_header.patient_table_position = acq.patient_table_position
base_header.acquisition_time_stamp = acq.acquisition_time_stamp
base_header.image_index = 0
base_header.image_series_index = 0
base_header.data_type = ismrmrd.DATATYPE_CXFLOAT
base_header.image_type= ismrmrd.IMTYPE_MAGNITUDE
for slc in range(0, dims_header[4]):
for n in range(0, dims_header[3]):
for s in range(0, dims_header[2]):
headers_list.append(base_header)
array_headers_test = np.array(headers_list,dtype=np.dtype(object))
array_headers_test=np.reshape(array_headers_test, (dims_header[2], dims_header[3], dims_header[4]))
return array_headers_test
def process(self, acq, data, *args):
if self.myBuffer is None:
channels = acq.active_channels
if self.enc.encodingLimits.slice != None:
nslices = self.enc.encodingLimits.slice.maximum + 1
else:
nslices = 1
eNz = self.enc.encodedSpace.matrixSize.z
eNy = self.enc.encodedSpace.matrixSize.y
eNx = self.enc.encodedSpace.matrixSize.x
self.myBuffer = np.zeros(
(int(eNx / 2), eNy, eNz, nslices, channels),
dtype=np.complex64)
line_offset = self.enc.encodedSpace.matrixSize.y / 2 - self.enc.encodingLimits.kspace_encoding_step_1.center
self.myBuffer[:,
int(acq.idx.kspace_encode_step_1 + line_offset),
int(acq.idx.kspace_encode_step_2),
int(acq.idx.slice), :] = data
if (acq.flags & (1 << 7)): #Is this the last scan in slice
image = transform.transform_kspace_to_image(self.myBuffer,
dim=(0, 1, 2))
image = image * np.product(
image.shape) * 100 #Scaling for the scanner
#Create a new image header and transfer value
img_head = ismrmrd.ImageHeader()
img_head.channels = acq.active_channels
img_head.slice = acq.idx.slice
img_head.matrix_size[0] = self.myBuffer.shape[0]
img_head.matrix_size[1] = self.myBuffer.shape[1]
img_head.matrix_size[2] = self.myBuffer.shape[2]
img_head.position = acq.position
img_head.read_dir = acq.read_dir
img_head.phase_dir = acq.phase_dir
img_head.slice_dir = acq.slice_dir
img_head.patient_table_position = acq.patient_table_position
img_head.acquisition_time_stamp = acq.acquisition_time_stamp
img_head.image_index = self.myCounter
img_head.image_series_index = self.mySeries
img_head.data_type = ismrmrd.DATATYPE_CXFLOAT
self.myCounter += 1
if self.myCounter > 5:
self.mySeries += 1
self.myCounter = 1
#Return image to Gadgetron
self.put_next(img_head, image.astype('complex64'), *args)
#print "Returning to Gadgetron"
return 0 #Everything OK
def test_new_instance():
img = ismrmrd.Image()
eq_(type(img.getHead()), ismrmrd.ImageHeader)
eq_(img.getHead().data_type, ismrmrd.DATATYPE_CXFLOAT)
eq_(type(img.data), np.ndarray)
eq_(img.data.dtype, np.complex64)
attr = "this is a fake attribute string"
head = ismrmrd.ImageHeader()
head.attribute_string_len = len(attr) # must set attribute_string_len
head.data_type = ismrmrd.DATATYPE_CXFLOAT # must set data_type
img = ismrmrd.Image(head, attribute_string=attr)
eq_(img.attribute_string, attr)
def test_set_head():
img = ismrmrd.Image()
nchan, nx, ny, nz = 8, 256, 128, 32
head = ismrmrd.ImageHeader()
head.data_type = ismrmrd.DATATYPE_CXDOUBLE
head.channels = nchan
head.matrix_size[0] = nx
head.matrix_size[1] = ny
head.matrix_size[2] = nz
img.setHead(head)
eq_(img.data.shape, (nchan, nz, ny, nx))
eq_(img.data_type, ismrmrd.DATATYPE_CXDOUBLE)
eq_(img.data.dtype, np.complex128)
def gen_image_to_send(header: ismrmrd.xsd.ismrmrdHeader,
acqs: typing.List[ismrmrd.Acquisition] = None,
connection: gadgetron.external.Connection = None):
# target picture size, should get get from header in the future
recon_matrix = header.encoding[0].reconSpace.matrixSize
ic = 1 # channel
iz = 1 # z size
iy = recon_matrix.y # height
ix = recon_matrix.x # width
dpi = 100 # data per inch
figure = plt.gcf() # type: Figure
figure.set_size_inches(ix / dpi, iy / dpi)
print(rf'--------------------plot begin-----------------------')
t = np.arange(0.0, 2.0, 0.01)
s = np.sin(2 * np.pi * t)
plt.plot(t, s)
plt.title(r'$\alpha_i > \beta_i$', fontsize=20)
plt.text(1, -0.6, r'$\sum_{i=0}^\infty x_i$', fontsize=20)
plt.text(0.6, 0.6, r'$\mathcal{A}\mathrm{sin}(2 \omega t)$', fontsize=20)
plt.xlabel('time (s)')
plt.ylabel('volts (mV)')
plt.savefig("result.png", dpi=dpi) # 3x100, 2x100
print(rf'--------------------plot end-----------------------')
h = ismrmrd.ImageHeader() # type: ismrmrd.ImageHeader
#h.data_type = ismrmrd.DATATYPE_USHORT
h.data_type = ismrmrd.DATATYPE_FLOAT
h.image_type = ismrmrd.IMTYPE_MAGNITUDE
h.channels = ic
h.matrix_size = (ix, iy, iz)
i = ismrmrd.Image(h)
gray_scale_img = PILImage.open('result.png').convert(
'L') # gray scale image uint 8
img_data = np.array(gray_scale_img)
#TODO how to stand this code?
#i.data[:] = img_data[:, ::-1].data[:]
i.data[:] = img_data.data[:]
return i
def process(self, recondata):
print(np.shape(recondata[0].data.data))
image = transform.transform_kspace_to_image(recondata[0].data.data,dim=(0,1,2))
print(np.shape(image))
#image = np.reshape(image,(image.shape[0],image.shape[1],image.shape[2],image.shape[3]))
#Create a new image header and transfer value
print(type(recondata[0].data.headers))
print(np.shape(recondata[0].data.headers))
acq = np.ravel(recondata[0].data.headers)[0]
print(type(acq))
print(acq.active_channels)
print(acq.idx.slice)
dims=np.shape(recondata[0].data.data)
print(dims)
for s in range(dims[6]):
img_head = ismrmrd.ImageHeader()
img_head.channels = acq.active_channels
img_head.slice = s #acq.idx.slice
img_head.matrix_size = (image.shape[0],image.shape[1],image.shape[2])
img_head.position = acq.position
img_head.read_dir = acq.read_dir
img_head.phase_dir = acq.phase_dir
img_head.slice_dir = acq.slice_dir
img_head.patient_table_position = acq.patient_table_position
img_head.acquisition_time_stamp = acq.acquisition_time_stamp
img_head.image_index = 0
img_head.image_series_index = 0
img_head.data_type = ismrmrd.DATATYPE_CXFLOAT
#Return image to Gadgetron
print(np.shape(image[:,:,:,:,0,0,s]))
self.put_next(img_head,image[:,:,:,:,:,:,s])
print("Slice ", img_head.slice)
print("----------------------------------------------")
return 0
def process(self, recondata):
print(np.shape(recondata[0].data.data))
image = cifftn(recondata[0].data.data, axes=(0, 1, 2))
image = np.reshape(
image,
(image.shape[0], image.shape[1], image.shape[2], image.shape[3]))
#Create a new image header and transfer value
acq = np.ravel(recondata[0].data.headers)[0]
img_head = ismrmrd.ImageHeader()
img_head.version = 1
img_head.measurement_uid = acq.measurement_uid
img_head.channels = acq.active_channels
img_head.slice = acq.idx.slice
img_head.matrix_size = (image.shape[0], image.shape[1], image.shape[2])
img_head.field_of_view = (self.enc.reconSpace.fieldOfView_mm.x,
self.enc.reconSpace.fieldOfView_mm.y,
self.enc.reconSpace.fieldOfView_mm.z)
img_head.position = acq.position
img_head.read_dir = acq.read_dir
img_head.phase_dir = acq.phase_dir
img_head.slice_dir = acq.slice_dir
img_head.patient_table_position = acq.patient_table_position
img_head.acquisition_time_stamp = acq.acquisition_time_stamp
img_head.average = acq.idx.average
img_head.slice = acq.idx.slice
img_head.contrast = acq.idx.contrast
img_head.phase = acq.idx.phase
img_head.repetition = acq.idx.repetition
img_head.set = acq.idx.set
img_head.image_index = next(self.image_indices)
img_head.image_series_index = 0
img_head.data_type = ismrmrd.DATATYPE_CXFLOAT
#Return image to Gadgetron
self.put_next(img_head, image)
print("Slice ", img_head.slice)
print("----------------------------------------------")
return 0
def process(self, recondata):
# receive kspace data and
# extract acq_data and acq_header
array_acq_headers = recondata[0].data.headers
kspace_data = recondata[0].data.data
try:
if recondata[0].ref.data is not None:
print("reference data exist")
print(
np.shape(recondata[0].ref.data)
) # only for repetition 0 # il faut creer le bucket recon grappa
reference = recondata[0].ref.data
data = recondata[0].data.data
print(np.shape(reference))
print(np.shape(data))
self.array_calib = reference
np.save('/tmp/gadgetron/reference', reference)
np.save('/tmp/gadgetron/data', data)
except:
print("reference data not exist")
# grappa
array_data = recondata[0].data.data
dims = np.shape(recondata[0].data.data)
kspace_data_tmp = np.ndarray(dims, dtype=np.complex64)
for slc in range(0, dims[6]):
for n in range(0, dims[5]):
for s in range(0, dims[4]):
kspace = array_data[:, :, :, :, s, n, slc]
calib = self.array_calib[:, :, :, :, s, n, slc]
calib = np.squeeze(calib, axis=2)
kspace = np.squeeze(kspace, axis=2)
sx, sy, ncoils = kspace.shape[:]
cx, cy, ncoils = calib.shape[:]
# Here's the actual reconstruction
res = grappa(kspace,
calib,
kernel_size=(5, 5),
coil_axis=-1)
# Here's the resulting shape of the reconstruction. The coil
# axis will end up in the same place you provided it in
sx, sy, ncoils = res.shape[:]
kspace_data_tmp[:, :, 0, :, s, n, slc] = res
# ifft, this is necessary for the next gadget
#image = transform.transform_kspace_to_image(kspace_data_tmp,dim=(0,1,2))
image = transform.transform_kspace_to_image(kspace_data_tmp,
dim=(0, 1, 2))
# create a new IsmrmrdImageArray
array_data = IsmrmrdImageArray()
# attache the images to the IsmrmrdImageArray
array_data.data = image
# get dimension for the acq_headers
dims_header = np.shape(recondata[0].data.headers)
# get one header with typical info
acq = np.ravel(array_acq_headers)[0]
print("acq.idx.repetition", acq.idx.repetition)
if (acq.idx.repetition == 0):
np.save('/tmp/gadgetron/image', image)
headers_list = []
base_header = ismrmrd.ImageHeader()
base_header.version = 2
ndims_image = np.shape(image)
base_header.channels = ndims_image[3]
base_header.matrix_size = (image.shape[0], image.shape[1],
image.shape[2])
print((image.shape[0], image.shape[1], image.shape[2]))
base_header.position = acq.position
base_header.read_dir = acq.read_dir
base_header.phase_dir = acq.phase_dir
base_header.slice_dir = acq.slice_dir
base_header.patient_table_position = acq.patient_table_position
base_header.acquisition_time_stamp = acq.acquisition_time_stamp
base_header.image_index = 0
base_header.image_series_index = 0
base_header.data_type = ismrmrd.DATATYPE_CXFLOAT
base_header.image_type = ismrmrd.IMTYPE_MAGNITUDE
print("ready to list")
for slc in range(0, dims_header[4]):
for n in range(0, dims_header[3]):
for s in range(0, dims_header[2]):
#for e2 in range(0, dims_header[1]):
# for e1 in range(0, dims_header[0]):
headers_list.append(base_header)
array_headers_test = np.array(headers_list, dtype=np.dtype(object))
print(type(array_headers_test))
print(np.shape(array_headers_test))
array_headers_test = np.reshape(
array_headers_test,
(dims_header[2], dims_header[3], dims_header[4]))
print(type(array_headers_test))
print(np.shape(array_headers_test))
print("---> ok 0")
# how to copy acquisition header into image header in python ?
for slc in range(0, dims_header[4]):
for n in range(0, dims_header[3]):
for s in range(0, dims_header[2]):
# for e2 in range(0, dims_header[1]):
# for e1 in range(0, dims_header[0]):
array_headers_test[s, n, slc].slice = slc
#print(s,n,slc)
#print(type(array_headers_test[s,n,slc]))
#print(array_headers_test[s,n,slc].slice)
#print("---> ok 1")
# print(np.shape(array_image_header))
# attache the image headers to the IsmrmrdImageArray
array_data.headers = array_headers_test
#print("---> ok 2")
# Return image to Gadgetron
#print(np.shape(array_data.data))
#print(np.shape(array_data.headers))
#print(type(array_data.data))
#print(type(array_data.headers))
#print(type(array_data))
# send the data to the next gadget
for slc in range(0, dims_header[4]):
for n in range(0, dims_header[3]):
for s in range(0, dims_header[2]):
#print("send out image %d-%d-%d" % (s, n, slc))
a = array_data.data[:, :, :, :, s, n, slc]
#array_data.headers[s,n,slc].slice=slc
#print(a.shape, array_data.headers[s,n,slc].slice)
self.put_next(array_data.headers[s, n, slc], a)
#self.put_next( [IsmrmrdReconBit(array_data.headers, array_data.data)] , )
print("----------------------------------------------")
return 0
def process(self, acq, data, *args):
if self.buffer is None:
# Matrix size
eNx = self.enc.encodedSpace.matrixSize.x
eNy = self.enc.encodedSpace.matrixSize.y
eNz = self.enc.encodedSpace.matrixSize.z
rNx = self.enc.reconSpace.matrixSize.x
rNy = self.enc.reconSpace.matrixSize.y
rNz = self.enc.reconSpace.matrixSize.z
# Field of View
eFOVx = self.enc.encodedSpace.fieldOfView_mm.x
eFOVy = self.enc.encodedSpace.fieldOfView_mm.y
eFOVz = self.enc.encodedSpace.fieldOfView_mm.z
rFOVx = self.enc.reconSpace.fieldOfView_mm.x
rFOVy = self.enc.reconSpace.fieldOfView_mm.y
rFOVz = self.enc.reconSpace.fieldOfView_mm.z
channels = acq.active_channels
if data.shape[1] != rNx:
raise (
"Error, Recon gadget expects data to be on correct matrix size in RO direction"
)
if (rNz != 1):
rasie("Error Recon Gadget only supports 2D for now")
self.buffer = np.zeros((channels, rNy, rNx), dtype=np.complex64)
self.samp_mask = np.zeros(self.buffer.shape[1:])
self.header_proto = ismrmrd.ImageHeader()
self.header_proto.matrix_size[0] = rNx
self.header_proto.matrix_size[1] = rNy
self.header_proto.matrix_size[2] = rNz
self.header_proto.field_of_view[0] = rFOVx
self.header_proto.field_of_view[1] = rFOVy
self.header_proto.field_of_view[0] = rFOVz
#Now put data in buffer
line_offset = self.buffer.shape[
1] / 2 - self.enc.encodingLimits.kspace_encoding_step_1.center
self.buffer[:, acq.idx.kspace_encode_step_1 + line_offset, :] = data
self.samp_mask[acq.idx.kspace_encode_step_1 + line_offset, :] = 1
#If last scan in buffer, do FFT and fill image header
if acq.isFlagSet(ismrmrd.ACQ_LAST_IN_ENCODE_STEP1) or acq.isFlagSet(
ismrmrd.ACQ_LAST_IN_SLICE):
img_head = copy.deepcopy(self.header_proto)
img_head.position = acq.position
img_head.read_dir = acq.read_dir
img_head.phase_dir = acq.phase_dir
img_head.slice_dir = acq.slice_dir
img_head.patient_table_position = acq.patient_table_position
img_head.acquisition_time_stamp = acq.acquisition_time_stamp
img_head.slice = acq.idx.slice
img_head.channels = 1
scale = self.samp_mask.size / (1.0 * np.sum(self.samp_mask[:]))
#We have not yet calculated unmixing coefficients
if self.unmix is None:
self.calib_buffer.append((img_head, self.buffer.copy()))
self.buffer[:] = 0
self.samp_mask[:] = 0
if len(self.calib_buffer) >= self.calib_frames:
cal_data = np.zeros(self.calib_buffer[0][1].shape,
dtype=np.complex64)
for c in self.calib_buffer:
cal_data = cal_data + c[1]
mask = np.squeeze(np.sum(np.abs(cal_data), 0))
mask = np.ones(mask.shape) * (np.abs(mask) > 0.0)
target = None #cal_data[0:8,:,:]
coil_images = transform.transform_kspace_to_image(cal_data,
dim=(1,
2))
(csm, rho) = coils.calculate_csm_walsh(coil_images)
if self.method == 'grappa':
self.unmix, self.gmap = grappa.calculate_grappa_unmixing(
cal_data,
self.acc_factor,
data_mask=mask,
kernel_size=(4, 5),
csm=csm)
elif self.method == 'sense':
self.unmix, self.gmap = sense.calculate_sense_unmixing(
self.acc_factor, csm)
else:
raise Exception('Unknown parallel imaging method: ' +
str(self.method))
for c in self.calib_buffer:
recon = transform.transform_kspace_to_image(
c[1], dim=(1, 2)) * np.sqrt(scale)
recon = np.squeeze(np.sum(recon * self.unmix, 0))
self.put_next(c[0], recon, *args)
return 0
if self.unmix is None:
raise Exception(
"We should never reach this point without unmixing coefficients"
)
recon = transform.transform_kspace_to_image(
self.buffer, dim=(1, 2)) * np.sqrt(scale)
recon = np.squeeze(np.sum(recon * self.unmix, 0))
self.buffer[:] = 0
self.samp_mask[:] = 0
self.put_next(img_head, recon, *args)
return 0
im = np.squeeze(np.sqrt(np.sum(np.abs(im)**2, 3)))
images.append(im)
l = len(images)
fig = plt.figure()
for n, im in enumerate(images):
a = fig.add_subplot(1, 5, n)
plt.imshow(im)
fig.set_size_inches(16, 4)
# grab the first acquisition for extra info
acqh = dset.readAcquisition(0).getHead()
for n, img in enumerate(images):
hdr = ismrmrd.ImageHeader()
hdr.acquisition_time_stamp = acqh.acquisition_time_stamp
hdr.flags = 0
hdr.measurement_uid = acqh.measurement_uid
hdr.phase_dir = acqh.phase_dir
hdr.physiology_time_stamp = acqh.physiology_time_stamp
hdr.position = acqh.position
hdr.read_dir = acqh.read_dir
hdr.slice_dir = acqh.slice_dir
hdr.channels = 1
hdr.image_data_type = ismrmrd.DATA_FLOAT
hdr.image_type = ismrmrd.TYPE_MAGNITUDE
hdr.image_index = n
hdr.slice = n
dset.appendImageHeader(hdr, "image_%d.hdr" % n)
def process(self, recondata):
# receive kspace data and
# extract acq_data and acq_header
array_acq_headers = recondata[0].data.headers
kspace_data = recondata[0].data.data
try:
if recondata[0].ref.data is not None:
print("reference data exist")
print(
np.shape(recondata[0].ref.data)
) # only for repetition 0 # il faut creer le bucket recon grappa
except:
print("reference data not exist")
# ifft
image = transform.transform_kspace_to_image(kspace_data, dim=(0, 1, 2))
# create a new IsmrmrdImageArray
array_data = IsmrmrdImageArray()
# attache the images to the IsmrmrdImageArray
array_data.data = image
# get dimension for the acq_headers
dims_header = np.shape(recondata[0].data.headers)
# get one header with typical info
acq = np.ravel(array_acq_headers)[0]
headers_list = []
base_header = ismrmrd.ImageHeader()
base_header.version = 2
ndims_image = np.shape(image)
base_header.channels = ndims_image[3]
base_header.matrix_size = (image.shape[0], image.shape[1],
image.shape[2])
print((image.shape[0], image.shape[1], image.shape[2]))
base_header.position = acq.position
base_header.read_dir = acq.read_dir
base_header.phase_dir = acq.phase_dir
base_header.slice_dir = acq.slice_dir
base_header.patient_table_position = acq.patient_table_position
base_header.acquisition_time_stamp = acq.acquisition_time_stamp
base_header.image_index = 0
base_header.image_series_index = 0
base_header.data_type = ismrmrd.DATATYPE_CXFLOAT
base_header.image_type = ismrmrd.IMTYPE_MAGNITUDE
print("ready to list")
for slc in range(0, dims_header[4]):
for n in range(0, dims_header[3]):
for s in range(0, dims_header[2]):
#for e2 in range(0, dims_header[1]):
# for e1 in range(0, dims_header[0]):
headers_list.append(base_header)
array_headers_test = np.array(headers_list, dtype=np.dtype(object))
print(type(array_headers_test))
print(np.shape(array_headers_test))
array_headers_test = np.reshape(
array_headers_test,
(dims_header[2], dims_header[3], dims_header[4]))
print(type(array_headers_test))
print(np.shape(array_headers_test))
print("---> ok 0")
# how to copy acquisition header into image header in python ?
for slc in range(0, dims_header[4]):
for n in range(0, dims_header[3]):
for s in range(0, dims_header[2]):
# for e2 in range(0, dims_header[1]):
# for e1 in range(0, dims_header[0]):
array_headers_test[s, n, slc].slice = slc
#print(s,n,slc)
#print(type(array_headers_test[s,n,slc]))
#print(array_headers_test[s,n,slc].slice)
#print("---> ok 1")
# print(np.shape(array_image_header))
# attache the image headers to the IsmrmrdImageArray
array_data.headers = array_headers_test
#print("---> ok 2")
# Return image to Gadgetron
print(np.shape(array_data.data))
print(np.shape(array_data.headers))
print(type(array_data.data))
print(type(array_data.headers))
print(type(array_data))
# send the data to the next gadget
for slc in range(0, dims_header[4]):
for n in range(0, dims_header[3]):
for s in range(0, dims_header[2]):
#print("send out image %d-%d-%d" % (s, n, slc))
a = array_data.data[:, :, :, :, s, n, slc]
#array_data.headers[s,n,slc].slice=slc
#print(a.shape, array_data.headers[s,n,slc].slice)
self.put_next(array_data.headers[s, n, slc], a)
#self.put_next( [IsmrmrdReconBit(array_data.headers, array_data.data)] , )
print("----------------------------------------------")
return 0
def test_header():
head = ismrmrd.ImageHeader()
assert ctypes.sizeof(head) == 198
