def kernel(self, inputs):
KT = self.KEYS.TENSOR
image = inputs[KT.IMAGE]
efficiency_map = inputs[KT.EFFICIENCY_MAP]
projection_data = inputs[KT.PROJECTION_DATA]
psf_xy = inputs[KT.PSF_XY]
psf_z = inputs[KT.PSF_Z]
# here start the extra psf process,
# the varabiles create below are tensorflow-like type.
# TODO: rewrite by encapsulating in doufo and dxlearn.
import tensorflow as tf
grid = image.data.get_shape()
print("the type of image grid is ",grid)
image_vectorized = tf.reshape(image.data, [grid[0]*grid[1], grid[2]])
print('psf xy shape:', psf_xy.data.get_shape())
print('psf z shape:', psf_z.data.get_shape())
print('image_vectorized shape:', image_vectorized.shape)
# image_mul_psf_z = image_vectorized
image_mul_psf_z = [email protected](psf_z.data)
image_psf_processed = tf.sparse_tensor_dense_matmul(
psf_xy.data, image_mul_psf_z)
# image_psf_processed = image_mul_psf_z
image_psf_processed = tf.reshape(
image_psf_processed, shape=tf.shape(image.data))
image_psf = Image(image_psf_processed, image.center, image.size)
# ####################
# original ReconStep
proj = self.projection(image_psf, projection_data)
back_proj = self.backprojection(proj, image_psf)
# from dxl.learn.tensor import transpose
# here start the extra psf process,
# the varabiles create below are tensorflow-like type.
# TODO: rewrite by encapsulating in doufo and dxlearn.
back_proj_vectorized = tf.reshape(back_proj.data, [grid[0]*grid[1], grid[2]])
# back_proj_mul_psf_z = back_proj_vectorized
back_proj_mul_psf_z = back_proj_vectorized@psf_z.data
back_proj_psf_processed = tf.sparse_tensor_dense_matmul(
tf.sparse_transpose(psf_xy.data), back_proj_mul_psf_z)
# back_proj_psf_processed = back_proj_mul_psf_z
back_proj_psf = tf.reshape(
back_proj_psf_processed, shape=tf.shape(image.data))
back_proj = Image(back_proj_psf, image.center, image.size)
######################################
return self.update(image, back_proj, efficiency_map)
def _(physical_model, projection_data, image):
image = transpose(image)
result = physical_model.op.maplors(image=image.data,
grid=list(image.grid[::-1]),
center=list(image.center[::-1]),
size=list(image.size[::-1]),
lors=transpose(projection_data.lors),
lors_value=projection_data.values)
return transpose(Image(result, image.center[::-1], image.size[::-1]))
def _construct_x(self):
x0 = self._loader.load(self)
x = variable_from_tensor[tf](x0.data, self.KEYS.TENSOR.X)
self.tensors[self.KEYS.TENSOR.BUFFER] = [
variable[tf](shape=x.shape,
dtype=x.dtype,
name=f'{self.KEYS.TENSOR.BUFFER}_{i}')
for i in range(self.config[self.KEYS.CONFIG.NB_WORKERS])
]
self.tensors[self.KEYS.TENSOR.X] = Image(x, x0.center, x0.size)
def _(physical_model, projection_data, image):
image = transpose(image)
result = physical_model.op.backprojection(
image=image.data,
grid=list(image.grid[::-1]),
center=list(image.center[::-1]),
size=list(image.size[::-1]),
lors=transpose(projection_data.lors),
lors_value=projection_data.values,
tof_bin=physical_model.config[physical_model.KEYS.CONFIG.TOF_BIN],
tof_sigma2=physical_model.config[
physical_model.KEYS.CONFIG.TOF_SIGMA2])
return transpose(Image(result, image.center[::-1], image.size[::-1]))
def _(physical_model, projection_data, image):
image = transpose(image)
result = physical_model.op.backprojection(
image=image.data,
sino=projection_data.data,
grid=list(image.grid[::-1]),
center=list(image.center[::-1]),
size=list(image.size[::-1]),
block_grid = list(physical_model.config[physical_model.KEYS.CONFIG.BLOCK_GRID][::-1]),
block_size = list(physical_model.config[physical_model.KEYS.CONFIG.BLOCK_SIZE][::-1]),
block_center = list(physical_model.config[physical_model.KEYS.CONFIG.BLOCK_CENTER][::-1]),
inner_radius = physical_model.config[physical_model.KEYS.CONFIG.INNER_RADIUS],
outer_radius = physical_model.config[physical_model.KEYS.CONFIG.OUTER_RADIUS],
nb_rings = physical_model.config[physical_model.KEYS.CONFIG.NB_RINGS],
nb_blocks_per_ring = physical_model.config[physical_model.KEYS.CONFIG.NB_BLOCKS_PER_RING],
gap = physical_model.config[physical_model.KEYS.CONFIG.GAP])
return transpose(Image(result, image.center[::-1], image.size[::-1]))
def _(model, projection_data, image):
result = []
# print("geometry sigma2 flag:",model.config[model.KEYS.GEO_SIGMA2_FLAG])
for a in model.AXIS:
# for a in ['x', 'z']:
image_axis = transpose(image, model.perm(a))
backproj = Op.get_module().maplors(
image=image_axis.data,
grid=list(image_axis.grid[::-1]),
center=list(image_axis.center[::-1]),
size=list(image_axis.size[::-1]),
lors=transpose(projection_data[a].lors),
lors_value=projection_data[a].values,
kernel_width=model.config[model.KEYS.KERNEL_WIDTH],
geo_sigma2_flag=model.config[model.KEYS.GEO_SIGMA2_FLAG])
result.append(transpose(backproj, model.perm_back(a)))
return Image(sum_(result), image.center, image.size)
def _construrt_inputs(self):
KT = self.KEYS.TENSOR
with tf.variable_scope('local_inputs'):
local_inputs, local_inputs_init = self._loader.load(self)
for k, v in local_inputs.items():
self.tensors[k] = v
with tf.control_dependencies([t.data for t in local_inputs_init]):
self.tensors[self.KEYS.TENSOR.INIT] = NoOp()
inputs = {
'image':
Image(self.tensor(KT.X), self.config('center'),
self.config('size')),
KT.TARGET:
self.tensor(KT.TARGET)
}
inputs.update(local_inputs)
return inputs
def _construct_inputs(self):
x = self.tensors[self.KEYS.TENSOR.X] = const[tf](np.zeros(
tuple(self.config['grid']), np.float32),
name='const')
return self.projection_data, Image(x, self.config['center'],
self.config['size'])
def _construct_inputs(self):
x = self.tensors[self.KEYS.TENSOR.X] = const[tf](self.image,
name='const')
return self.projection_data, Image(x, self.config['center'],
self.config['size'])
def mlem_update_normal(image_prev: Image, image_succ: Image, efficiency_map: Image):
return image_prev.fmap(lambda d: d / efficiency_map.data * image_succ.data)