def sliding_window_crop(img, img_name, output_path, usage): height, width, _ = img.shape col_count = 0 for y in range(0, height, int(height / 4)): row_count = 0 for x in range(0, width, int(width / 4)): img_crop = img[y:y + int(height / 4), x:x + int(width / 4)] if usage == "img": crop_name = "_".join( [img_name, "{:04d}_{:04d}".format(row_count, col_count)]) img_file = os.path.join(output_path, ".".join([crop_name, "tif"])) tif = TIFFimage(img_crop) tif.write_file(img_file) else: crop_name = "_".join([ img_name, "{:04d}_{:04d}_label".format(row_count, col_count) ]) img_file = os.path.join(output_path, ".".join([crop_name, "tif"])) mask = cv2.cvtColor(img_crop, cv2.COLOR_BGR2RGB) cv2.imwrite(img_file, mask) row_count += 1 col_count += 1
def test_rw_rgb(): itype = uint8 dt = dtype(dict(names = list('rgb'), formats = [itype]*3)) image = zeros((2,3), dtype=dt) image['r'][:,0] = 250 image['g'][:,1] = 251 image['b'][:,2] = 252 fn = mktemp('.tif') tif = TIFFimage(image) tif.write_file(fn,compression='lzw')#, samples='rgb') del tif tif = TIFFfile(fn) data, names = tif.get_samples() #os.remove(fn) atexit.register(os.remove, fn) print image print data assert itype == data[0].dtype, `itype, data[0].dtype` assert (image['r']==data[0]).all() assert (image['g']==data[1]).all() assert (image['b']==data[2]).all()
def test_rw_rgb(): itype = uint8 dt = dtype(dict(names=list('rgb'), formats=[itype] * 3)) image = zeros((2, 3), dtype=dt) image['r'][:, 0] = 250 image['g'][:, 1] = 251 image['b'][:, 2] = 252 fn = mktemp('.tif') tif = TIFFimage(image) tif.write_file(fn, compression='lzw') #, samples='rgb') del tif tif = TIFFfile(fn) data, names = tif.get_samples() #os.remove(fn) atexit.register(os.remove, fn) print image print data assert itype == data[0].dtype, ` itype, data[0].dtype ` assert (image['r'] == data[0]).all() assert (image['g'] == data[1]).all() assert (image['b'] == data[2]).all()
def test_write_lzw(): for itype in [ uint8, uint16, uint32, uint64, int8, int16, int32, int64, float32, float64, complex64, complex128 ]: #image = array([[1,2,3], [4,5,6]], itype) image = array([range(10000)], itype) #image = array([[0]*14000], itype) fn = mktemp('.tif') tif = TIFFimage(image) tif.write_file(fn, compression='lzw') del tif #os.system('wc %s; echo %s' % (fn, image.nbytes)) tif = TIFF.open(fn, 'r') image2 = tif.read_image() tif.close() #os.remove(fn) atexit.register(os.remove, fn) for i in range(image.size): if image.flat[i] != image2.flat[i]: print ` i, image.flat[i - 5:i + 5].view( dtype=uint8), image2.flat[i - 5:i + 5].view(dtype=uint8) ` break assert image.dtype == image2.dtype assert (image == image2).all()
def test_write_read(): for compression in [None, 'lzw']: for itype in [ uint8, uint16, uint32, uint64, int8, int16, int32, int64, float32, float64, complex64, complex128 ]: image = array([[1, 2, 3], [4, 5, 6]], itype) fn = mktemp('.tif') if 0: tif = TIFF.open(fn, 'w') tif.write_image(image, compression=compression) tif.close() else: tif = TIFFimage(image) tif.write_file(fn, compression=compression) del tif tif = TIFFfile(fn) data, names = tif.get_samples() assert names == ['sample0'], repr(names) assert len(data) == 1, repr(len(data)) assert image.dtype == data[0].dtype, repr( (image.dtype, data[0].dtype)) assert (image == data[0]).all() #os.remove(fn) atexit.register(os.remove, fn)
def test_write_read(): for compression in [None, 'lzw']: for itype in [uint8, uint16, uint32, uint64, int8, int16, int32, int64, float32, float64, complex64, complex128]: image = array([[1,2,3], [4,5,6]], itype) fn = mktemp('.tif') if 0: tif = TIFF.open(fn,'w') tif.write_image(image, compression=compression) tif.close() else: tif = TIFFimage(image) tif.write_file(fn, compression=compression) del tif tif = TIFFfile(fn) data, names = tif.get_samples() assert names==['sample0'],`names` assert len(data)==1, `len(data)` assert image.dtype==data[0].dtype, `image.dtype, data[0].dtype` assert (image==data[0]).all() #os.remove(fn) atexit.register(os.remove, fn)
def sci2tiff(input_file, force_input_min=None, force_input_max=None, fill_null_stripes=False, fillsat=False, dohisteq=False, minpercent=None, maxpercent=None, std_mult=None, resize=None, band=0, trim=0, outputformat="uint16"): pixel_matrix = load_image_matrix(input_file, band=band) pixel_matrix = process_data(pixel_matrix, force_input_min, force_input_max, fill_null_stripes, fillsat, dohisteq, minpercent, maxpercent, std_mult, resize, trim, outputformat=outputformat) output_filename = build_output_filename(input_file) print "Writing", output_filename # Create output tiff tiff = TIFFimage(pixel_matrix, description='') tiff.write_file(output_filename, compression='none', verbose=False) return True
def test_write_lzw(): for itype in [uint8, uint16, uint32, uint64, int8, int16, int32, int64, float32, float64, complex64, complex128]: #image = array([[1,2,3], [4,5,6]], itype) image = array([range(10000)], itype) #image = array([[0]*14000], itype) fn = mktemp('.tif') tif = TIFFimage(image) tif.write_file(fn, compression='lzw') del tif #os.system('wc %s; echo %s' % (fn, image.nbytes)) tif = TIFF.open(fn,'r') image2 = tif.read_image() tif.close() #os.remove(fn) atexit.register(os.remove, fn) for i in range(image.size): if image.flat[i] != image2.flat[i]: print `i, image.flat[i-5:i+5].view(dtype=uint8),image2.flat[i-5:i+5].view(dtype=uint8)` break assert image.dtype==image2.dtype assert (image==image2).all()
def convert(filename, fileext='tif', force=False, compress=False): """Converts a RAXIS file to an image Arguments --------- filename : string fileext : string Either 'tif' or 'tiff'; since RAXIS data is 16-bit, it is of dubious utility to use other formats. Support for other 16-bit formats may be added in future force : string Whether to overwrite an existing image file of the same name. """ #### Initial sanity checks print("Converting {}".format(filename)) if fileext not in ['tif', 'tiff']: print("RAXIS data is 16-bit; at the moment, we therefore only support " "saving it to TIFF files.") return newfilename = ''.join([splitext(filename)[0], '.', fileext]) if exists(newfilename): if not force: print("The file {} already exists. Re-run with --force " "if you want to overwrite it.".format(newfilename)) return data = read_raxis_file(filename) tiff = TIFFimage(data, description='RAXIS file converted to TIFF by raxis_to_image 0.0.3') tiff.write_file(newfilename, compression='none' if not compress else 'lzw') print('Converted {} to {}'.format(filename, newfilename))
def test_issue69(): itype = np.uint32 image = np.array([[[1, 2, 3], [4, 5, 6]]], itype) fn = mktemp('issue69.tif') tif = TIFFimage(image) tif.write_file(fn) del tif tif = lt.TIFF3D.open(fn) tif.close() atexit.register(os.remove, fn)
def save_band(band, band_num, filter_num): img = np.copy(band) inds = np.where(np.isnan(img)) img[inds] = np.nanmin(img) data_matrix = img #.astype(np.uint16) tiff = TIFFimage(data_matrix, description='') if not os.path.exists("bands"): os.mkdir("bands") tiff.write_file("bands/band_%d_%d.tif"%(filter_num, band_num), compression='none', verbose=False)
def FromProto(name, expe, var, alpha, nx = 100, ny = 100, sx = 25, sy = 25): image = np.zeros((nx * sx, ny * sy), dtype = np.uint16) proto = np.load(name) for i in range(nx): for j in range(ny): for m in range(sx): for n in range(sy): esti = proto[i, j, m, n] image[sx*i + m, sy*j + n] = int(round(random.normal(esti+expe, sqrt(alpha*esti + var)))) tiff = TIFFimage(image, description = '') tiff.write_file('image', compression = 'none') del tiff
def SpotArray(es_l, es_h, num = 100): es_limage, es_himage = np.load(es_l), np.load(es_h) sizex, sizey = es_limage.shape limage, himage = np.zeros((sizex, sizey * num), np.uint16), np.zeros((sizex, sizey * num), np.uint16) for k in range(num): for i in range(sizex): for j in range(sizey): lesti, hesti = es_limage[i, j], es_himage[i, j] limage[i, j + sizey * k] = int(round(random.normal(lesti+expe, sqrt(alpha*lesti + var)))) himage[i, j + sizey * k] = int(round(random.normal(hesti+expe, sqrt(alpha*hesti + var)))) tiff = TIFFimage(limage, description = '') tiff.write_file('limage', compression = 'none') del tiff tiff = TIFFimage(himage, description = '') tiff.write_file('himage', compression = 'none') del tiff return limage, himage
def process_image(img_path, save_file_path=None, verbose=False): if verbose: print("Filling dead pixels in %s" % img_path) data = open_image(img_path) fillpixels(data, verbose=verbose) if save_file_path is None: save_file_path = "%s-filled.tif" % (img_path[0:-4]) if verbose: print("Saving processed data to", save_file_path) tiff = TIFFimage(data, description='') tiff.write_file(save_file_path, compression='none', verbose=False) return save_file_path
def test_write_read(): for compression in ['none', 'lzw']: for itype in [uint8, uint16, uint32, uint64, int8, int16, int32, int64, float32, float64, complex64, complex128]: image = array([[1,2,3], [4,5,6]], itype) fn = mktemp('.tif') tif = TIFFimage(image) tif.write_file(fn, compression=compression) del tif tif = TIFFfile(fn) data, names = tif.get_samples() #os.remove(fn) atexit.register(os.remove, fn) assert names==['sample0'],repr(names) assert len(data)==1, repr(len(data)) assert image.dtype==data[0].dtype, repr((image.dtype,data[0].dtype)) assert (image==data[0]).all()
def test_write_read(): for compression in ['none', 'lzw']: for itype in [ uint8, uint16, uint32, uint64, int8, int16, int32, int64, float32, float64, complex64, complex128 ]: image = array([[1, 2, 3], [4, 5, 6]], itype) fn = mktemp('.tif') tif = TIFFimage(image) tif.write_file(fn, compression=compression) del tif tif = TIFFfile(fn) data, names = tif.get_samples() #os.remove(fn) atexit.register(os.remove, fn) assert names == ['sample0'], ` names ` assert len(data) == 1, ` len(data) ` assert image.dtype == data[0].dtype, ` image.dtype, data[0].dtype ` assert (image == data[0]).all()
def main (): from libtiff import TIFFimage #import matplotlib.pyplot as plt N = 400 for i in range (N): L = 1.8 + 0.2*numpy.cos(max(0,i-N//5)/N*2*numpy.pi) print i,L image = compute_image(L, 2.25, 1.5, 100, 640, 0.274) tif = TIFFimage(image.astype(numpy.uint8).T, description=''' VoxelSizeX: 0.274e-6 VoxelSizeY: 0.274e-6 VoxelSizeZ: 1 MicroscopeType: widefield ObjectiveNA: 1.2 ExcitationWavelength: 540.0 RefractiveIndex: 1.33 ''') tif.write_file ('fakesacromere_exact/image_%06d.tif' % i) del tif
def main(): from libtiff import TIFFimage #import matplotlib.pyplot as plt N = 400 for i in range(N): L = 1.8 + 0.2 * numpy.cos(max(0, i - N // 5) / N * 2 * numpy.pi) print i, L image = compute_image(L, 2.25, 1.5, 100, 640, 0.274) tif = TIFFimage(image.astype(numpy.uint8).T, description=''' VoxelSizeX: 0.274e-6 VoxelSizeY: 0.274e-6 VoxelSizeZ: 1 MicroscopeType: widefield ObjectiveNA: 1.2 ExcitationWavelength: 540.0 RefractiveIndex: 1.33 ''') tif.write_file('fakesacromere_exact/image_%06d.tif' % i) del tif
def test_simple_slicing(): for planar_config in [1, 2]: for compression in [None, 'lzw']: for itype in [ uint8, uint16, uint32, uint64, int8, int16, int32, int64, float32, float64, complex64, complex128 ]: image = random.randint(0, 100, size=(10, 6, 7)).astype(itype) fn = mktemp('.tif') if 0: if planar_config == 2: continue tif = TIFF.open(fn, 'w') tif.write_image(image, compression=compression) tif.close() else: tif = TIFFimage(image) tif.write_file(fn, compression=compression, planar_config=planar_config) del tif tif = TIFFfile(fn) arr = tif.get_tiff_array() data = arr[:] assert len(data) == len(image), repr(len(data)) assert image.dtype == data.dtype, repr( (image.dtype, data[0].dtype)) assert (image == data).all() assert arr.shape == image.shape _indices = [0, slice(None), slice(0, 2), slice(0, 5, 2)] for _i0 in _indices[:1]: for i1 in _indices: for i2 in _indices: sl = (_i0, i1, i2) assert (arr[sl] == image[sl]).all(), repr(sl) tif.close() atexit.register(os.remove, fn)
def test_simple_slicing(): for planar_config in [1,2]: for compression in [None, 'lzw']: for itype in [uint8, uint16, uint32, uint64, int8, int16, int32, int64, float32, float64, complex64, complex128]: image = random.randint(0, 100, size=(10,6,7)).astype(itype) fn = mktemp('.tif') if 0: if planar_config == 2: continue tif = TIFF.open(fn, 'w') tif.write_image(image, compression=compression) tif.close() else: tif = TIFFimage(image) tif.write_file(fn, compression=compression, planar_config=planar_config) del tif tif = TIFFfile(fn) arr = tif.get_tiff_array() data = arr[:] assert len(data) == len(image), repr(len(data)) assert image.dtype == data.dtype, repr((image.dtype, data[0].dtype)) assert (image == data).all() assert arr.shape == image.shape _indices = [0, slice(None), slice(0, 2), slice(0, 5, 2)] for _i0 in _indices[:1]: for i1 in _indices: for i2 in _indices: sl = (_i0, i1, i2) assert (arr[sl] == image[sl]).all(),repr(sl) atexit.register(os.remove, fn)
def image_shifted(mean, std, sx = 21, sy = 21, nx = 101, ny = 101, kx=1, ky=1, initial = False, noisy = True, rep = 100): mx, my = mean.shape if mx<sx+1 or my<sy+1: return 0 image = np.zeros((sx*nx,sy*ny),dtype=np.uint16) fimage = np.zeros((sx*nx,sy*ny)) fvar = np.zeros((sx*nx,sy*ny)) if initial: for m in range(nx): for n in range(ny): image[m*sx:(m+1)*sx, n*sy:(n+1)*sy] = np.int_(np.round_(mean[0:sx,0:sy])) tiff = TIFFimage(image, description = '') tiff.write_file('image_ini', compression = 'none') del tiff return 0 accum=np.zeros((sx+2, sy+2)) #sub = np.zeros((sx+1, sy+1)) for m in range(nx): for n in range(ny): for i in range(sx+2): for j in range(sy+2): accum[i,j] = mean[0:i,0:j].sum() spline = interpolate.RectBivariateSpline(np.arange(0,sx+2),np.arange(0,sy+2),accum,kx=kx,ky=ky,s=0) subimage = fimage[m*sx:(m+1)*sx,n*sy:(n+1)*sy] for i in range(sx): for j in range(sy): subimage[i,j] = spline.ev(m/(nx-1.)+i+1,n/(ny-1.)+j+1)-spline.ev(m/(nx-1.)+i,n/(ny-1.)+j+1)-spline.ev(m/(nx-1.)+i+1,n/(ny-1.)+j)+spline.ev(m/(nx-1.)+i,n/(ny-1.)+j) var = std**2 if noisy: for m in range(nx): for n in range(ny): for i in range(sx+2): for j in range(sy+2): accum[i,j] = var[0:i,0:j].sum() spline = interpolate.RectBivariateSpline(np.arange(0,sx+2),np.arange(0,sy+2),accum,kx=kx,ky=ky,s=0) subvar = fvar[m*sx:(m+1)*sx,n*sy:(n+1)*sy] for i in range(sx): for j in range(sy): subvar[i,j] = spline.ev(m/(nx-1.)+i+1,n/(ny-1.)+j+1)-spline.ev(m/(nx-1.)+i,n/(ny-1.)+j+1)-spline.ev(m/(nx-1.)+i+1,n/(ny-1.)+j)+spline.ev(m/(nx-1.)+i,n/(ny-1.)+j) for k in range(100): for i in range(sx*nx): for j in range(sy*ny): image[i,j] = int(round(random.normal(fimage[i,j],np.sqrt(fvar[i,j])))) tiff = TIFFimage(image, description = '') tiff.write_file('image%i'%k, compression = 'none') del tiff else: for i in range(sx*nx): for j in range(sy*ny): image[i,j] = int(round(fimage[i,j])) tiff = TIFFimage(image, description = '') tiff.write_file('image', compression = 'none') del tiff return 0
def test_issue19(): size = 1024 * 32 # 1GB # size = 1024*63 # almost 4GB, test takes about 60 seconds but succeeds image = ones((size, size), dtype=uint8) print('image size:', image.nbytes / 1024**2, 'MB') fn = mktemp('issue19.tif') tif = TIFFimage(image) try: tif.write_file(fn) except OSError as msg: if 'Not enough storage is available to process this command'\ in str(msg): # Happens in Appveyour CI del tif atexit.register(os.remove, fn) return else: raise del tif tif = TIFFfile(fn) tif.get_tiff_array()[:] # expected failure tif.close() atexit.register(os.remove, fn)
y = labels # for i in range(y.shape[0]): for i in range(y.shape[0]): # to create a tiff structure from image data tiff_ch1 = TIFFimage(X[i, 0, :, :].astype('uint16'), description='') tiff_ch2 = TIFFimage(X[i, 1, :, :].astype('uint16'), description='') tiff_ch3 = TIFFimage(X[i, 2, :, :].astype('uint16'), description='') tiff_ch4 = TIFFimage(X[i, 3, :, :].astype('uint16'), description='') if i % 100 == 0: print "Cell no.", i if y[i, 0] == 0: tiff_ch1.write_file(p1 + 'id' + str(i) + '_class' + str(y[i, 0]) + '_' + str(y[i, 1]) + '_ch1.tif', compression='none') tiff_ch2.write_file(p1 + 'id' + str(i) + '_class' + str(y[i, 0]) + '_' + str(y[i, 1]) + '_ch2.tif', compression='none') tiff_ch3.write_file(p1 + 'id' + str(i) + '_class' + str(y[i, 0]) + '_' + str(y[i, 1]) + '_ch3.tif', compression='none') tiff_ch4.write_file(p1 + 'id' + str(i) + '_class' + str(y[i, 0]) + '_' + str(y[i, 1]) + '_ch4.tif', compression='none') if y[i, 0] == 1: tiff_ch1.write_file(p2 + 'id' + str(i) + '_class' + str(y[i, 0]) + '_' + str(y[i, 2]) + '_ch1.tif', compression='none') tiff_ch2.write_file(p2 + 'id' + str(i) + '_class' + str(y[i, 0]) +
esti = proto[i, j, m, n] image[sx*i + m, sy*j + n] = int(round(random.normal(esti+expe, sqrt(alpha*esti + var)))) tiff = TIFFimage(image, description = '') tiff.write_file('image', compression = 'none') del tiff """ mean_var = np.load('mean_var.npy') var = -mean_var[0] expe = mean_var[1] fit = np.load('hklfit.npy') alpha = fit.item().values()[0][0] FromProto('prototype new.npy', expe = expe, var = var, alpha = alpha) """ proto = np.load('prototype new.npy') subimage = np.zeros((25, 25), dtype=np.uint16) mean_var = np.load('mean_var.npy') var = -mean_var[0] expe = mean_var[1] fit = np.load('hklfit.npy') alpha = fit.item().values()[0][0] for m in range(25): for n in range(25): esti = proto[0, 0, m, n] subimage[m, n] = int(round(random.normal(esti+expe, sqrt(alpha*esti + var)))) image = np.zeros((2500, 2500), dtype=np.uint16) for i in range(100): for j in range(100): image[i*25: (i+1)*25, j*25: (j+1)*25] = subimage tiff = TIFFimage(image, description = '') tiff.write_file('ini_image', compression = 'none')
type=str) parser.add_argument("-i", "--delay", help="Interframe Delay", required=True, type=float) args = parser.parse_args() is_verbose = args.verbose kernelbase = args.kernelbase allow_predicted = args.predicted source = args.data start_date = args.start interframe_delay = args.delay if is_verbose: print_r("Loading spice kernels...") jcspice.load_kernels(kernelbase, allow_predicted) print_r("Loading Image Data...") data = open_image(source) delambert(data, start_date, interframe_delay, is_verbose) data /= data.max() data *= 65535.0 data_matrix = data.astype(np.uint16) tiff = TIFFimage(data_matrix, description='') tiff.write_file("test_data.tif", compression='none')
def save(self, path): data_matrix = self.data.astype(np.uint16) tiff = TIFFimage(data_matrix, description='') tiff.write_file(path, compression='none', verbose=False)
def train_EM_Seg(): # 数据准备 train_data_path = os.path.join("EMseg", 'train-volume.tif') train_label_path = os.path.join("EMseg", 'train-labels.tif') test_data_path = os.path.join("EMseg", 'test-volume.tif') train_data = openTIF(train_data_path) train_label = openTIF(train_label_path) test_data = openTIF(test_data_path) train_label[train_label > 0.5] = 1.0 train_label[train_label < 0.5] = 0.0 validation_data = train_data[:3, :, :, :] validation_label = train_label[:3, :, :, :] train_data = train_data[3:, :, :, :] train_label = train_label[3:, :, :, :] train_data, train_label = data_augmentation(train_data, train_label) model = Unet(1, image_shape) step_counter = 0 data_order = np.arange(train_data.shape[0]) step_in_epoch = (train_data.shape[0] // batch_size) + 1 current_time = datetime.datetime.now().strftime("%Y%m%d-%H%M%S") train_log_dir = 'logs/UNet_EM_SEG_' + current_time model_path = os.path.join(train_log_dir, 'best_model.h5') summary_writer = tf.summary.create_file_writer(train_log_dir) best_iou = -1 print('train dataset shape:', train_data.shape) print('train label shape:', train_label.shape) # 训练环节 for ep in range(epoch_num): # shuffle np.random.shuffle(data_order) train_data = train_data[data_order, :, :, :] train_label = train_label[data_order, :, :, :] for step in range(step_in_epoch): step_counter += 1 batch_start = step * batch_size batch_end = batch_start + batch_size batch_data = train_data[batch_start:batch_end, :, :, :] batch_label = train_label[batch_start:batch_end, :, :, :] with tf.GradientTape() as tape: predictions = model(batch_data, training=True) loss = loss_function(batch_label, predictions) gradients = tape.gradient(loss, model.trainable_variables) optimizer.apply_gradients(zip(gradients, model.trainable_variables)) train_loss(loss) with summary_writer.as_default(): tf.summary.scalar('Stats/train_loss', train_loss.result(), step=step_counter) train_loss.reset_states() predictions = model.predict(validation_data) v_loss = loss_function(validation_label, predictions) validation_loss(v_loss) predictions[predictions >= 0.5] = 1.0 predictions[predictions < 0.5] = 0.0 validation_iou.update_state(validation_label, predictions) with summary_writer.as_default(): tf.summary.scalar('stats/val_loss', validation_loss.result(), step=ep) tf.summary.scalar('stats/val_iou', validation_iou.result(), step=ep) if validation_iou.result() > best_iou: model.save_weights(model_path) best_iou = validation_iou.result() validation_loss.reset_states() validation_iou.reset_states() print("best validation iou:", best_iou) # 评价环节 # 打印validation set里面的图片 model.load_weights(model_path) valid_pred = model.predict(validation_data) for im_idx in range(valid_pred.shape[0]): valid_im = valid_pred[im_idx, :, :, :] valid_im[valid_im >= 0.5] = 255 valid_im[valid_im < 0.5] = 0 imsave(os.path.join(train_log_dir, 'validation_%d.png' % im_idx), valid_im) imsave(os.path.join(train_log_dir, 'validation_label_%d.png' % im_idx), validation_label[im_idx]) # 生成测试集的输出 test_pred = model.predict(test_data) test_tiff = [] for im_idx in range(test_data.shape[0]): test_im = test_pred[im_idx, :, :, :] test_im[test_im >= 0.5] = 255 test_im[test_im < 0.5] = 0 test_tiff.append(np.squeeze(test_im)) tiff = TIFFimage(test_tiff) tiff.write_file(os.path.join(train_log_dir, 'test_result.tif'))
def save_tif(img, newname, headers): print("Opening filename") img_tif = numpy.array(img, dtype=numpy.uint16) newname_tif = newname newname_tif += ".tif" info_tiff = [] try: binning = int(headers['Binning']) binning += 1 except Exception as e: print("Binning Type Error ->" + str(e)) binning = " ??? " try: print("Tricat of save_tif") day_hour = get_date_hour_image_for_headers(str(headers['Start Time'])) try: info_tiff.append('Binning: ' + str(binning) + "x" + str(binning) + ';') info_tiff.append('CCD SET TEMP: ' + str(headers['Set Temperature']) + ' Deg.' + ';') info_tiff.append('CCD Temperature: ' + str(headers['Temperature']) + ' Deg.' + ';') info_tiff.append('CCD Type: ' + str(headers['Imager ID']) + ';') info_tiff.append('Exposure: ' + str(headers['Exposure']) + '0 ms' + ';') info_tiff.append('Filter Label: ' + str(headers['Filter Label']) + ';') info_tiff.append('Filter Wavelength: ' + str(headers['Filter Wavelength']) + ';') info_tiff.append('Image Type: ' + 'TIF' + ';') info_tiff.append('Latitude: ' + str(headers['Latitude']) + ' Deg.' + ';') info_tiff.append('Longitude: ' + str(headers['Longitude']) + ' Deg.' + ';') info_tiff.append('Moon Elevation: ' + str(headers['Moon Elevation']) + ' Deg.' + ';') info_tiff.append('Moon Phase: ' + str(headers['Moon Phase']) + " %" + ';') info_tiff.append('Site ID: ' + str(headers['Observatory']) + ';') info_tiff.append('Start Time: ' + str(day_hour) + " UTC;") info_tiff.append('Sun Elevation:' + str(headers['Sun Elevation']) + ' Deg.;') info_tiff.append('Version: ' + str(software_version) + '') except Exception as e: print("info.add_text: " + e) try: if sys.platform.startswith("linux"): imgarray = numpy.array(img_tif, dtype='uint16') im3 = Image.fromarray(imgarray) im3.save(newname_tif) elif sys.platform.startswith("win"): # imgarray = numpy.array(img_tif, dtype=numpy.int16) imgarray_tiff2 = numpy.asarray(img_tif, dtype=numpy.uint32) im3 = Image.fromarray(imgarray_tiff2) tiff = im3.resize((int(512), int(512))) imgarray_tiff2 = numpy.asarray(tiff, dtype=numpy.uint32) tiff2 = TIFFimage(imgarray_tiff2, description=info_tiff) tiff2.write_file(newname_tif, compression='lzw') print(info_tiff) except Exception as e: print(e) except Exception as e: print("Exception -> {}".format(e))
def vic2tif(input_file, force_input_min=None, force_input_max=None, fill_null_stripes=False, fillsat=False, dohisteq=False, minpercent=None, maxpercent=None, resize=None): pixel_matrix, value_pairs = vicar.load_vic(input_file) if pixel_matrix is None or value_pairs is None: return False # Scale to 0-65535 and convert to UInt16 if force_input_min is not None: pixel_min = force_input_min else: pixel_min = np.nanmin(pixel_matrix) if force_input_max is not None: pixel_max = force_input_max else: pixel_max = np.nanmax(pixel_matrix) print "Minimum Native:", pixel_min, "Maximum Native:", pixel_max if fill_null_stripes is True: stripes = detect_null_stripes(pixel_matrix) fill_stripes(pixel_matrix, stripes) # The min/max percent stuff isn't correct. TODO: Make it correct. if minpercent is not None: diff = pixel_min + ((pixel_max - pixel_min) * (minpercent / 100.0)) print "Min:", diff pixel_matrix[pixel_matrix < diff] = diff pixel_min = diff if maxpercent is not None: diff = pixel_min + ((pixel_max - pixel_min) * (maxpercent / 100.0)) print "Max:", diff pixel_matrix[pixel_matrix > diff] = diff pixel_max = diff if fillsat is True: inds = np.where(np.isnan(pixel_matrix)) pixel_matrix[inds] = np.nanmax(pixel_matrix) pixel_matrix = pixel_matrix - pixel_min pixel_matrix = pixel_matrix / (pixel_max - pixel_min) pixel_matrix[pixel_matrix < 0] = 0 # Format for UInt16 pixel_matrix = pixel_matrix * 65535.0 pixel_matrix = pixel_matrix.astype(np.uint16) #print pixel_matrix.min(), pixel_matrix.max() if dohisteq is True: pixel_matrix = histeq(pixel_matrix) if resize is not None: pixel_matrix = imresize(pixel_matrix, size=resize, interp='bicubic') output_filename = build_output_filename(value_pairs) print "Writing", output_filename # Create output tiff tiff = TIFFimage(pixel_matrix, description='') tiff.write_file(output_filename, compression='none') return True
I = I | (L2 / A > ip_threshold).as_matrix() # Find the proper index in the labeled image idx = properties.index[I] - 10000 * position # Filter bad idx from labeled image notrightsize = np.isnan(nuclei) for i in idx: notrightsize = notrightsize | (nuclei == i) # Save only good nuclei in image and properties table good_labels = nuclei.copy() good_labels[notrightsize] = 0 nucs = properties[~I] # Save the segmentation as 32-bit TIFF # NB: only use the libtiff package since we need 32-bit tiff = TIFFimage(good_labels, description='') tiff.write_file(''.join((base, 'nuclei.tif')), compression='none') # DEBUG ONLY: also save the raw segmentation # tiff = TIFFimage(nuclei, description='') # tiff.write_file(''.join((base, 'raw_nuclei.tif')), # compression='none') # Save the DataFrame as CSV nucs.to_csv(''.join((base, 'quantification.csv')), sep='\t') all_props = pd.concat([all_props, nucs]) raw_props = pd.concat([raw_props, properties]) print "Done with ", position
def save_image(image_data, path): data_matrix = image_data.astype(np.uint16) tiff = TIFFimage(data_matrix, description='') tiff.write_file(path, compression='none')
bitpix = hdu.header['bitpix'] bzero = hdu.header['bzero'] #is the image flipped? No worries! d = hdu.data[::-1, :] #removing mask (if I understood this bit of the spec correctly) d[d < bzero] = bzero mi = numpy.min(d) ma = numpy.max(d) print d.shape, d.dtype, mi, ma #mostly, we want 16 bit images... if bitpix != 16: d = 65535 * (d - mi) / (ma - mi) print "writing 16 bit tiff..." d16 = d.astype(numpy.uint16) tiff = TIFFimage(d16, description='http://tdc-www.harvard.edu/postage_stamp/') tiff.write_file(fn + '.tif', compression='lzw') #flush the file to disk: del tiff print "writing equalized 8 bit png and jpeg..." d8, cdf = histeq(d, 65536) i = Image.fromarray(d8) i.save(fn + '.png') i.save(fn + '.jpg')
bzero = hdu.header['bzero'] #is the image flipped? No worries! d = hdu.data[::-1,:] #removing mask (if I understood this bit of the spec correctly) d[d<bzero] = bzero mi = numpy.min(d) ma = numpy.max(d) print d.shape, d.dtype,mi,ma #mostly, we want 16 bit images... if bitpix != 16: d = 65535*(d - mi)/(ma-mi) print "writing 16 bit tiff..." d16 = d.astype(numpy.uint16) tiff = TIFFimage(d16, description='http://tdc-www.harvard.edu/postage_stamp/') tiff.write_file(fn+'.tif', compression='lzw') #flush the file to disk: del tiff print "writing equalized 8 bit png and jpeg..." d8,cdf = histeq(d,65536) i = Image.fromarray(d8) i.save(fn+'.png') i.save(fn+'.jpg')
import tifffile as tf from libtiff import TIFFimage src_p = r"Z:\rabies_tracing_project\M533921" \ r"\2020-10-12-align-sections\step02_align_sections" \ r"\201026-M533921-merged-GCaMP.tif" curr_folder = os.path.dirname(os.path.realpath(__file__)) os.chdir(curr_folder) save_folder, save_name = os.path.split(src_p) save_name = f'{os.path.splitext(save_name)[0]}_libtiff.tif' save_path = os.path.join(save_folder, save_name) print(f'reading {src_p} ...') img = tf.imread(src_p) print(f'\timage datatype: {img.dtype}.') print(f'\timage shape: {img.shape}.') if len(img.shape) > 3: raise NotImplementedError( f'pylibtiff cannot convert image with more than 3 dimensions. ' f'Current number of dimensions: {len(img.shape)}.') print(f'\tsaving {save_path} ...') tiff = TIFFimage(img, description='') tiff.write_file(save_name, compression='none') # or 'lzw' del tiff print('\tdone.')