def __get_stacks(self, index):
centre_z = self.batches[index][0].z
half_cube_depth = self.num_planes_needed_for_cube // 2
min_plane = centre_z - half_cube_depth
if is_even(self.num_planes_needed_for_cube):
# WARNING: not centered because even
max_plane = centre_z + half_cube_depth
else:
# centered
max_plane = centre_z + half_cube_depth + 1
signal_stack = np.empty((
self.num_planes_needed_for_cube,
self.image_height,
self.image_width,
))
background_stack = np.empty_like(signal_stack)
for plane, plane_path in enumerate(
self.signal_planes[min_plane:max_plane]):
signal_stack[plane] = tifffile.imread(plane_path)
for plane, plane_path in enumerate(
self.background_planes[min_plane:max_plane]):
background_stack[plane] = tifffile.imread(plane_path)
return signal_stack, background_stack
def test_cube_extraction(tmpdir, depth=20):
tmpdir = str(tmpdir)
args = CubeExtractArgs(tmpdir)
extract_cubes.main(args)
validation_cubes = load_cubes_in_dir(validate_cubes_dir)
test_cubes = load_cubes_in_dir(tmpdir)
for idx, test_cube in enumerate(test_cubes):
assert (validation_cubes[idx] == test_cube).all()
system.delete_directory_contents(tmpdir)
# test cube scaling
args.x_pixel_um = 2
args.y_pixel_um = 2
args.z_pixel_um = 7.25
extract_cubes.main(args)
validation_cubes_scale = load_cubes_in_dir(validate_cubes_scale_dir)
test_cubes = load_cubes_in_dir(tmpdir)
for idx, test_cube in enumerate(test_cubes):
assert (validation_cubes_scale[idx] == test_cube).all()
# test edge of data errors
cell = Cell("x0y0z10", 2)
plane_paths = os.listdir(signal_data_dir[0])
first_plane = tifffile.imread(
os.path.join(signal_data_dir[0], plane_paths[0]))
stack_shape = first_plane.shape + (depth, )
stacks = {}
stacks[0] = np.zeros(stack_shape, dtype=np.uint16)
stacks[0][:, :, 0] = first_plane
for plane in range(1, depth):
im_path = os.path.join(signal_data_dir[0], plane_paths[plane])
stacks[0][:, :, plane] = tifffile.imread(im_path)
cube = extract_cubes.Cube(cell, 0, stacks)
assert (cube.data == 0).all()
cell = Cell("x2500y2500z10", 2)
cube = extract_cubes.Cube(cell, 0, stacks)
assert (cube.data == 0).all()
# test insufficient z-planes for a specific cube
stacks[0] = stacks[0][:, :, 1:]
cube = extract_cubes.Cube(cell, 0, stacks)
assert (cube.data == 0).all()
# test insufficient z-planes for any cube to be extracted at all.
system.delete_directory_contents(tmpdir)
args.z_pixel_um = 0.1
with pytest.raises(extract_cubes.StackSizeError):
extract_cubes.main(args)
def __read_local(self, tile):
"""Read a locally cached GeoTIFF altitude map"""
local_file = self.root_path + tile + '.tif'
if self.verbose > 0:
print("Reading local tile", tile)
if self.verbose > 1:
print(" from", local_file)
try:
tif = tiff.imread(local_file)
#print tif.shape
except ValueError as e:
print('Local file error {0}'.format(e.message))
return False
except:
# File was not found!
print('Unexpected error while reading local file!')
return False
# File loaded succesfully, add to cache
# Y-axis needs to be inverted so that values increase to north
self.cache[tile] = numpy.flip(tif, axis=0)
return True
def load(path: PathLike, force_rgb=False):
"""
Loads an image from the supplied path in grayscale or RGB depending on the
source. If the source is RGB and has redundant channels, the image will be
converted to grayscale. If force_rgb is True, the image will be returned
with 3 channels. If the image has only one channel, then all channels will
be identical.
"""
if PurePath(path).suffix.casefold() in (".tif", ".tiff"):
image = tf.imread(path)
else:
image = Image.open(str(path))
image = np.array(image)
image = _add_channel_dim(image)
# convert redundant rgb to grayscale
if _is_color(image):
g_redundant = (image[..., 0] == image[..., 1]).all()
b_redundant = (image[..., 0] == image[..., 2]).all()
if (g_redundant and b_redundant) and not force_rgb:
image = image[..., 0]
image = image[..., np.newaxis]
if _is_gray(image) and force_rgb:
image = np.repeat(image, 3, axis=2)
assert image.ndim == 3
assert _is_gray(image) or _is_color(image)
return image
def process_series(_experiment, _series_id, _overwrite=False):
_series_image_path = paths.serieses(_experiment, _series_id)
_image_properties = load.image_properties(_experiment, _series_id)
_series_image = tifffile.imread(_series_image_path)
_cells_coordinates = load.cell_coordinates_tracked_series_file_data(
_experiment, _series_id)
_series_image_by_time_frames = [
np.array([
_z[IMAGE_FIBER_CHANNEL_INDEX] for _z in _series_image[_time_frame]
]) for _time_frame in range(_series_image.shape[0])
]
_tuples = load.experiment_groups_as_tuples(_experiment)
_tuples = organize.by_experiment(_tuples)[_experiment]
_tuples = filtering.by_real_pairs(_tuples)
_tuples = filtering.by_real_fake_pairs(_tuples, _real_fake_pairs=False)
_tuples = filtering.by_series_id(_tuples, _series_id)
for _tuple in _tuples:
_experiment, _series_id, _group = _tuple
_cell_1_id, _cell_2_id = [
int(_value) for _value in _group.split('_')[1:]
]
process_group(
_experiment=_experiment,
_series_id=_series_id,
_cells_coordinates=_cells_coordinates,
_cell_1_id=_cell_1_id,
_cell_2_id=_cell_2_id,
_series_image_by_time_frames=_series_image_by_time_frames,
_resolutions=_image_properties['resolutions'],
_image_properties=_image_properties,
_overwrite=_overwrite)
def setup(
first_img_path,
soma_diameter,
ball_xy_size,
ball_z_size,
ball_overlap_fraction=0.6,
z_offset=0,
):
plane = tifffile.imread(first_img_path)
plane = plane.T
max_value = get_max_value(plane)
clipping_value = max_value - 2
thrsh_val = max_value - 1
soma_centre_val = max_value
tile_width = soma_diameter * 2
layer_width, layer_height = plane.shape
ball_filter = BallFilter(
layer_width,
layer_height,
ball_xy_size,
ball_z_size,
overlap_fraction=ball_overlap_fraction,
tile_step_width=tile_width,
tile_step_height=tile_width,
threshold_value=thrsh_val,
soma_centre_value=soma_centre_val,
)
start_z = z_offset + int(math.floor(ball_z_size / 2))
cell_detector = CellDetector(layer_width, layer_height, start_z=start_z)
return clipping_value, thrsh_val, ball_filter, cell_detector
def process_fake_following(_experiment,
_series_id,
_cell_1_id,
_cell_2_id,
_x_change,
_y_change,
_z_change=0,
_overwrite=False):
_series_image_path = paths.serieses(_experiment, _series_id)
_image_properties = load.image_properties(_experiment, _series_id)
_series_image = tifffile.imread(_series_image_path)
_cells_coordinates = load.cell_coordinates_tracked_series_file_data(
_experiment, _series_id)
_series_image_by_time_frames = [
np.array([
_z[IMAGE_FIBER_CHANNEL_INDEX] for _z in _series_image[_time_frame]
]) for _time_frame in range(_series_image.shape[0])
]
process_group(_experiment=_experiment,
_series_id=_series_id,
_cells_coordinates=_cells_coordinates,
_cell_1_id=_cell_1_id,
_cell_2_id=_cell_2_id,
_series_image_by_time_frames=_series_image_by_time_frames,
_resolutions=_image_properties['resolutions'],
_real_cells=False,
_x_change=_x_change,
_y_change=_y_change,
_z_change=_z_change,
_overwrite=_overwrite)
def process_fake_static(_experiment,
_series_id,
_cell_1_id,
_cell_2_id,
_x1,
_y1,
_z1,
_x2,
_y2,
_z2,
_overwrite=False):
_series_image_path = paths.serieses(_experiment, _series_id)
_image_properties = load.image_properties(_experiment, _series_id)
_series_image = tifffile.imread(_series_image_path)
_cells_coordinates = [[
(_x1, _y1, _z1) for _time_frame in range(_series_image.shape[0])
], [(_x2, _y2, _z2) for _time_frame in range(_series_image.shape[0])]]
_series_image_by_time_frames = [
np.array([
_z[IMAGE_FIBER_CHANNEL_INDEX] for _z in _series_image[_time_frame]
]) for _time_frame in range(_series_image.shape[0])
]
process_group(_experiment=_experiment,
_series_id=_series_id,
_cells_coordinates=_cells_coordinates,
_cell_1_id=0,
_cell_2_id=1,
_series_image_by_time_frames=_series_image_by_time_frames,
_resolutions=_image_properties['resolutions'],
_real_cells=False,
_fake_cell_1_id=_cell_1_id,
_fake_cell_2_id=_cell_2_id,
_overwrite=_overwrite)
def read_image(filepath_or_buffer: typing.Union[str, io.BytesIO]):
"""Read a file into an image object
Args:
filepath_or_buffer: The path to the file, a URL, or any object
with a `read` method (such as `io.BytesIO`)
"""
import cv2
import tifffile.tifffile
import validators
if isinstance(filepath_or_buffer, np.ndarray):
return filepath_or_buffer
if hasattr(filepath_or_buffer, 'read'):
image = np.asarray(bytearray(filepath_or_buffer.read()),
dtype=np.uint8)
image = cv2.imdecode(image, cv2.IMREAD_UNCHANGED)
elif isinstance(filepath_or_buffer, str):
if validators.url(filepath_or_buffer):
return read(urllib.request.urlopen(filepath_or_buffer))
assert os.path.isfile(filepath_or_buffer), \
'Could not find image at path: ' + filepath_or_buffer
if filepath_or_buffer.endswith('.tif') or filepath_or_buffer.endswith(
'.tiff'):
image = tifffile.imread(filepath_or_buffer)
else:
image = cv2.imread(filepath_or_buffer)
return cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
def main():
parser = argparse.ArgumentParser(description=_description)
parser.add_argument('--output', '-o', metavar='normalized.tif',
default='normalized.tif', help='Output filename')
parser.add_argument(
'--subtract', action='store_true',
help='Subtract background instead of dividing and truncating')
parser.add_argument('infile')
args = parser.parse_args()
infile = args.infile
print 'Reading image stack'
t = tf.TiffFile(infile)
ar = tf.stack_pages(t.pages)
n = ar.shape[0]
percentile = 0.01 if args.subtract else 0.05
if os.path.exists('background.tif'):
print 'Reading background image'
bg = tf.imread('background.tif')
else:
print 'Computing background image'
sorted_ar = ar.copy()
sorted_ar.sort(0)
bg = sorted_ar[int(round(percentile*n, 0))]
print 'Saving background image'
tf.imsave('background.tif', bg)
del sorted_ar
print 'Performing background normalization'
if not args.subtract:
ar = ar.astype(np.double)
for i in range(n):
ar[i] /= bg
print 'Converting to 16-bit TIFF'
max_normed = (4095.0 / bg.min()) - 1
ar -= 1
ar *= 65535
ar /= max_normed
ar = ar.round()
else:
ar = ar.astype(np.int16)
for i in range(n):
ar[i] -= bg
ar[ar < 0] = 0
ar = ar.astype(np.uint16)
print 'Writing normalized image'
with tf.TiffWriter(args.output) as out:
for i in range(n):
if (i % 100) == 0:
print i,
sys.stdout.flush()
out.save(ar[i])
print
def setup_tile_filtering(first_img_path):
plane = tifffile.imread(first_img_path)
plane = plane.T
max_value = get_max_value(plane)
clipping_value = max_value - 2
thrsh_val = max_value - 1
return clipping_value, thrsh_val
def convert_tiff_tiling(input_filename, description):
tile_size = (256, 256)
image = tifffile.imread(input_filename)[:, :, 0:3]
path_ext = os.path.splitext(input_filename)
output_filename = path_ext[0] + '.jpeg' + path_ext[1]
with tifffile.TiffWriter(output_filename) as tiff:
tiff.save(image,
tile=tile_size,
compression='JPEG',
description=description)
def for_each_file(f):
# for f in tqdm(glob.glob('../Data/LongTermStudy/Orthomosaics/Georeferenced/' + '*.tif')):
##Getting filenames
fullname = os.path.split(f)[1]
filename = os.path.splitext(fullname)[0]
##Getting Day of Year
find_date = re.compile(r"_([0-9]+-[0-9]+-[0-9]+)_")
date = find_date.search(filename).group(1)
doy = datetime.strptime(date, '%d-%m-%y').timetuple().tm_yday
##Reading 16 bit ITC tiff file and bgr image
treecrowns = tiff.imread("../Data/LongTermStudy/Templates/NewGeoref/" + filename + "_ITC.tif")
img_bgr = cv2.imread(f)
img = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)
##Extract tree crowns
print("Extracting Tree Crowns")
def extract_trees(tree):
# for tree in tqdm(set(rawdata["Tree_Crown_ID"])):
##Find tree in image
locations = np.where(treecrowns == tree)
xmin = locations[0].min()
xmax = locations[0].max()
ymin = locations[1].min()
ymax = locations[1].max()
##Find boundary
#Take tree from boundary
boundary = treecrowns[xmin:xmax, ymin:ymax] != tree
values = img[xmin:xmax, ymin:ymax]
values[boundary, ] = 0
##Finding largest shape
# shapes.append(boundary.shape)
##Expand Mask dynamically
Max = (340, 320)
bshape = boundary.shape
xchange = Max[0] - bshape[0]
ychange = Max[1] - bshape[1]
expval = np.pad(values, ((0, xchange),(0,ychange), (0,0)), 'constant', constant_values=0)
# expval = np.concatenate((values, np.zeros(xchange, ychange)),-1)
##Convert back to rgb
Values = cv2.cvtColor(expval, cv2.COLOR_BGR2RGB)
##Saving file if does not exist
newfile = "../Data/LongTermStudy/CNN/ExtractedTrees/"+format(tree, '03d')+"_"+date+"_"+str(format(doy, '03d'))+".png"
if not os.path.isfile(newfile):
cv2.imwrite(newfile, Values)
[extract_trees(tree) for tree in tqdm(set(rawdata["Tree_Crown_ID"]))]
def series_image(_experiment, _series_id, _fiber_channel=True):
_series_image_path = paths.serieses(_experiment, _series_id)
_series_image = tifffile.imread(_series_image_path)
if _fiber_channel:
return np.array([
np.array([
_z[IMAGE_FIBER_CHANNEL_INDEX]
for _z in _series_image[_time_frame]
]) for _time_frame in range(_series_image.shape[0])
])
else:
return _series_image
def load_mask_one_layer(self, image_id, relabel=False):
mask = tifffile.imread(self.mask_path[self.ids[image_id]])
if (mask.ndim > 2):
mask = mask[:, :, 0]
if (relabel):
mask_tmp = np.zeros((mask.shape[0], mask.shape[1]))
running = 1
for i in np.unique(mask):
if i > 0:
mask_tmp = mask_tmp + running * (mask == i)
running = running + 1
mask = mask_tmp.astype(np.float)
return mask #mask.astype(np.float)
def __getitem__(self, index):
patch_dir, label, name = self.images[index]
image = tifffile.imread(os.path.join(patch_dir, 'image.tif'))
out = {'name': name, 'label': torch.tensor(label).long()}
if self.is_segmentation:
mask = self.load_mask(patch_dir)
transformed = self.transform(image=image, mask=mask)
out['img'] = transformed['image']
out['mask'] = transformed['mask']
else:
out['img'] = self.transform(image=image)['image']
return out
def try_image_to_kitti():
# loading data
directory = r'D:\output-datasets\offroad-14\1'
base_name = '000084'
rgb_file = os.path.join(directory, '{}.jpg'.format(base_name))
depth_file = os.path.join(directory, '{}-depth.tiff'.format(base_name))
stencil_file = os.path.join(directory, '{}-stencil.png'.format(base_name))
json_file = os.path.join(directory, '{}.json'.format(base_name))
rgb = np.array(Image.open(rgb_file))
depth = tifffile.imread(depth_file)
stencil = np.array(Image.open(stencil_file))
with open(json_file) as f:
data = json.load(f)
# creating pointcloud for original data
csv_name = base_name + '-orig'
vecs, _ = points_to_homo(data, depth, tresholding=False)
vecs_p = ndc_to_view(vecs, data['proj_matrix'])
vecs_p_world = view_to_world(vecs_p, np.array(data['view_matrix']))
a = np.asarray(vecs_p_world[0:3, :].T)
np.savetxt(os.path.join('kitti-format', "points-{}.csv".format(csv_name)), a, delimiter=",")
# whole gta to kitti transformation
rgb, depth, stencil = image_gta_to_kitti(rgb, depth, stencil, data['width'], data['height'], data['camera_fov'])
data['proj_matrix'] = get_kitti_proj_matrix(np.array(data['proj_matrix'])).tolist()
data['width'], data['height'] = get_kitti_img_size()
# saving new images
Image.fromarray(rgb).convert(mode="RGB").save(os.path.join('kitti-format', '{}.jpg'.format(base_name)))
tifffile.imsave(os.path.join('kitti-format', '{}-depth-orig.tiff'.format(base_name)), depth)
tifffile.imsave(os.path.join('kitti-format', '{}-depth-lzma.tiff'.format(base_name)), depth, compress='lzma')
tifffile.imsave(os.path.join('kitti-format', '{}-depth-zip-5.tiff'.format(base_name)), depth, compress=5)
tifffile.imsave(os.path.join('kitti-format', '{}-depth-zip-9.tiff'.format(base_name)), depth, compress=9)
tifffile.imsave(os.path.join('kitti-format', '{}-depth-zip-zstd.tiff'.format(base_name)), depth, compress='zstd')
Image.fromarray(stencil).save(os.path.join('kitti-format', '{}-stencil.jpg'.format(base_name)))
with open(os.path.join('kitti-format', '{}.json'.format(base_name)), 'w+') as f:
json.dump(data, f)
data['view_matrix'] = np.array(data['view_matrix'])
check_proj_matrices(depth, data)
# creating pointcloud for kitti format data
csv_name = base_name + '-kitti'
vecs, _ = points_to_homo(data, depth, tresholding=False)
vecs_p = ndc_to_view(vecs, data['proj_matrix'])
vecs_p_world = view_to_world(vecs_p, np.array(data['view_matrix']))
a = np.asarray(vecs_p_world[0:3, :].T)
np.savetxt(os.path.join('kitti-format', "points-{}.csv".format(csv_name)), a, delimiter=",")
def loadimage(filename: str) -> np.array:
# Read image.
img = tiff.imread(filename)
# Crop images.
# img = img[0:30, 80:-100, 80:-100]
img = img[0:3, 100:200, 100:200]
# Filter each frame.
for k in range(img.shape[0]):
img[k] = ndimage.gaussian_filter(img[k], sigma=1)
# Normalise to [0, 1].
img = np.array(img, dtype=float)
img = (img - img.min()) / (img.max() - img.min())
return img
def main():
_experiment = 'SN41'
_series_id = 3
_group = 'static_0_1'
_x1, _y1, _z1 = 23, 226, 10
_x2, _y2, _z2 = 228, 226, 10
_time_frame = 34
_series_image_path = paths.serieses(_experiment, _series_id)
_image_properties = load.image_properties(_experiment, _series_id)
_series_image = tifffile.imread(_series_image_path)
_series_image_by_time_frames = [
np.array([
_z[IMAGE_FIBER_CHANNEL_INDEX] for _z in _series_image[_time_frame]
]) for _time_frame in range(_series_image.shape[0])
]
plt.imshow(_series_image_by_time_frames[_time_frame][30])
plt.show()
def load_image(self, image_id):
info = self.image_info[image_id]
if self.img_postfix == '.jpg':
img_final = cv2.imread(self.image_path[self.ids[image_id]])
else:
img_final = tifffile.imread(self.image_path[self.ids[image_id]])
try:
img_final = img_final[:, :, 0]
except:
None
#return img_final / 255.0
if self.settings.network_info[
"netinfo"] == 'maskrcnn': # mask rcnn need an rgb image
img_new = np.zeros((img_final.shape[0], img_final.shape[1], 3))
img_new[:, :, 0] = img_new[:, :, 1] = img_new[:, :, 2] = img_final
img_final = img_new
return img_final
def return_opm_psf(wavelength_um):
"""
Load pre-generated OPM psf
TO DO: write checks and generate PSF if it does not exist on disk
:param wavelength: float
wavelength in um
:return psf: ndarray
pre-generated skewed PSF
"""
wavelength_nm = int(np.round(wavelength_um * 1000, 0))
psf_path = Path('opm_psf_' + str(wavelength_nm).zfill(0) + '_nm.tif')
opm_psf = tifffile.imread(psf_path)
return opm_psf
def process(
self,
plane_id,
path,
previous_lock,
self_lock,
clipping_value,
threshold_value,
soma_diameter,
log_sigma_size,
n_sds_above_mean_thresh,
):
laplace_gaussian_sigma = log_sigma_size * soma_diameter
plane = tifffile.imread(path)
plane = plane.T
np.clip(plane, 0, clipping_value, out=plane)
walker = TileWalker(plane, soma_diameter, threshold_value)
walker.walk_out_of_brain_only()
thresholded_img = enhance_peaks(
walker.thresholded_img,
clipping_value,
gaussian_sigma=laplace_gaussian_sigma,
)
# threshold
avg = thresholded_img.ravel().mean()
sd = thresholded_img.ravel().std()
plane[
thresholded_img > avg + n_sds_above_mean_thresh * sd
] = threshold_value
tile_mask = walker.good_tiles_mask.astype(np.uint8)
with previous_lock:
pass
self.ball_filter_q.put((plane_id, plane, tile_mask))
self.thread_q.put(plane_id)
self_lock.release()
def load_mask(self, image_id):
"""Generate instance masks for shapes of the given image ID.
"""
info = self.image_info[image_id]
mask = tifffile.imread(self.mask_path[self.ids[image_id]])
count = 0
for i in range(1, int(mask.max()) + 1):
if ((mask == i).sum() > 0):
count = count + 1
# prepare image for net
#count = int(mask.max())
mask_new = np.zeros([info['height'], info['width'], count + 1],
dtype=np.uint8) # one more for background
running = 0
for i in np.unique(mask): #range(1, count):
if ((i > 0) & ((mask == i).sum() > 0)):
mask_new[:, :, running] = (mask == i)
running = running + 1
# Map class names to class IDs.
class_ids = np.ones(count)
return mask_new, class_ids.astype(np.int32)
def load_mask(self, image_id):
"""Generate instance masks for shapes of the given image ID.
"""
info = self.image_info[image_id]
mask = tifffile.imread(self.mask_path[self.ids[image_id]])
if np.unique(mask).__len__() > 1:
count = np.unique(mask).__len__() - 1 # one less because of 0
mask_new = np.zeros([info['height'], info['width'], count],
dtype=np.uint8) # one more for background
running = 0
for i in np.unique(mask): #range(1, count):
if ((i > 0) & ((mask == i).sum() > 0)):
mask_new[:, :, running] = (mask == i)
running = running + 1
# Map class names to class IDs.
class_ids = np.ones(count)
else:
mask_new = np.zeros([info['height'], info['width'], 1],
dtype=np.uint8)
class_ids = np.zeros([1])
return mask_new, class_ids.astype(np.int32)
colored_membrane = cv2.cvtColor(layers['membrane'], cv2.COLOR_GRAY2BGR)
cv2.drawContours(colored_membrane,
[np.array(line, np.int32) for line in all_revised_lines],
-1, (255, 100, 0), 1)
# draw each length
for i in range(len(all_revised_lines)):
cv2.putText(colored_membrane, str(all_widths[i]),
(all_revised_lines[i][0][0], all_revised_lines[i][0][1]),
cv2.FONT_HERSHEY_PLAIN, 1, (0, 100, 255), 1, cv2.LINE_AA,
False)
show(colored_membrane)
# show(testing)
def proc_layers(image):
return {'membrane': image[0], 'edge': image[2]}
if __name__ == '__main__':
files = list(glob.glob(FOLDER + os.path.sep + '*.tiff'))
for file in files:
name = os.path.basename(file)
print('Testing on file %s' % name)
# open image
image = tifffile.imread(file)
layers = proc_layers(image)
simplify_membrane_edge(layers)
def test_tiff_io(tmpdir, layer):
folder = str(tmpdir)
dest_path = os.path.join(folder, "layer.tiff")
tifffile.imsave(dest_path, layer)
reloaded = tifffile.imread(dest_path)
assert (reloaded == layer).all()
def test_cube_extraction(tmpdir, depth=20):
tmpdir = str(tmpdir)
args = CubeExtractArgs(tmpdir)
planes_paths = {}
planes_paths[0] = get_sorted_file_paths(signal_data_dir,
file_extension="tif")
planes_paths[1] = get_sorted_file_paths(background_data_dir,
file_extension="tif")
extract_cubes.main(
get_cells(args.paths.cells_file_path),
args.paths.tmp__cubes_output_dir,
planes_paths,
args.cube_depth,
args.cube_width,
args.cube_height,
args.voxel_sizes,
args.network_voxel_sizes,
args.max_ram,
args.n_free_cpus,
args.save_empty_cubes,
)
validation_cubes = load_cubes_in_dir(validate_cubes_dir)
test_cubes = load_cubes_in_dir(tmpdir)
for idx, test_cube in enumerate(test_cubes):
assert (validation_cubes[idx] == test_cube).all()
delete_directory_contents(tmpdir)
# test cube scaling
args.voxel_sizes = [7.25, 2, 2]
args.x_pixel_um = 2
args.y_pixel_um = 2
args.z_pixel_um = 7.25
extract_cubes.main(
get_cells(args.paths.cells_file_path),
args.paths.tmp__cubes_output_dir,
planes_paths,
args.cube_depth,
args.cube_width,
args.cube_height,
args.voxel_sizes,
args.network_voxel_sizes,
args.max_ram,
args.n_free_cpus,
args.save_empty_cubes,
)
validation_cubes_scale = load_cubes_in_dir(validate_cubes_scale_dir)
test_cubes = load_cubes_in_dir(tmpdir)
for idx, test_cube in enumerate(test_cubes):
assert (validation_cubes_scale[idx] == test_cube).all()
# test edge of data errors
cell = Cell("x0y0z10", 2)
plane_paths = os.listdir(signal_data_dir)
first_plane = tifffile.imread(os.path.join(signal_data_dir,
plane_paths[0]))
stack_shape = first_plane.shape + (depth, )
stacks = {}
stacks[0] = np.zeros(stack_shape, dtype=np.uint16)
stacks[0][:, :, 0] = first_plane
for plane in range(1, depth):
im_path = os.path.join(signal_data_dir, plane_paths[plane])
stacks[0][:, :, plane] = tifffile.imread(im_path)
cube = extract_cubes.Cube(cell, 0, stacks)
assert (cube.data == 0).all()
cell = Cell("x2500y2500z10", 2)
cube = extract_cubes.Cube(cell, 0, stacks)
assert (cube.data == 0).all()
# test insufficient z-planes for a specific cube
stacks[0] = stacks[0][:, :, 1:]
cube = extract_cubes.Cube(cell, 0, stacks)
assert (cube.data == 0).all()
# test insufficient z-planes for any cube to be extracted at all.
delete_directory_contents(tmpdir)
# args.z_pixel_um = 0.1
args.voxel_sizes[0] = 0.1
with pytest.raises(extract_cubes.StackSizeError):
extract_cubes.main(
get_cells(args.paths.cells_file_path),
args.paths.tmp__cubes_output_dir,
planes_paths,
args.cube_depth,
args.cube_width,
args.cube_height,
args.voxel_sizes,
args.network_voxel_sizes,
args.max_ram,
args.n_free_cpus,
args.save_empty_cubes,
)
def __init__(self, paths, fn, fn_mapping, has_alpha):
super().__init__(paths, fn, fn_mapping, has_alpha)
# print(Path(self.paths['images']).joinpath(self.fn).resolve())
# self.im = imread(os.path.join(self.paths['images'], self.fn), mode='RGB')
self.im = tifffile.imread(os.path.join(self.paths['images'], self.fn))
self.im = np.dstack((self.im, self.im, self.im))
def __get_image_size(self):
self.image_z_size = len(self.signal_planes)
first_plane = tifffile.imread(self.signal_planes[0])
self.image_height, self.image_width = first_plane.shape
img = np.array(img, dtype=float)
img = (img - img.min()) / (img.max() - img.min())
return img
# Figure 1: output frames for one dataset.
gen = 'SqAX3_SqhGFP42_GAP43_TM6B'
dat = 'E2PSB1'
frames = [4, 6, 10, 20, 40, 60, 80, 90]
# Output frames.
datfolder = os.path.join(datapath, os.path.join(gen, dat))
seq = glob.glob('{0}/{1}*.tif'.format(datfolder, dat))
if len(seq) != 1:
warnings.warn("No sequence found!")
img = tiff.imread(seq)
# Output each frame.
for k in frames:
if len(img.shape) is 4:
frame = img[0, k]
else:
frame = img[k]
filepath = os.path.join(os.path.join(resultpath, gen), dat)
ph.saveimage_nolegend(filepath, '{0}-{1}'.format(dat, k), frame)
# Figure 2: load and output kymograph.
img, name = load_kymo(datfolder, dat)
# Plot and save figures.
ph.saveimage(os.path.join(*[resultpath, gen, dat]), name, img)
def main(
cells,
cubes_output_dir,
planes_paths,
cube_depth,
cube_width,
cube_height,
voxel_sizes,
network_voxel_sizes,
max_ram,
n_free_cpus=4,
save_empty_cubes=False,
):
start_time = datetime.now()
if voxel_sizes[0] != network_voxel_sizes[0]:
plane_scaling_factor = float(network_voxel_sizes[0]) / float(
voxel_sizes[0]
)
num_planes_needed_for_cube = round(cube_depth * plane_scaling_factor)
else:
num_planes_needed_for_cube = cube_depth
if num_planes_needed_for_cube > len(planes_paths[0]):
raise StackSizeError(
"The number of planes provided is not sufficient "
"for any cubes to be extracted. Please check the "
"input data"
)
first_plane = tifffile.imread(list(planes_paths.values())[0][0])
planes_shape = first_plane.shape
brain_depth = len(list(planes_paths.values())[0])
# TODO: use to assert all centre planes processed
center_planes = sorted(list(set([cell.z for cell in cells])))
# REFACTOR: rename (clashes with different meaning of planes_to_read below)
planes_to_read = np.zeros(brain_depth, dtype=np.bool)
if is_even(num_planes_needed_for_cube):
half_nz = num_planes_needed_for_cube // 2
# WARNING: not centered because even
for p in center_planes:
planes_to_read[p - half_nz : p + half_nz] = 1
else:
half_nz = num_planes_needed_for_cube // 2
# centered
for p in center_planes:
planes_to_read[p - half_nz : p + half_nz + 1] = 1
planes_to_read = np.where(planes_to_read)[0]
if not planes_to_read.size:
logging.error(
f"No planes found, you need at the very least "
f"{num_planes_needed_for_cube} "
f"planes to proceed (i.e. cube z size)"
f"Brain z dimension is {brain_depth}.",
stack_info=True,
)
raise ValueError(
f"No planes found, you need at the very least "
f"{num_planes_needed_for_cube} "
f"planes to proceed (i.e. cube z size)"
f"Brain z dimension is {brain_depth}."
)
# TODO: check if needs to flip args.cube_width and args.cube_height
cells_groups = group_cells_by_z(cells)
# copies=2 is set because at all times there is a plane queue (deque)
# and an array passed to `Cube`
ram_per_process = get_ram_requirement_per_process(
planes_paths[0][0],
num_planes_needed_for_cube,
copies=2,
)
n_processes = get_num_processes(
min_free_cpu_cores=n_free_cpus,
ram_needed_per_process=ram_per_process,
n_max_processes=len(planes_to_read),
fraction_free_ram=0.2,
max_ram_usage=system.memory_in_bytes(max_ram, "GB"),
)
# TODO: don't need to extract cubes from all channels if
# n_signal_channels>1
with ProcessPoolExecutor(max_workers=n_processes) as executor:
n_planes_per_chunk = len(planes_to_read) // n_processes
for i in range(n_processes):
start_idx = i * n_planes_per_chunk
end_idx = (
start_idx + n_planes_per_chunk + num_planes_needed_for_cube - 1
)
if end_idx > planes_to_read[-1]:
end_idx = None
sub_planes_to_read = planes_to_read[start_idx:end_idx]
executor.submit(
save_cubes,
cells_groups,
planes_paths,
sub_planes_to_read,
planes_shape,
voxel_sizes,
network_voxel_sizes,
num_planes_for_cube=num_planes_needed_for_cube,
cube_width=cube_width,
cube_height=cube_height,
cube_depth=cube_depth,
thread_id=i,
output_dir=cubes_output_dir,
save_empty_cubes=save_empty_cubes,
)
total_cubes = system.get_number_of_files_in_dir(cubes_output_dir)
time_taken = datetime.now() - start_time
logging.info(
"All cubes ({}) extracted in: {}".format(total_cubes, time_taken)
)
rings_per_frame = {}
for t in tracks:
for n,x,y in t:
# if n != 5:
# continue
if n not in rings_per_frame.keys():
rings_per_frame[n] = [(x,y)]
else:
rings_per_frame[n].append((x,y))
for f in sorted(rings_per_frame.keys()):
img_path = '../data/raw/sample_b'
img_file_name = '{:05d}.tif'.format(int(f))
img_data = tif.imread(os.path.join(img_path, img_file_name))
centers = rings_per_frame[f]
for c in centers:
cx, cy = map(int, c)
for xx, yy, est_r in rings[int(f)]:
if abs(xx-cx) < 5 and abs(yy-cy) < 5:
break
plist = []
for _x in range(cx-1, cx+2):
for _y in range(cy-1, cy+2):
_, r, peak = radial_profile_simple(img_data, (_x,_y), est_r)
plist.append([r, peak, _x, _y])
# -*- coding: utf-8 -*-
"""
Created on Wed Sep 10 03:29:03 2014
@author: Indranil
"""
from __future__ import print_function, division
import numpy as np
import tifffile.tifffile as tf
import matplotlib.pyplot as plt
image = tf.imread('test.tif')
print(type(image))
print(image.shape)
print(image.dtype)
for i in range(3):
print(np.max(image[:,:,i]))
print(np.min(image[:,:,i]))
plt.imshow(image[:,:,1])
plt.show()
