Raw_path = os.path.join(basedir, '*TIF') #tif or TIF be careful
axes = 'ZYX' #projection axes : 'YX'
filesRaw = glob.glob(Raw_path)
# In[6]:
for fname in filesRaw:
if os.path.exists(fname) == True :
if os.path.exists(basedirResults2Dextended + '_' + os.path.basename(fname)) == False :
print(fname)
y = imread(fname)
restored = RestorationModel.predict(y, axes, n_tiles = (1,4,4)) #n_tiles is for the decomposition of the image in (z,y,x). (1,2,2) will work with light images. Less tiles we have, faster the calculation is
projection = ProjectionModel.predict(restored, axes, n_tiles = (1,1,2)) #n_tiles is for the decomposition of the image in (z,y,x). There is overlapping in the decomposition wich is managed by the program itself
axes_restored = axes.replace(ProjectionModel.proj_params.axis, '')
restored = restored.astype('uint8') # if prediction and projection running at the same time
#restored = restored.astype('uint16') # if projection training set creation or waiting for a future projection
projection = projection.astype('uint8')
#save_tiff_imagej_compatible((basedirResults3Dextended + os.path.basename(fname)) , restored, axes)
save_tiff_imagej_compatible((basedirResults2Dextended + '_' + os.path.basename(fname)) , projection, axes_restored)
#Normal Images : restored = RestorationModel.predict(y, axes, n_tiles = (1,2,4))
# projection = ProjectionModel.predict(restored, axes, n_tiles = (1,1,1))
# In[]:
def predict(self, file_fn, n_tiles=(1, 4, 4), keep_meta=True):
JVM().start()
pixel_reso = get_space_time_resolution(file_fn)
print("Prediction {}".format(file_fn))
print(" -- Using pixel sizes and frame interval", pixel_reso)
ir = bf.ImageReader(file_fn)
reader = ir.rdr
loci_pixel_type = reader.getPixelType()
if loci_pixel_type == 1:
# uint8
dtype = numpy.uint8
elif loci_pixel_type == 3:
# uint16
dtype = numpy.uint16
else:
print(
"Error: Pixel-type not supported. Pixel type must be 8- or 16-bit"
)
return
series = 0
z_size = reader.getSizeZ()
y_size = reader.getSizeY()
x_size = reader.getSizeX()
c_size = reader.getSizeC()
t_size = reader.getSizeT()
z_out_size = int(z_size * self.low_scaling[0])
y_out_size = int(y_size * self.low_scaling[1])
x_out_size = int(x_size * self.low_scaling[2])
if c_size != len(self.train_channels):
print(
" -- Warning: Number of Channels during training and prediction do not match. Using channels {} for prediction"
.format(self.train_channels))
for ch in self.train_channels:
model = CARE(None,
'CH_{}_model'.format(ch),
basedir=pathlib.Path(self.out_dir) / 'models')
res_image_ch = numpy.zeros(shape=(t_size, z_out_size, 1,
y_out_size, x_out_size),
dtype=dtype)
print(" -- Predicting channel {}".format(ch))
for t in tqdm(range(t_size), total=t_size):
img_3d = numpy.zeros((z_size, y_size, x_size), dtype=dtype)
for z in range(z_size):
img_3d[z, :, :] = ir.read(series=series,
z=z,
c=ch,
t=t,
rescale=False)
img_3d_ch_ex = rescale(img_3d,
self.low_scaling,
preserve_range=True,
order=self.order,
multichannel=False,
mode="reflect",
anti_aliasing=True)
pred = model.predict(img_3d_ch_ex, axes='ZYX', n_tiles=n_tiles)
di = numpy.iinfo(dtype)
pred = pred.clip(di.min, di.max).astype(dtype)
res_image_ch[t, :, 0, :, :] = pred
if False:
ch_t_out_fn = os.path.join(
os.path.dirname(file_fn),
os.path.splitext(os.path.basename(file_fn))[0] +
"_care_predict_tp{:04d}_ch{}.tif".format(t, ch))
print("Saving time-point {} and channel {} to file '{}'".
format(t, ch, ch_t_out_fn))
tifffile.imsave(ch_t_out_fn,
pred[None, :, None, :, :],
imagej=True,
metadata={'axes': 'TZCYX'})
ch_out_fn = os.path.join(
os.path.dirname(file_fn),
os.path.splitext(os.path.basename(file_fn))[0] +
"_care_predict_ch{}.tif".format(ch))
print(" -- Saving channel {} CARE prediction to file '{}'".format(
ch, ch_out_fn))
if keep_meta:
reso = (1 / (pixel_reso.X / self.low_scaling[2]),
1 / (pixel_reso.Y / self.low_scaling[1]))
spacing = pixel_reso.Z / self.low_scaling[0]
unit = pixel_reso.Xunit
finterval = pixel_reso.T
tifffile.imsave(ch_out_fn,
res_image_ch,
imagej=True,
resolution=reso,
metadata={
'axes': 'TZCYX',
'finterval': finterval,
'spacing': spacing,
'unit': unit
})
else:
tifffile.imsave(ch_out_fn, res_image_ch)
res_image_ch = None # should trigger gc and free the memory
Raw_path = os.path.join(basedir, '*TIF') #tif or TIF be careful
axes = 'ZYX' #projection axes : 'YX'
filesRaw = glob.glob(Raw_path)
# In[6]:
for fname in filesRaw:
if os.path.exists(fname) == True :
if os.path.exists(basedirResults3Dextended + os.path.basename(fname)) == False or os.path.exists(basedirResults2Dextended + '_' + os.path.basename(fname)) == False :
print(fname)
y = imread(fname)
restored = RestorationModel.predict(y, axes, n_tiles = (1,8,8))
#restored = RestorationModel.predict(y, axes, n_tiles = (1,4,8)) #n_tiles is for the decomposition of the image in (z,y,x). (1,2,2) will work with light images. Less tiles we have, faster the calculation is
projection = ProjectionModel.predict(restored, axes, n_tiles = (1,4,4))
#projection = ProjectionModel.predict(restored, axes, n_tiles = (1,1,2)) #n_tiles is for the decomposition of the image in (z,y,x). There is overlapping in the decomposition wich is managed by the program itself
axes_restored = axes.replace(ProjectionModel.proj_params.axis, '')
restored = restored.astype('uint8') # if prediction and projection running at the same time
#restored = restored.astype('uint16') # if projection training set creation or waiting for a future projection
projection = projection.astype('uint8')
#save_tiff_imagej_compatible((basedirResults3Dextended + os.path.basename(fname)) , restored, axes)
save_tiff_imagej_compatible((basedirResults2Dextended + '_' + os.path.basename(fname)) , projection, axes_restored)
# In[]:
from csbdeep.utils import Path
def n2v_flim(project, n2v_num_pix=32):
results_file = os.path.join(project, 'fit_results.hdf5')
X, groups, mask = extract_results(results_file)
data_shape = np.shape(X)
print(data_shape)
mean, std = np.mean(X), np.std(X)
X = normalize(X, mean, std)
XA = X #augment_data(X)
X_val = X[0:10,...]
# We concatenate an extra channel filled with zeros. It will be internally used for the masking.
Y = np.concatenate((XA, np.zeros(XA.shape)), axis=-1)
Y_val = np.concatenate((X_val.copy(), np.zeros(X_val.shape)), axis=-1)
n_x = X.shape[1]
n_chan = X.shape[-1]
manipulate_val_data(X_val, Y_val, num_pix=n_x*n_x*2/n2v_num_pix , shape=(n_x, n_x))
# You can increase "train_steps_per_epoch" to get even better results at the price of longer computation.
config = Config('SYXC',
n_channel_in=n_chan,
n_channel_out=n_chan,
unet_kern_size = 5,
unet_n_depth = 2,
train_steps_per_epoch=200,
train_loss='mae',
train_epochs=35,
batch_norm = False,
train_scheme = 'Noise2Void',
train_batch_size = 128,
n2v_num_pix = n2v_num_pix,
n2v_patch_shape = (n2v_num_pix, n2v_num_pix),
n2v_manipulator = 'uniform_withCP',
n2v_neighborhood_radius='5')
vars(config)
model = CARE(config, 'n2v_model', basedir=project)
history = model.train(XA, Y, validation_data=(X_val,Y_val))
model.load_weights(name='weights_best.h5')
output_project = project.replace('.flimfit','-n2v.flimfit')
if os.path.exists(output_project) : shutil.rmtree(output_project)
shutil.copytree(project, output_project)
output_file = os.path.join(output_project, 'fit_results.hdf5')
X_pred = np.zeros(X.shape)
for i in range(X.shape[0]):
X_pred[i,...] = denormalize(model.predict(X[i], axes='YXC',normalizer=None), mean, std)
X_pred[mask] = np.NaN
insert_results(output_file, X_pred, groups)
