def write_output(outpath, out, props):
props['dtype'] = out.dtype
mo = Image(outpath, **props)
mo.create()
mo.write(out)
return mo
def write_data(data, props, out_template='', ods=''):
"""Create an Image object and optionally write to file."""
outputpath = ''
if out_template:
outputpath = out_template.format(ods)
props['dtype'] = data.dtype
mo = Image(outputpath, **props)
mo.create()
mo.write(data)
# mo.close()
return mo
def extract_mean(im, dim='c', keep_dtype=True, output='', report={}):
"""Calculate mean over channels."""
ods = 'mean'
im.load(load_data=False)
props = im.get_props()
if len(im.dims) > 4:
props = im.squeeze_props(props, dim=4)
if len(im.dims) > 3:
props = im.squeeze_props(props, dim=3)
mo = Image(output.format(ods), **props)
mo.create()
zdim = im.axlab.index('z')
if im.chunks is not None:
nslcs = im.chunks[zdim]
else:
nslsc = 8
slc_thrs = []
for zstart in range(0, im.dims[zdim], nslcs):
zstop = min(im.dims[zdim], zstart + nslcs)
im.slices[zdim] = mo.slices[zdim] = slice(zstart, zstop, None)
data_mean = np.mean(im.slice_dataset(), axis=im.axlab.index(dim))
if keep_dtype:
data_mean = data_mean.astype(im.dtype)
mo.write(data_mean)
slc_thrs += list(np.median(np.reshape(data_mean, [data_mean.shape[0], -1]), axis=1))
mo.slices = None
mo.set_slices()
im.close()
c_slcs = {dim: get_centreslice(mo, '', dim) for dim in 'zyx'}
report['centreslices'][ods] = c_slcs
return mo, report, slc_thrs
def stack_channels(images_in, outputpath=''):
channels = []
for image_in in images_in:
im = Image(image_in, permission='r')
im.load(load_data=True)
channels.append(im.ds[:])
data = np.stack(channels, axis=3)
mo = Image(outputpath)
mo.elsize = list(im.elsize) + [1]
mo.axlab = im.axlab + 'c'
mo.dims = data.shape
mo.chunks = list(im.chunks) + [1]
mo.dtype = im.dtype
mo.set_slices()
if outputpath:
mo.create()
mo.write(data)
mo.close()
return mo
def apply_bias_field_full(image_in,
bias_in,
dsfacs=[1, 64, 64, 1],
in_place=False,
write_to_single_file=False,
blocksize_xy=1280,
outputpath='',
channel=None):
"""single-core in ~200 blocks"""
perm = 'r+' if in_place else 'r'
im = Image(image_in, permission=perm)
im.load(load_data=False)
bf = Image(bias_in, permission='r')
bf.load(load_data=False)
if channel is not None:
im.slices[3] = slice(channel, channel + 1)
if write_to_single_file: # assuming single-channel copied file here
mo = Image(outputpath)
mo.load()
mo.slices[3] = slice(0, 1, 1)
mpi = wmeMPI(usempi=False)
mpi_nm = wmeMPI(usempi=False)
if blocksize_xy:
blocksize = [im.dims[0], blocksize_xy, blocksize_xy, 1, 1]
blockmargin = [0, im.chunks[1], im.chunks[2], 0, 0]
else:
blocksize = im.dims[:3] + [1, 1]
blockmargin = [0] * len(im.dims)
mpi.set_blocks(im, blocksize, blockmargin)
mpi_nm.set_blocks(im, blocksize)
mpi.scatter_series()
for i in mpi.series:
print(i)
block = mpi.blocks[i]
data_shape = list(im.slices2shape(block['slices']))
block_nm = mpi_nm.blocks[i]
it = zip(block['slices'], block_nm['slices'], blocksize, data_shape)
data_shape = list(im.slices2shape(block_nm['slices']))
data_slices = []
for b_slc, n_slc, bs, ds in it:
m_start = n_slc.start - b_slc.start
m_stop = m_start + bs
m_stop = min(m_stop, ds)
data_slices.append(slice(m_start, m_stop, None))
data_slices[3] = block['slices'][3]
data_shape = list(im.slices2shape(data_slices))
# get the fullres image block
im.slices = block['slices']
data = im.slice_dataset().astype('float')
# get the upsampled bias field
bias = get_bias_field_block(bf, im.slices, data.shape)
data /= bias
data = np.nan_to_num(data, copy=False)
if in_place:
im.slices = block_nm['slices']
data = data[tuple(data_slices[:3])].astype(im.dtype)
im.write(data)
elif write_to_single_file:
mo.slices = block_nm['slices']
mo.slices[3] = slice(0, 1, 1)
data = data[tuple(data_slices[:3])].astype(mo.dtype)
mo.write(data)
else:
props = im.get_props()
if len(im.dims) > 4:
props = im.squeeze_props(props, dim=4)
if len(im.dims) > 3:
props = im.squeeze_props(props, dim=3)
props['axlab'] = 'zyx' # FIXME: axlab return as string-list
props['shape'] = bias.shape
props['slices'] = None
props['dtype'] = bias.dtype
mo = Image(block['path'], **props) # FIXME: needs channel
mo.create(comm=mpi.comm)
mo.slices = None
mo.set_slices()
mo.write(data=bias)
mo.close()
im.close()
bf.close()
def csv_to_im(
image_in,
csv_path,
labelkey='label',
key='dapi',
name='',
maxlabel=0,
normalize=False,
scale_uint16=False,
replace_nan=False,
channel=-1,
outpath='',
):
"""Write segment backprojection."""
if isinstance(image_in, Image):
labels = image_in
else:
labels = LabelImage(image_in)
labels.load(load_data=False)
if not maxlabel:
labels.set_maxlabel()
maxlabel = labels.maxlabel
if csv_path.endswith('.csv'):
df = pd.read_csv(csv_path)
df = df.astype({labelkey: int})
elif csv_path.endswith('.h5ad'):
import scanpy as sc
adata = sc.read(csv_path)
if not csv_path.endswith('_nofilter.h5ad'):
adata.X = adata.raw.X
df = adata.obs[labelkey].astype(int)
df = pd.concat([df, adata[:, key].to_df()], axis=1)
# for key in keys: # TODO
fw = np.zeros(maxlabel + 1, dtype='float')
for index, row in df.iterrows():
fw[int(row[labelkey])] = row[key]
if replace_nan:
fw = np.nan_to_num(fw)
if normalize:
def normalize_data(data):
"""Normalize data between 0 and 1."""
data = data.astype('float64')
datamin = np.amin(data)
datamax = np.amax(data)
data -= datamin
data *= 1 / (datamax - datamin)
return data, [datamin, datamax]
fw_n, fw_minmax = normalize_data(fw)
fw_n *= 65535
fw = fw_n
elif scale_uint16: # for e.g. pseudotime / FA / etc / any [0, 1] vars
fw *= 65535
out = labels.forward_map(list(fw))
if outpath.endswith('.ims'):
mo = Image(outpath, permission='r+')
mo.load(load_data=False)
if channel >= 0 and channel < mo.dims[3]:
ch = channel
else:
mo.create()
ch = mo.dims[3] - 1
mo.slices[3] = slice(ch, ch + 1, 1)
mo.write(out.astype(mo.dtype)) # FIXME: >65535 wraps around
cpath = 'DataSetInfo/Channel {}'.format(ch)
name = name or key
mo.file[cpath].attrs['Name'] = np.array([c for c in name], dtype='|S1')
mo.close()
elif outpath.endswith('.nii.gz'):
props = labels.get_props()
if not labels.path.endswith('.nii.gz'):
props = transpose_props(props, outlayout='xyz')
out = out.transpose()
mo = write_output(outpath, out, props)
else:
outpath = outpath or gen_outpath(labels, key)
mo = write_output(outpath, out, labels.get_props())
return mo