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_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_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_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 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_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 rwlibtiff(x, fn): """ It seems with verion 0.4.0 that it requires Python 2.7, but I get a segmentation fault even with Python 2.7 """ from libtiff import TIFFimage, TIFF with TIFFimage(x, description='my test data') as tf: print('libtiff write ' + fn) #write demo tf.write_file(str(fn), compression='none') #read demo with TIFF.open(str(fn), mode='r') as tif: return tif.read_image()
def rwlibtiff(x, fn): """ It seems with verion 0.4.0 that it requires Python 2.7, but I get a segmentation fault even with Python 2.7 """ from libtiff import TIFFimage, TIFF with TIFFimage(x, description='my test data') as tf: print(f'libtiff write {fn}') #write demo tf.write_file(str(fn), compression='none') #read demo with TIFF.open(str(fn), mode='r') as tif: return tif.read_image() # for image in tif.iter_images(): # %% tifffile if 'tifffile' in modules: ofn = mkstemp('.tif', 'tifffile')[1] tic = time() write_multipage_tiff(imgs, ofn, descr='0 to 9 numbers', tags=[ (65000, 's', None, 'My custom tag #1', True), (65001, 's', None, 'My custom tag #2', True), (65002, 'f', 2, [123456.789, 9876.54321], True) ]) y = read_multipage_tiff(ofn) print(f'{time()-tic:.6f} seconds to read/write {ofn} with tifffile.') assert (y == imgs).all(), 'tifffile read/write equality failure' # %% if 'libtiff' in modules: tic = time() ofn = mkstemp('.tif', 'libtiff')[1] y = rwlibtiff(imgs, ofn) print(f'{time()-tic:.6f} seconds to read/write {ofn} with libtiff.') assert (y == imgs).all(), 'libtiff read/write equality failure' return y
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'], ` 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 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_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)
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')
acq_time = dt.datetime.strptime(meta.get_item('EXIF:CreateDate'), '%Y:%m:%d %H:%M:%S') # Convert acquisition time to julian to do time-dependent interpolation acq_time_julian = pd.Series([0], index=[acq_time]).index \ .to_julian_date().values # Calculate rad2refl factor m = refl_factors.loc[band, 'm'] c = refl_factors.loc[band, 'c'] rad2refl = m * acq_time_julian + c # Apply corrections/conversions fl_im_refl_cor = mc.calibrate_correct_image(fl_im_raw, meta, rad2refl) # Create a tiff structure from image data tiff = TIFFimage(fl_im_refl_cor, 'reflectance') filename = args.flight_loc + 'refl/' + fl_im_name.split(args.flight_loc + 'raw/')[1] tiff.write_file(filename, compression='none') # or 'lzw' del tiff # flushes data to disk # Copy metadata to refl TIFF from radiance TIFF # Note that if calibration model is provided by user then this won't be # written to output tiff. cmd = 'exiftool %s -overwrite_original -q -tagsFromFile %s' % (filename, fl_im_name) subprocess.call(cmd, shell=True) # Increment display counter n += 1
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 iter_Image(self, func): sys.stdout.write('iter_Image: reading image data from TIFF files\n') for detector in self.data: sys.stdout.write(' detector: %s\n' % (detector)) d_index = self.data[detector] # write the content of tiff files to a single raw files f,fn,dtype = None, None, None time_set = set() mn, mx = None, None mnz = float(self.config['PROTOCOL_Z_STACKER_Minimum']) mxz = float(self.config['PROTOCOL_Z_STACKER_Maximum']) nz = int(self.config['PROTOCOL_Z_STACKER_NumberOfFrames']) if nz > 1: dz = (mxz-mnz)/(nz-1) else: dz = 0 plane_l = [] ti = -1 exptime = '0' if detector=='Confocal': exptime = float(self.config['CONFOCAL_PixelAcqusitionTime']) * 1e-6 elif detector=='Andor': exptime = self.config['CAMERA_ANDOR_ExposureTime'] elif detector=='Imperx': for line in self.config['CAMERA_IMPERX_HardwareInformation'].split('\n'): if line.startswith ('Exposure time:'): v,u = line[14:].lstrip().split() v = v.strip (); u = u.strip () if u=='usec': exptime = float(v)*1e-6 elif u=='msec': exptime = float(v)*1e-3 elif u=='sec': exptime = float(v) else: raise NotImplementedError (`v,u,line`) else: raise NotImplementedError(`detector`) for t, index in sorted(d_index): if t not in time_set: time_set.add(t) ti += 1 zi = 0 else: zi += 1 z = mnz + dz * zi d = dict(DeltaT=str(t), TheT=str(ti), TheZ = str(zi), PositionZ=str(z), TheC='0', ExposureTime=str(exptime)) plane_l.append(d) tif = TIFFfile(d_index[t, index]) samples, sample_names = tif.get_samples() assert len (sample_names)==1,`sample_names` data = samples[0] if mn is None: mn, mx = data.min(), data.max() else: mn = min (data.min(), mn) mx = min (data.max(), mx) if f is None: shape = list(data.shape) dtype = data.dtype fn = tempfile.mktemp(suffix='.raw', prefix='%s_%s_' % (detector, dtype)) f = open (fn, 'wb') else: assert dtype is data.dtype,`dtype,data.dtype` shape[0] += 1 data.tofile(f) sys.stdout.write('\r copying TIFF image data to RAW file: %5s%% done' % (int(100.0*(index+1)/len(d_index)))) sys.stdout.flush() if f is None: continue f.close () shape = tuple (shape) xsz = shape[2] ysz = shape[1] tsz = len(time_set) zsz = shape[0] // tsz order = 'XYZTC' sys.stdout.write("\n RAW file contains %sx%sx%sx%sx%s [%s] array, dtype=%s, MIN/MAX=%s/%s\n" \ % (xsz, ysz,zsz,tsz,1,order, dtype, mn,mx)) assert zsz*tsz==shape[0],`zsz,tsz,shape` tif_filename = '%s%s.ome.tif' % (self.file_prefix, detector) sys.stdout.write(" creating memmap image for OME-TIF file %r..." % (tif_filename)) sys.stdout.flush() mmap = numpy.memmap(fn, dtype=dtype, mode='r', shape=shape) tif_image = TIFFimage(mmap) atexit.register(os.remove, fn) tif_uuid = self._mk_uuid() self.tif_images[detector, tif_filename, tif_uuid] = tif_image sys.stdout.write (' done\n') sys.stdout.flush() pixels_d = {} channel_d = dict(SamplesPerPixel='1') lpath_l = [] #channel_d todo: ExcitationWavelength, EmissionWavelength, Fluor, NDFilter, PockelCellSetting, Color if detector in ['Confocal']: objective = ome.ObjectiveSettings(ID='Objective:%s' % (self.config['olympus_optics_objective'])) instrument_id = 'Instrument:Airy' pixels_d['PhysicalSizeX'] = str(self.config['CONFOCAL_PixelSizeX']) pixels_d['PhysicalSizeY'] = str(self.config['CONFOCAL_PixelSizeY']) pixels_d['TimeIncrement'] = str(self.config['CONFOCAL_TimeBetweenFrames']) channel_d['Name'] = 'Confocal' channel_d['IlluminationType'] = 'Epifluorescence' channel_d['PinholeSize'] = '180' # todo: FluorescenceCorrelationSpectroscopy channel_d['AcquisitionMode'] = 'LaserScanningConfocalMicroscopy' for i in range (1,5): d1 = 'AOTFLine%s' % i ft = confocal_filters.get(d1) if ft is None: continue fn = ft['ex'][0] fn = get_aotf_filter_name (fn, self.config) if 'OFF' in fn: continue lpath_l.append(ome.ExcitationFilterRef(ID='Filter:%s:%s' % (d1,fn))) fn = confocal_filters['OpticalTableSplitter']['di'][0] lpath_l.append(ome.DichroicRef(ID='Dichroic:OpticalTableSplitter:%s' % (fn))) d1 = 'ThorlabsWheelPosition%s' % (self.config['thorlabs_filter_wheel_position'][3]) ft = confocal_filters.get(d1) if ft is not None: fn = ft['em'][0] lpath_l.append(ome.EmissionFilterRef (ID='Filter:%s:%s' % (d1,fn))) elif detector in ['Andor', 'Imperx']: objective = ome.ObjectiveSettings(ID='Objective:%s' % (self.config['optics_objective'])) instrument_id = 'Instrument:Suga' channel_d['Name'] = '%s camera' % (detector) channel_d['AcquisitionMode'] = 'WideField' pixels_d['PhysicalSizeX'] = pixels_d['PhysicalSizeY'] = str(self.config['CAMERA_%s_PixelSize' % (detector.upper ())]) tbf = float(self.config['CAMERA_%s_TimeBetweenFrames' % (detector.upper ())]) d1 = 'NikonTurretTopCube%s' % (self.config['top_turret_cube'][3]) d2 = 'NikonTurretBottomCube%s' % (self.config['bottom_turret_cube'][3]) top_cube = nikon_filters[d1] bottom_cube = nikon_filters[d2] if detector=='Andor': channel_d['IlluminationType'] = 'Epifluorescence' if self.config['CAMERA_ANDOR_FrameTransferMode']=='1': m = re.search(r'Kinetic cycle time:\s*(?P<time>\d+[.]\d*)\s*sec', self.config['CAMERA_ANDOR_HardwareInformation'], re.M) pixels_d['TimeIncrement'] = str(m.group('time')) else: pixels_d['TimeIncrement'] = str(tbf) if 'ex' in top_cube: fn = top_cube['ex'][0] lpath_l.append(ome.ExcitationFilterRef(ID='Filter:%s:%s' % (d1,fn))) if 'di' in top_cube: fn = top_cube['di'][0] lpath_l.append(ome.DichroicRef(ID='Dichroic:%s:%s' % (d1,fn))) if 'em' in top_cube: fn = top_cube['em'][0] lpath_l.append(ome.EmissionFilterRef(ID='Filter:%s:%s' % (d1,fn))) if 'ex' in bottom_cube: fn = bottom_cube['ex'][0] lpath_l.append(ome.EmissionFilterRef(ID='Filter:%s:%s' % (d2,fn))) else: #m = re.search(r'Exposure time:\s*(?P<time>\d+[.]\d*)\s*msec', self.config['CAMERA_IMPERX_HardwareInformation'], re.M) #exp_time = float (m.group ('time')) if self.config['main_protocol_mode'].startswith('MyocyteMechanicsFluorescence'): tbf = float(self.config['PROTOCOL_MYOCYTE_MECHANICS_TimeBetweenSavedFrames']) pixels_d['TimeIncrement'] = str(tbf) channel_d['IlluminationType'] = 'Transmitted' if self.config['optics_transmission_light_filter']!='Empty': fn = nikon_filters['NikonIllumination']['ex'][0] lpath_l.append(ome.ExcitationFilterRef(ID='Filter:NikonIllumination:%s' % (fn))) if 'di' in top_cube: fn = top_cube['di'][0] lpath_l.append(ome.EmissionFilterRef(ID='Filter:%s:%s' % (d1, fn))) if 'em' in top_cube: fn = top_cube['em'][0] lpath_l.append(ome.EmissionFilterRef(ID='Filter:%s:%s' % (d1,fn))) if 'em' in bottom_cube: fn = bottom_cube['em'][0] lpath_l.append(ome.EmissionFilterRef(ID='Filter:%s:%s' % (d2,fn))) if 'di' in bottom_cube: fn = bottom_cube['di'][0] lpath_l.append(ome.EmissionFilterRef(ID='Filter:%s:%s' % (d2,fn))) else: raise NotImplementedError (`detector`) if zsz>1: pixels_d['PhysicalSizeZ'] = str(dz) channel = ome.Channel(ID='Channel:%s' % (detector), **channel_d) lpath = ome.LightPath(*lpath_l) channel.append (lpath) #todo attributes: #todo elements: BIN:BinData, MetadataOnly, SA:AnnotationRef tiffdata = ome.TiffData(ome.UUID (tif_uuid, FileName=tif_filename)) pixels = ome.Pixels(channel, tiffdata, DimensionOrder=order, ID='Pixels:%s' % (detector), SizeX = str(xsz), SizeY = str(ysz), SizeZ = str(zsz), SizeT=str(tsz), SizeC = str(1), Type = self.dtype2PixelIType (dtype), **pixels_d ) for d in plane_l: pixels.append(ome.Plane(**d)) #todo attributes: Name #todo elements: Description, ExperimentRef, DatasetRef , # ImagingEnvironment, StageLabel, ROIRef, MicrobeamManipulationRef, AnnotationRef image = ome.Image (ome.AcquiredDate (self.get_AcquiredDate()), ome.ExperimenterRef(ID='Experimenter:%s' % (self.current_user)), ome.GroupRef(ID='Group:SysBio'), ome.InstrumentRef(ID=instrument_id), objective, pixels, ID='Image:%s' % (detector)) if 0: image.append(sa.AnnotationRef (ID='Annotation:configuration.txt')) yield image return
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'))
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.')
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_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 save(self, path): data_matrix = self.data.astype(np.uint16) tiff = TIFFimage(data_matrix, description='') tiff.write_file(path, compression='none', verbose=False)
# +/+ path p1 = "/Volumes/MoritzBertholdHD/CellData/Experiments/Ex3/LabeledImages/full_ex3_no_zeros_66_shifted/++/" # +/- path p2 = "/Volumes/MoritzBertholdHD/CellData/Experiments/Ex3/LabeledImages/full_ex3_no_zeros_66_shifted/+-/" # -/+ path p3 = "/Volumes/MoritzBertholdHD/CellData/Experiments/Ex3/LabeledImages/full_ex3_no_zeros_66_shifted/-+/" # -/- path p4 = "/Volumes/MoritzBertholdHD/CellData/Experiments/Ex3/LabeledImages/full_ex3_no_zeros_66_shifted/--/" # outliers # p5 = "/Volumes/MoritzBertholdHD/CellData/Experiments/Ex3/LabeledImages/full_ex3/outliers/" 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]) +