def main(): parser = argparse.ArgumentParser(description=_description) parser.add_argument('--output', '-o', metavar='stitched_elisa.tif', default='stitched_elisa.tif') parser.add_argument('--saturationmap', '-s', metavar='saturated_elisa.tif', default='saturated_elisa.tif') parser.add_argument( 'original_image', help="Original MicroManager stack (used for metadata)") parser.add_argument( 'normalized_image', help="Normalized image (used for image data)") args = parser.parse_args() orig_fn = args.original_image bgsub_fn = args.normalized_image print 'Reading metadata.' with open(orig_fn, 'rb') as f: metadata = tf.read_micromanager_metadata(f) print('Loading original image.') with tf.TiffFile(bgsub_fn) as bgsub_img: bgsub = np.concatenate([page.asarray()[np.newaxis,:] for page in bgsub_img.pages]) canvas = stitch(metadata, bgsub) print('Saving image.') tf.imsave(args.output, canvas) del canvas, bgsub print('Computing saturation map.') with tf.TiffFile(orig_fn) as bgsub_img: orig = np.concatenate([page.asarray()[np.newaxis,:] for page in bgsub_img.pages]) saturated = (orig == 4095) canvas = (stitch(metadata, saturated) > 0).astype(np.uint8) tf.imsave(args.saturationmap, canvas)
def main(): parser = argparse.ArgumentParser(description=_description) parser.add_argument('--output', '-o', metavar='stitched_elisa.tif', default='stitched_elisa.tif') parser.add_argument('--saturationmap', '-s', metavar='saturated_elisa.tif', default='saturated_elisa.tif') parser.add_argument( 'original_image', help="Original MicroManager stack (used for metadata)") parser.add_argument( 'normalized_image', help="Normalized image (used for image data)") args = parser.parse_args() orig_fn = args.original_image bgsub_fn = args.normalized_image print 'Reading metadata.' with open(orig_fn, 'rb') as f: metadata = tf.read_micromanager_metadata(f) print('Loading original image.') with tf.TiffFile(bgsub_fn) as bgsub_img: bgsub = np.concatenate([page.asarray()[np.newaxis, :] for page in bgsub_img.pages]) canvas = stitch(metadata, bgsub) print('Saving image.') tf.imsave(args.output, canvas) del canvas, bgsub print('Computing saturation map.') with tf.TiffFile(orig_fn) as bgsub_img: orig = np.concatenate([page.asarray()[np.newaxis, :] for page in bgsub_img.pages]) saturated = (orig == 4095) canvas = (stitch(metadata, saturated) > 0).astype(np.uint8) tf.imsave(args.saturationmap, canvas)
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 crop_tiffs(self): self.images = [] self.file_list = [] for plane in list(range(self.planes)): time_slice = slice(plane*self.channels+self.channel2use, -1, self.channels*self.planes) with ScanImageTiffReader(self.tiff) as reader: data = reader.data() data = data[time_slice, : , self.xslice] self.images.append(data) tif_name = self.tiff.split('.')[0] + '_template_plane' + str(plane) + '.tif' self.file_list.append(tif_name) tifffile.imsave(tif_name, data)
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 crop(self, data, no_boxes=2, save_dir=None): # Extract bounding boxes and crop data raw, pred, filenames, bboxes = self.get_bounding_boxes( data, no_boxes=no_boxes, save_dir=save_dir) cropped = apply_to_batch([raw, bboxes], 'crop') # crop the raw images print "Saving crop regions..." if save_dir: for crop_boxes, filename in zip(cropped, filenames): for i, region in enumerate(crop_boxes): imsave(join(save_dir, filename + '_{}.tiff'.format(i)), region) return cropped
def singlet_image(self, tmpdir_factory): a = np.zeros((256, 256), dtype=np.uint8) size = 20 # singlet a[20:20+size+1, 20:20+size+1] = 255 # doublet a[100:100+size+1, 100:100+size+1] = 255 offset = 100 + size + 10 a[100:100+size+1, offset:offset+size+1] = 255 # duplicate into second channel im = np.concatenate([a[np.newaxis, :], a[np.newaxis, :]]) filename = tmpdir_factory.mktemp('data').join('img.tif') tf.imsave(str(filename), im) return filename
def test_2x2(tmpdir): metadata = { 'summary': { 'InitialPositionList': [{'GridRowIndex': r, 'GridColumnIndex': c} for (r, c) in zip([0, 0, 1, 1], [0, 1, 0, 1])], 'Height': 100, 'Width': 100, } } stack = np.ones(shape=(4, 100, 100), dtype=np.uint16) * 128 canvas = stitch.stitch(metadata, stack) tf.imsave(str(tmpdir.join('2x2.tif')), canvas) delta = np.abs(canvas[11:-11, 11:-11].astype(np.int32) - 128) assert np.all(delta < 2)
def test_1x1(tmpdir): metadata = { 'summary': { 'InitialPositionList': [{'GridRowIndex': 0, 'GridColumnIndex': 0}], 'Height': 100, 'Width': 100, } } stack = np.ones(shape=(1, 100, 100), dtype=np.uint16) * 128 canvas = stitch.stitch(metadata, stack) tf.imsave(str(tmpdir.join('1x1.tif')), canvas) # center is uniform assert np.all(canvas[11:-11, 11:-11] == 128) # vignetting is symmetric assert np.all(canvas[50, :] == canvas[50, ::-1]) assert np.all(canvas[:, 50] == canvas[::-1, 50])
def test_2x2(tmpdir): metadata = { 'summary': { 'InitialPositionList': [{ 'GridRowIndex': r, 'GridColumnIndex': c } for (r, c) in zip([0, 0, 1, 1], [0, 1, 0, 1])], 'Height': 100, 'Width': 100, } } stack = np.ones(shape=(4, 100, 100), dtype=np.uint16) * 128 canvas = stitch.stitch(metadata, stack) tf.imsave(str(tmpdir.join('2x2.tif')), canvas) delta = np.abs(canvas[11:-11, 11:-11].astype(np.int32) - 128) assert np.all(delta < 2)
def test_1x1(tmpdir): metadata = { 'summary': { 'InitialPositionList': [{ 'GridRowIndex': 0, 'GridColumnIndex': 0 }], 'Height': 100, 'Width': 100, } } stack = np.ones(shape=(1, 100, 100), dtype=np.uint16) * 128 canvas = stitch.stitch(metadata, stack) tf.imsave(str(tmpdir.join('1x1.tif')), canvas) # center is uniform assert np.all(canvas[11:-11, 11:-11] == 128) # vignetting is symmetric assert np.all(canvas[50, :] == canvas[50, ::-1]) assert np.all(canvas[:, 50] == canvas[::-1, 50])
def segment_nuclei(img=None, save=True, adaptive=False, color_image=False, load_from_direc=None, feature_to_load="feature_1", mask_location=None, threshold=0.5, area_threshold=50, eccentricity_threshold=1, solidity_threshold=0): # Requires a 4 channel image (number of frames, number of features, image width, image height) from skimage.filters import threshold_otsu, threshold_adaptive if load_from_direc is None: img = img[:, 1, :, :] nuclear_masks = np.zeros(img.shape, dtype=np.float32) if load_from_direc is not None: img_files = nikon_getfiles(load_from_direc, feature_to_load) img_size = get_image_sizes(load_from_direc, feature_to_load) img = np.zeros((len(img_files), img_size[0], img_size[1]), dtype=np.float32) nuclear_masks = np.zeros((len(img_files), img.shape[1], img.shape[2]), dtype=np.float32) counter = 0 for name in img_files: img[counter, :, :] = get_image(os.path.join(load_from_direc, name)) counter += 1 for frame in xrange(img.shape[0]): interior = img[frame, :, :] if adaptive: block_size = 61 nuclear_mask = np.float32( threshold_adaptive(interior, block_size, method='median', offset=-.075)) else: nuclear_mask = np.float32(interior > threshold) nuc_label = label(nuclear_mask) max_cell_id = np.amax(nuc_label) for cell_id in xrange(1, max_cell_id + 1): img_new = nuc_label == cell_id img_fill = binary_fill_holes(img_new) nuc_label[img_fill == 1] = cell_id region_temp = regionprops(nuc_label) for region in region_temp: if region.area < area_threshold: nuclear_mask[nuc_label == region.label] = 0 if region.eccentricity > eccentricity_threshold: nuclear_mask[nuc_label == region.label] = 0 if region.solidity < solidity_threshold: nuclear_mask[nuc_label == region.label] = 0 nuclear_masks[frame, :, :] = nuclear_mask if save: img_name = os.path.join(mask_location, "nuclear_mask_" + str(frame) + ".png") tiff.imsave(img_name, nuclear_mask) if color_image: img_name = os.path.join(mask_location, "nuclear_colorimg_" + str(frame) + ".png") from skimage.segmentation import find_boundaries import palettable from skimage.color import label2rgb seg = label(nuclear_mask) bound = find_boundaries(seg, background=0) image_label_overlay = label2rgb( seg, bg_label=0, bg_color=(0.8, 0.8, 0.8), colors=palettable.colorbrewer.sequential.YlGn_9.mpl_colors) image_label_overlay[bound == 1, :] = 0 scipy.misc.imsave(img_name, np.float32(image_label_overlay)) return nuclear_masks
def segment_cytoplasm(img=None, save=True, load_from_direc=None, feature_to_load="feature_1", color_image=False, nuclear_masks=None, mask_location=None, smoothing=1, num_iters=80): if load_from_direc is None: cytoplasm_masks = np.zeros((img.shape[0], img.shape[2], img.shape[3]), dtype=np.float32) img = img[:, 1, :, :] if load_from_direc is not None: img_files = nikon_getfiles(load_from_direc, feature_to_load) img_size = get_image_sizes(load_from_direc, feature_to_load) img = np.zeros((len(img_files), img_size[0], img_size[1]), dtype=np.float32) cytoplasm_masks = np.zeros( (len(img_files), img.shape[1], img.shape[2]), dtype=np.float32) counter = 0 for name in img_files: img[counter, :, :] = get_image(os.path.join(load_from_direc, name)) counter += 1 for frame in xrange(img.shape[0]): interior = img[frame, :, :] nuclei = nuclear_masks[frame, :, :] nuclei_label = label(nuclei, background=0) seg = segment_image_w_morphsnakes(interior, nuclei_label, num_iters=num_iters, smoothing=smoothing) seg[seg == 0] = -1 cytoplasm_mask = np.zeros(seg.shape, dtype=np.float32) max_cell_id = np.amax(seg) for cell_id in xrange(1, max_cell_id + 1): img_new = seg == cell_id img_fill = binary_fill_holes(img_new) cytoplasm_mask[img_fill == 1] = 1 cytoplasm_masks[frame, :, :] = cytoplasm_mask if save: img_name = os.path.join(mask_location, "cytoplasm_mask_" + str(frame) + ".png") tiff.imsave(img_name, np.float32(cytoplasm_mask)) if color_image: img_name = os.path.join( mask_location, "cytoplasm_colorimg_" + str(frame) + ".png") from skimage.segmentation import find_boundaries import palettable from skimage.color import label2rgb seg = label(cytoplasm_mask) bound = find_boundaries(seg, background=0) image_label_overlay = label2rgb( seg, bg_label=0, bg_color=(0.8, 0.8, 0.8), colors=palettable.colorbrewer.sequential.YlGn_9.mpl_colors) image_label_overlay[bound == 1, :] = 0 scipy.misc.imsave(img_name, np.float32(image_label_overlay)) return cytoplasm_masks
def main(): parser = argparse.ArgumentParser(description='Train model.') parser.add_argument('--tissue', help='select tissue to train.', default=None) parser.add_argument('--inputFolder', help='Select input folder.', default=None) parser.add_argument('--outputFolder', help='select output folder', default=None) parser.add_argument('--nr_images', help='select number of images to create', default=None) parser.add_argument('--overlapProbability', help='select overlapProbability', default=None) parser.add_argument('--scale', help='select output folder', default=None) args = parser.parse_args() tisquant = TisQuantExtract() config = Config if args.tissue: config.diagnosis = [args.tissue] if args.outputFolder: config.outputFolder = args.outputFolder if args.overlapProbability: args.overlapProbability = float(args.overlapProbability) else: args.overlapProbability = 0.5 if args.scale == '1': config.scale = True print(config.diagnosis) tools = Tools() annotated_nuclei = AnnotatedObjectSet() annotated_images = [] #ids_paths = tisquant.dbconnector.execute(query=tisquant.getLevel3AnnotatedImagesByDiagnosis_Query(diagnosis = config.diagnosis,magnification = config.magnification, staining_type = config.staining_type, staining = config.staining, segmentation_function = config.segmentation_function, annotator = config.annotator, device = config.device)) ids_images = glob.glob( os.path.join(args.inputFolder, config.diagnosis[0], 'images', '*.tif')) ids_masks = glob.glob( os.path.join(args.inputFolder, config.diagnosis[0], 'masks', '*.tif')) #for index,elem in enumerate(ids_paths): for index, elem in enumerate(ids_images): #groundtruth_paths = tisquant.dbconnector.execute(tisquant.getLevel3AnnotationByImageId_Query(elem[0],config.annotator)) #groundtruth_paths = tisquant.dbconnector.execute(tisquant.getLevel3AnnotationByImageIdUsingMaxExperience_Query(elem[0], config.annotator)) #for groundtruth_path in groundtruth_paths: test = AnnotatedImage() # test.readFromPath(tools.getLocalDataPath(elem[1],1),tools.getLocalDataPath(groundtruth_path[0],3)) test.readFromPath(ids_images[index], ids_masks[index]) annotated_images.append(test) # Create artificial new dataset scales = tools.getNormalizedScales(annotated_images) for index, img in enumerate(annotated_images): test = AnnotatedImage() if config.scale: test.createWithArguments( tools.rescale_image(img.getRaw(), (scales[index], scales[index])), tools.rescale_mask(img.getMask(), (scales[index], scales[index]), make_labels=True)) else: test.createWithArguments(img.getRaw(), img.getMask()) annotated_nuclei.addObjectImage( test, useBorderObjects=config.useBorderObjects) if config.scale == 0: if args.tissue == 'Ganglioneuroma': possible_numbers = [9, 16, 25, 36, 49] else: possible_numbers = [4, 4, 9] else: possible_numbers = [9, 16, 25, 36, 49] # How many images? if not args.nr_images: args.nr_images = 10 else: args.nr_images = int(args.nr_images) for t in tqdm(range(0, args.nr_images)): # Create artificial image number_nuclei = random.randint(0, possible_numbers.__len__() - 1) img = ArtificialAnnotatedImage( width=256, height=256, number_nuclei=possible_numbers[number_nuclei], probabilityOverlap=args.overlapProbability) total_added = 0 for i in range(0, possible_numbers[number_nuclei]): test = annotated_nuclei.returnArbitraryObject() if (randint(0, 1)): test = tools.arbitraryEnhance(test) total_added += img.addImageAtGridPosition(test) if (total_added > 0): shape_y = img.getRaw().shape[0] shape_x = img.getRaw().shape[1] img_new = np.zeros((shape_y, shape_x * 2, 3), dtype=np.float32) img_new[:, 0:shape_x, 0] = img_new[:, 0:shape_x, 1] = img_new[:, 0:shape_x, 2] = img_new[:, shape_x:2 * shape_x, 0] = img_new[:, shape_x: 2 * shape_x, 1] = img_new[:, shape_x: 2 * shape_x, 2] = img.getRaw( ) scipy.misc.toimage( img_new, cmin=0.0, cmax=1.0).save(config.outputFolder + config.diagnosis[0] + '\\images\\Img_' + str(t) + '.jpg') tifffile.imsave(config.outputFolder + config.diagnosis[0] + '\\masks\\Mask_' + str(t) + '.tif', img.getMask(), dtype=np.uint8) e = 1
def save_cubes( cells, planes_paths, planes_to_read, planes_shape, voxel_sizes, network_voxel_sizes, num_planes_for_cube=20, cube_width=50, cube_height=50, cube_depth=20, thread_id=0, output_dir="", save_empty_cubes=False, ): """ :param cells: :param planes_paths: :param planes_to_read: :param planes_shape: :param x_pix_um: :param y_pix_um: :param x_pix_um_network: :param y_pix_um_network: :param num_planes_for_cube: :param cube_width: :param cube_height: :param cube_depth: :param thread_id: :param output_dir: :param save_empty_cubes: :return: """ channels = list(planes_paths.keys()) stack_shape = planes_shape + (num_planes_for_cube,) stacks = {} planes_queues = {} for ch in channels: stacks[ch] = np.zeros(stack_shape, dtype=np.uint16) planes_queues[ch] = deque(maxlen=num_planes_for_cube) for plane_idx in tqdm(planes_to_read, desc="Thread: {}".format(thread_id)): for ch in channels: plane_path = planes_paths[ch][plane_idx] planes_queues[ch].append(tifffile.imread(plane_path)) if len(planes_queues[ch]) == num_planes_for_cube: if is_even(num_planes_for_cube): cell_z = int(plane_idx - num_planes_for_cube / 2 + 1) else: cell_z = int( plane_idx - floor(num_planes_for_cube) / 2 + 1 ) for j, plane in enumerate(planes_queues[ch]): stacks[ch][:, :, j] = plane # ensures no cube_depth planes at the end planes_queues[ch].popleft() # required since we provide all cells # TODO: if len(planes_queues[ch]) # < num_planes_for_cube -1: break for cell in cells[cell_z]: cube = Cube( cell, ch, stacks, x_pix_um=voxel_sizes[2], y_pix_um=voxel_sizes[1], x_pix_um_network=network_voxel_sizes[2], y_pix_um_network=network_voxel_sizes[1], final_depth=cube_depth, width=cube_width, height=cube_height, depth=num_planes_for_cube, ) if not cube.empty or (cube.empty and save_empty_cubes): tifffile.imsave( os.path.join(output_dir, str(cube)), cube.data )
from Classes.Helper import SVGTools import matplotlib.pyplot as plt from tifffile import tifffile import glob import os diagnosis = ['normal', 'Neuroblastoma', 'Ganglioneuroma'] tool = SVGTools() for diag in diagnosis: ids_images = glob.glob( os.path.join( r"\\chubaka\home\florian.kromp\settings\desktop\nucleusanalyzer\FFG COIN VISIOMICS\Ongoing\Image groundtruth curation", diag, '*_svg.svg')) for img_path in ids_images: mask = tool.transformSVGToMaskNew(img_path) tifffile.imsave(img_path.replace('_svg.svg', '_mask.tif'), mask) #plt.imshow(tool.transformSVGToMaskNew(r"\\chubaka\home\florian.kromp\settings\desktop\nucleusanalyzer\FFG COIN VISIOMICS\Ongoing\Image groundtruth curation\Neuroblastoma\4471_svg.svg"))
fullsize = (float(a), float(a)) elif o == '-t': fmt = a else: assert False, "unknown option" image = np.zeros(fullsize) xs, ys = samplesize snr_ = [] for i in range(fullsize[0] / samplesize[0]): for j in range(fullsize[1] / samplesize[1]): sample, snr = gen_pattern(alpha) snr_.append(snr) print 'SNR : %.5f,' % snr, print 'Industrial SNR: %.3f db' % snr_ind(snr) image[i * xs:(i + 1) * xs, j * xs:(j + 1) * xs] = sample snr_ = np.array(snr_) print "Average SNR %.3f +/- %.3f (%.2f db)" % \ (snr_.mean(), snr_.std(), snr_ind(snr_.mean())) # plt.imshow(image, cmap='gray') if fmt == 'tif': tif.imsave('figs/ring.tif', image.astype(np.float32)) elif fmt == 'png': plt.savefig('figs/ring.png') else: print 'Output format %s not supported' % fmt
def main(): parser = argparse.ArgumentParser(description='Train model.') parser.add_argument('--tissue', help='select tissue to train.', default=None) parser.add_argument('--inputFolder', help='Select input folder.', default=None) parser.add_argument('--outputFolder', help='select output folder', default=None) parser.add_argument('--nr_images', help='select number of images to create', default=None) parser.add_argument('--overlapProbability', help='select overlapProbability', default=None) parser.add_argument('--scale', help='select output folder', default=None) parser.add_argument('--img_prefix', help='select output folder', default='Img_') parser.add_argument('--mask_prefix', help='select output folder', default='Mask_') #random.seed(13431) args = parser.parse_args() config = Config if args.tissue: config.diagnosis = [args.tissue] if args.outputFolder: config.outputFolder = args.outputFolder if args.overlapProbability: args.overlapProbability = float(args.overlapProbability) else: args.overlapProbability = 0.5 if args.tissue == 'Ganglioneuroma': n_freq = 20#15 else: n_freq = 30 if args.scale == '1': config.scale=True print(config.diagnosis) tools = Tools() annotated_nuclei =[] annotated_images = [] ids_images = glob.glob(os.path.join(args.inputFolder,config.diagnosis[0],'images','*.tif')) ids_masks = glob.glob(os.path.join(args.inputFolder, config.diagnosis[0], 'masks', '*.tif')) for index, elem in enumerate(ids_images): test = AnnotatedImage() test.readFromPath(ids_images[index], ids_masks[index],type='uint16') annotated_images.append(test) # Create artificial new dataset scales = tools.getNormalizedScales(annotated_images) running = 0 for index,img in enumerate(annotated_images): test = AnnotatedImage() annotated_nuclei.append(AnnotatedObjectSet()) if config.scale: test.createWithArguments(tools.rescale_image(img.getRaw(),(scales[index],scales[index])),tools.rescale_mask(img.getMask(),(scales[index],scales[index]), make_labels=True)) else: test.createWithArguments(img.getRaw(),img.getMask()) annotated_nuclei[running].addObjectImage(test, useBorderObjects=config.useBorderObjects, tissue=args.tissue, scale=Config.scale) running += 1 del test if config.scale == 0: if args.tissue == 'Ganglioneuroma': possible_numbers = [9, 16, 25, 36, 49] else: possible_numbers = [4, 4, 9] else: possible_numbers = [9,16,25,36,49] # How many images? if not args.nr_images: args.nr_images=10 else: args.nr_images=int(args.nr_images) for t in tqdm(range(0,args.nr_images)): nr_img = random.randint(0,annotated_nuclei.__len__()-1) # Create artificial image number_nuclei = random.randint(0, possible_numbers.__len__()-1) # calculate Background tmp_image = annotated_nuclei[nr_img].images[0].getRaw() tmp_mask = annotated_nuclei[nr_img].images[0].getMask() kernel = np.ones((15, 15), np.uint8) bg = cv2.erode((tmp_mask == 0).astype(np.uint8), kernel, iterations=1) bg = np.sort(tmp_image[np.where(bg>0)]) img = ArtificialAnnotatedImage(width=256,height=256,number_nuclei=possible_numbers[number_nuclei],probabilityOverlap=args.overlapProbability,background=bg) total_added = 0 for i in range(0,possible_numbers[number_nuclei]): test = annotated_nuclei[nr_img].returnArbitraryObject() if (randint(0,1)): test = tools.arbitraryEnhance(test) total_added += img.addImageAtGridPosition(test) if (total_added > 0): shape_y = img.getRaw().shape[0] shape_x = img.getRaw().shape[1] img_new = np.zeros((shape_y,shape_x*2,3),dtype=np.float32) img_new[:,0:shape_x,0] = img_new[:,0:shape_x,1] = img_new[:,0:shape_x,2] = img_new[:,shape_x:2*shape_x,0] = img_new[:,shape_x:2*shape_x,1] = img_new[:,shape_x:2*shape_x,2] = img.getRaw() scipy.misc.toimage(img_new, cmin=0.0, cmax=1.0).save(config.outputFolder + config.diagnosis[0] + '\\images\\' + args.img_prefix + str(t) + '.jpg') tifffile.imsave(config.outputFolder + config.diagnosis[0] + '\\masks\\' + args.mask_prefix + str(t) + '.tif',img.getMask(),dtype=np.uint8) e=1
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 save_plane(self, plane): plane_name = f"plane_{str(self.z).zfill(4)}.tif" f_path = os.path.join(self.plane_directory, plane_name) tifffile.imsave(f_path, plane.T)
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()
else: assert False, "unknown option" image = np.zeros(fullsize) xs, ys = samplesize snr_ = [] for i in range(fullsize[0]/samplesize[0]): for j in range(fullsize[1]/samplesize[1]): sample, snr = gen_pattern(alpha) snr_.append(snr) print 'SNR : %.5f,' % snr, print 'Industrial SNR: %.3f db' % snr_ind(snr) image[i*xs:(i+1)*xs, j*xs:(j+1)*xs] = sample snr_ = np.array(snr_) print "Average SNR %.3f +/- %.3f (%.2f db)" % \ (snr_.mean(), snr_.std(), snr_ind(snr_.mean())) # plt.imshow(image, cmap='gray') if fmt == 'tif': tif.imsave('figs/ring.tif', image.astype(np.float32)) elif fmt == 'png': plt.savefig('figs/ring.png') else: print 'Output format %s not supported' % fmt