def _read_array(f: tifffile.TiffFile) -> np.ndarray: image = f.asarray() assert image.dtype == uint16 if image.ndim == 2: image = image[None, :, :] assert image.ndim == 3 return image
def test(sample_path): detection_params = {'w_s': 11, 'peak_radius': 4., 'threshold': 40., 'max_peaks': 4 } sample = TiffFile(sample_path) curr_dir = os.path.dirname(__file__) fname = os.path.join( curr_dir, os.path.join(sample.fpath, sample.fname)) arr = sample.asarray() peaks = detect_peaks(arr, shape_label=('t', 'z', 'x', 'y'), verbose=True, show_progress=False, parallel=True, **detection_params) # del sample # sample = None gc.get_referrers(arr) del arr gc.collect()
def getarray(idx_buffer_filename): idx, buf, fname = idx_buffer_filename fbuf = BytesIO(buf) tfh = TiffFile(fbuf) ary = tfh.asarray() pageCount = ary.shape[0] if nplanes is not None: extra = pageCount % nplanes if extra: if discard_extra: pageCount = pageCount - extra logging.getLogger('thunder').warn( 'Ignored %d pages in file %s' % (extra, fname)) else: raise ValueError( "nplanes '%d' does not evenly divide '%d in file %s'" % (nplanes, pageCount, fname)) values = [ ary[i:(i + nplanes)] for i in range(0, pageCount, nplanes) ] else: values = [ary] tfh.close() if ary.ndim == 3: values = [val.squeeze() for val in values] nvals = len(values) keys = [(idx * nvals + timepoint, ) for timepoint in range(nvals)] return zip(keys, values)
def getOrthoTif(zfBytes): bytesio = io.BytesIO(zfBytes) zfiles = zipfile.ZipFile(bytesio, "r") for fn in zfiles.namelist(): if fn[-4:] == '.tif': tif = TiffFile(io.BytesIO(zfiles.open(fn).read())) return tif.asarray()
class LocalTiff(LocalTarget): tif = None def open(self): self.tif = TiffFile(self.path) return self def close(self): if self.tif is not None: self.tif.close() def __len__(self): return len(self.tif.pages) @property def shape(self): return (len(self), *self.tif.pages[0].shape) def __getitem__(self, item): if isinstance(item, tuple): if isinstance(item[0], int): return self[item[0]][item[1:]] else: return self[item[0]][item] else: out = self.tif.asarray(key=item) if isinstance(item, list) and len(item) == 1: return out[None] # Add axis elif isinstance(item, slice) and len( range(*item.indices(len(self)))) == 1: return out[None] # Add axis else: return out
def getarray(idx_buffer_filename): idx, buf, fname = idx_buffer_filename fbuf = BytesIO(buf) tfh = TiffFile(fbuf) ary = tfh.asarray() pageCount = ary.shape[0] if nplanes is not None: extra = pageCount % nplanes if extra: if discard_extra: pageCount = pageCount - extra logging.getLogger('thunder').warn('Ignored %d pages in file %s' % (extra, fname)) else: raise ValueError("nplanes '%d' does not evenly divide '%d in file %s'" % (nplanes, pageCount, fname)) values = [ary[i:(i+nplanes)] for i in range(0, pageCount, nplanes)] else: values = [ary] tfh.close() if ary.ndim == 3: values = [val.squeeze() for val in values] nvals = len(values) keys = [(idx*nvals + timepoint,) for timepoint in range(nvals)] return zip(keys, values)
class Viewer(QtWidgets.QMainWindow): def __init__(self): QtWidgets.QMainWindow.__init__(self) path = QtWidgets.QFileDialog.getOpenFileName(self, 'Choose file', '/', "(*.tiff *.tif)") if not path[0]: return path = path[0] self.tif = TiffFile(path) self.widget = QtWidgets.QWidget(parent=self) self.vlayout = QtWidgets.QVBoxLayout(self.widget) iv = ImageView(parent=self) iv.setImage(self.tif.asarray(key=0)) self.vlayout.addWidget(iv) self.slider = QtWidgets.QSlider(QtCore.Qt.Horizontal, parent=self) self.slider.setMaximum(len(self.tif.series) - 1) self.slider.setMinimum(0) self.slider.setSingleStep(1) self.slider.setPageStep(10) self.spinbox = QtWidgets.QSpinBox(parent=self) self.spinbox.setMaximum(len(self.tif.series) - 1) self.spinbox.setMinimum(0) self.spinbox.valueChanged.connect(self.slider.setValue) self.vlayout.addWidget(self.spinbox) self.vlayout.addWidget(self.slider) self.slider.valueChanged.connect( lambda i: iv.setImage( self.tif.asarray(key=i), autoRange=False, autoLevels=False, autoHistogramRange=False ) ) self.slider.valueChanged.connect(self.spinbox.setValue) self.setCentralWidget(self.widget)
def getOrthoTif(zfBytes): #given a zipfile as bytes (i.e. from reading from a binary file), # return a np array of rgbx values for each pixel bytesio = io.BytesIO(zfBytes) zfiles = zipfile.ZipFile(bytesio, "r") #find tif: for fn in zfiles.namelist(): if fn[-4:] == '.tif': #found it, turn into array: tif = TiffFile(io.BytesIO(zfiles.open(fn).read())) return tif.asarray()
def get_bedmap2(): filename = inspect.getframeinfo(inspect.currentframe()).filename home = os.path.dirname(os.path.abspath(filename)) direc = home + '/antarctica/bedmap2/bedmap2_tiff/' files = ['bedmap2_bed', 'bedmap2_surface', 'bedmap2_thickness', 'bedmap2_icemask_grounded_and_shelves', 'bedmap2_rockmask', #'bedmap2_lakemask_vostok', 'bedmap2_grounded_bed_uncertainty', #'bedmap2_thickness_uncertainty_5km', 'bedmap2_coverage', 'gl04c_geiod_to_WGS84'] vara = dict() # extents of domain : dx = 1000 west = -3333500.0 east = 3333500.0 north = 3333500.0 south = -3333500.0 #projection info : proj = 'stere' lat_0 = '-90' lat_ts = '-71' lon_0 = '0' names = ['b', 'h', 'H', 'mask', 'rock_mask', 'b_uncert', 'coverage', 'gl04c_to_WGS84'] sys.path.append(home + '/external_import_scripts') from tifffile import TiffFile # retrieve data : for n, f in zip(names, files): data = TiffFile(direc + f + '.tif') vara[n] = {'map_data' : data.asarray(), 'map_western_edge' : west, 'map_eastern_edge' : east, 'map_southern_edge' : south, 'map_northern_edge' : north, 'projection' : proj, 'standard lat' : lat_0, 'standard lon' : lon_0, 'lat true scale' : lat_ts} return vara
def getOrthoTif(filename, zfBytes): """ Ans 1b. :param filename: :param zfBytes: :return: """ #given a zipfile as bytes (i.e. from reading from a binary file), # return a np array of rgbx values for each pixel bytesio = io.BytesIO(zfBytes) zfiles = zipfile.ZipFile(bytesio, "r") #find tif: for fn in zfiles.namelist(): if fn[-4:] == '.tif': #found it, turn into array: tif = TiffFile(io.BytesIO(zfiles.open(fn).read())) return splitImage(filename.rsplit("/")[-1], tif.asarray(), 5)
def read_tiff_image(tiff_file, channel_names=None): from tifffile import TiffFile tiff_img = TiffFile(tiff_file) tiff_channels = tiff_img.asarray() n_channels = 1 if tiff_channels.ndim == 3 else tiff_channels.shape[1] if n_channels > 1: if channel_names is None: channel_names = ["CH" + str(i) for i in range(n_channels)] img = {} for i_channel, channel_name in enumerate(channel_names): img[channel_name] = SpatialImage( np.transpose(tiff_channels[:, i_channel], (1, 2, 0))) else: img = SpatialImage(np.transpose(tiff_channels, (1, 2, 0))) return img
def get_gre_measures(): filename = inspect.getframeinfo(inspect.currentframe()).filename home = os.path.dirname(os.path.abspath(filename)) sys.path.append(home + '/external_import_scripts') from tifffile import TiffFile direc = home + '/greenland/measures/greenland_vel_mosaic500_2008_2009_' files = ['sp', 'vx', 'vy', 'ex', 'ey'] vara = dict() # extents of domain : nx = 3010 ny = 5460 dx = 500 west = -645000.0 east = west + nx * dx south = -3370000.0 north = south + ny * dx #projection info : proj = 'stere' lat_0 = '90' lat_ts = '70' lon_0 = '-45' # retrieve data : vara['dataset'] = 'measures' for f in files: data = TiffFile(direc + f + '.tif') vara[f] = { 'map_data': data.asarray()[::-1, :], 'map_western_edge': west, 'map_eastern_edge': east, 'map_southern_edge': south, 'map_northern_edge': north, 'projection': proj, 'standard lat': lat_0, 'standard lon': lon_0, 'lat true scale': lat_ts } return vara
def open(self, filename): prefs = self.preferences # OPEN tif = TiffFile(str(filename)) img = tif.asarray() # due to different conventions: #img = transpose(img) # crop if prefs.pCrop.value(): r = (prefs.pCropX0.value(), prefs.pCropX1.value(), prefs.pCropY0.value(), prefs.pCropY1.value()) img = img[r[0]:r[1], r[2]:r[3]] # resize if prefs.pResize.value(): img = cv2.resize(img, (prefs.pResizeX.value(), prefs.pResizeY.value())) img = self.toFloat(img) try: # try to extract labels names set by imageJ: labels = tif.pages[0].imagej_tags['labels'] # remove surplus information: for n, l in enumerate(labels): try: i = l.index('\n') if i != -1: labels[n] = l[:i] except ValueError: # no \n in label pass except AttributeError: if img.ndim == 3: # color image labels = [str(r) for r in range(len(img))] else: labels = None tif.close() return img, labels
def get_gre_measures(): filename = inspect.getframeinfo(inspect.currentframe()).filename home = os.path.dirname(os.path.abspath(filename)) sys.path.append(home + '/external_import_scripts') from tifffile import TiffFile direc = home + '/greenland/measures/greenland_vel_mosaic500_2008_2009_' files = ['sp', 'vx', 'vy', 'ex', 'ey'] vara = dict() # extents of domain : nx = 3010 ny = 5460 dx = 500 west = -645000.0 east = west + nx*dx south = -3370000.0 north = south + ny*dx #projection info : proj = 'stere' lat_0 = '90' lat_ts = '70' lon_0 = '-45' # retrieve data : vara['dataset'] = 'measures' for f in files: data = TiffFile(direc + f + '.tif') vara[f] = {'map_data' : data.asarray()[::-1, :], 'map_western_edge' : west, 'map_eastern_edge' : east, 'map_southern_edge' : south, 'map_northern_edge' : north, 'projection' : proj, 'standard lat' : lat_0, 'standard lon' : lon_0, 'lat true scale' : lat_ts} return vara
def load( cls, load_locations: typing.List[typing.Union[str, BytesIO, Path]], range_changed: typing.Callable[[int, int], typing.Any] = None, step_changed: typing.Callable[[int], typing.Any] = None, metadata: typing.Optional[dict] = None, ): image_file = TiffFile(load_locations[0]) count_pages = [0] mutex = Lock() def report_func(): mutex.acquire() count_pages[0] += 1 step_changed(count_pages[0]) mutex.release() range_changed(0, len(image_file.series[0])) image_file.report_func = report_func mask_data = image_file.asarray() return MaskInfo(load_locations[0], mask_data)
def get_study_region(self): """ return: vara - dictionary - contains projection information as well as bed data intended to be an input to utilites.DataInput """ sys.path.append(self.home + '/external_import_scripts') from tifffile import TiffFile direc = self.home + '/elevation_data/elevation/ASTGTM2_S78E161_dem' vara = dict() # extents of domain : nx = 1049 ny = 1031 dx = 17.994319205518387 west = 423863.131 east = west + nx*dx south = -1304473.006 north = south + ny*dx # projection info : proj = 'stere' lat_0 = '-90' lon_0 = '0' lat_ts = '-71' # retrieve data : data = TiffFile(direc + '.tif') vara['b'] = {'map_data' : data.asarray(), 'map_western_edge' : west, 'map_eastern_edge' : east, 'map_southern_edge' : south, 'map_northern_edge' : north, 'projection' : proj, 'standard lat' : lat_0, 'standard lon' : lon_0, 'lat true scale' : lat_ts} return vara
def getOrthoTif(filename, zfBytes): filename = filename[filename.rfind('/') + 1:] #given a zipfile as bytes (i.e. from reading from a binary file), # return a np array of rgbx values for each pixel bytesio = io.BytesIO(zfBytes) zfiles = zipfile.ZipFile(bytesio, "r") #find tif: for fn in zfiles.namelist(): if fn[-4:] == '.tif': #found it, turn into array: tif = TiffFile(io.BytesIO(zfiles.open(fn).read())) result = [] tifArray = tif.asarray() splitBy = int(tifArray.shape[0] / 500) split1 = np.split(tifArray, splitBy, axis=0) arrayNumber = 0 for array in split1: split2 = np.split(array, splitBy, axis=1) for output in split2: outputFileName = filename + "-" + str(arrayNumber) arrayNumber = arrayNumber + 1 result.append((outputFileName, output)) return result
def __init__(self, filename, dtype=None): self.type = 2 tf = TiffFile(filename) vb = tf.asarray() nc = 0 if len(vb.shape) == 3: zdim, ydim, xdim = vb.shape else: zdim, ydim, xdim, nc = vb.shape if nc > 0 and vb.dtype == np.uint8: nc = 0 dp = tf.pages[0] try: xs = float(dp.x_resolution[1]) / dp.x_resolution[0] ys = float(dp.y_resolution[1]) / dp.y_resolution[0] except Exception: xs = ys = 1.0 zs = 1.0 vu = 0 if dp.is_imagej: if dp.imagej_tags.has_key('spacing'): zs = float(dp.imagej_tags.spacing) if dp.imagej_tags.has_key('unit') and dp.imagej_tags.unit != '': vu = Volume.VOXEL_UNITS[dp.imagej_tags.unit] vs = [xs, ys, zs] self.filename = filename self.data = vb if dtype is None or dtype is vb.dtype else vb.astype(dtype) self.xdim = xdim self.ydim = ydim self.zdim = zdim self.vdim = np.array([xdim, ydim, zdim]) self.vunit = vu self.vsize = np.round(vs, 3) self.nchan = nc self.clist = [0] * 8
def getOrthoTif(fileName, zfBytes): fileName = fileName[fileName.rfind('/') + 1:] # Given a zipfile as bytes (i.e. from reading from a binary file), # Return a np array of rgbx values for each pixel bytesio = io.BytesIO(zfBytes) zfiles = zipfile.ZipFile(bytesio, "r") # find tif: for fn in zfiles.namelist(): if fn[-4:] == '.tif': # found it, turn into array: tif = TiffFile(io.BytesIO(zfiles.open(fn).read())) arr = tif.asarray(); # Divide image in 500 * 500 size res = [] factor = int(arr.shape[0]/500) hArr = np.split(arr, factor, axis=0) count = 0 for h in hArr: vArr = np.split(h, factor, axis = 1) for v in vArr: name = fileName + "-" + str(count) res.append((name, v)) count += 1 return res
import sys sys.path.append("..") from peak_detection import detect_peaks from peak_detection import show_peaks from tifffile import TiffFile fname = 'sample.tif' detection_parameters = {'w_s': 10, 'peak_radius': 4., 'threshold': 60., 'max_peaks': 10 } sample = TiffFile(fname) arr = sample.asarray() peaks = detect_peaks(arr, shape_label=('t', 'z', 'x', 'y'), parallel=True, verbose=True, show_progress=False, **detection_parameters) for id, p in peaks.groupby(level="stacks"): print((p.shape[0])) show_peaks(arr, peaks, 3)
class TiffImageStack(ImageStack): extensions = ( '.tif', '.tiff', ) priority = 1000 def open(self, location, **kwargs): self.tiff = TiffFile(location.path) self._tiff_first_series = self.tiff.series[0] self._tiff_axes = self._tiff_first_series.axes self._tiff_shape = self._tiff_first_series.shape self._tiff_memmap = self.tiff.asarray(out='memmap') if 'swap_axes' in self.parameters: from_, to_ = self.parameters['swap_axes'].split('..') from_, to_ = from_ + to_, to_ + from_ self._tiff_axes = ''.join( to_[from_.index(axis)] if axis in from_ else axis for axis in self._tiff_axes) if 'S' in self._tiff_axes and 'C' not in self._tiff_axes: self._tiff_axes = self._tiff_axes.replace('S', 'C') assert self._tiff_axes.endswith('YX') or self._tiff_axes.endswith( 'YXS') or self._tiff_axes.endswith('YXC') dim = [] sizes = [] if 'Q' in self._tiff_axes: # Q is "unknown" if 'T' not in self._tiff_axes: self._tiff_axes = self._tiff_axes.replace('Q', 'T') elif 'R' not in self._tiff_axes: self._tiff_axes = self._tiff_axes.replace('Q', 'R') elif 'Z' not in self._tiff_axes: self._tiff_axes = self._tiff_axes.replace('Q', 'Z') else: raise RuntimeError( 'There is an unknown axis (Q) in the TIFF file,' 'but as well T, R, Z axes. Please change the TIFF file.') for char, size in zip(self._tiff_axes, self._tiff_shape): if char in ('X', 'Y'): continue dim.append(Dimensions.by_char(char)) sizes.append(size) self.set_dimensions_and_sizes(dim, sizes) # noinspection PyProtectedMember def notify_fork(self): self.tiff._fh.close() self.tiff._fh.open() def get_data(self, what): key = tuple([ what.get(Dimensions.by_char(char), 0) if char not in ('X', 'Y') else slice(None, None, None) for char, size in zip(self._tiff_axes, self._tiff_shape) ]) data = self._tiff_memmap.__getitem__(key) return data def get_meta(self, what): try: calibration = float(self.parameters['calibration']) except KeyError: try: tags = self.tiff.pages[0].tags assert tags['ResolutionUnit'].value == 1 # 1 == µm? x_resolution, y_resolution = tags['XResolution'].value, tags[ 'YResolution'].value assert x_resolution == y_resolution calibration = x_resolution[1] / x_resolution[0] except (KeyError, AssertionError): calibration = 1.0 try: interval = float(self.parameters['interval']) except KeyError: interval = 1.0 try: time = what[Dimensions.Time] except KeyError: time = 1.0 position = self.__class__.Position(x=0.0, y=0.0, z=0.0) meta = self.__class__.Metadata(time=interval * time, position=position, calibration=calibration) return meta
class Intermediate_handler: """ Wrapper for saving intermediate results to file and keeping track of them """ def __init__(self, filename): try: os.remove(filename) except: pass self.plane = 0 self.tif = None self.filename = filename self.refs = [] self.array = None def reader(self): self.read = True self.write = False return self def writer(self): self.write = True self.read = False return self def __enter__(self): if self.write: self.tif = TiffWriter(self.filename, bigtiff=True, append=True) if self.read: self.tif = TiffFile(self.filename) self.array = self.tif.asarray() # memmap=True) return self def __exit__(self, exc_type, exc_value, traceback): self.array = None self.tif.close() def close(self): self.array = None if self.tif is not None: self.tif.close() def write_plane(self, data, t, z, f): # works plane by plane # print 'writing plane' + str((t,z,f)) # print data.shape self.tif.save(data, compress=0, contiguous=True) if len(data.shape) > 2: for i in range(data.shape[0]): self.plane += 1 self.refs = self.refs + [(t, z + i)] else: self.plane += 1 self.refs = self.refs + [(t, z)] def read_plane(self, t, z, f): # works plane by plane planeno = self.refs.index((t, z)) return np.squeeze(self.tif.asarray(planeno))
def get_bedmap2(thklim=0.0): filename = inspect.getframeinfo(inspect.currentframe()).filename home = os.path.dirname(os.path.abspath(filename)) direc = home + '/antarctica/bedmap2/bedmap2_tiff/' sys.path.append(home + '/external_import_scripts') from tifffile import TiffFile b = TiffFile(direc + 'bedmap2_bed.tif') h = TiffFile(direc + 'bedmap2_surface.tif') H = TiffFile(direc + 'bedmap2_thickness.tif') mask = TiffFile(direc + 'bedmap2_icemask_grounded_and_shelves.tif') rock_mask = TiffFile(direc + 'bedmap2_rockmask.tif') b_uncert = TiffFile(direc + 'bedmap2_grounded_bed_uncertainty.tif') coverage = TiffFile(direc + 'bedmap2_coverage.tif') gl04c_WGS84 = TiffFile(direc + 'gl04c_geiod_to_WGS84.tif') b = b.asarray() h = h.asarray() H = H.asarray() mask = mask.asarray() rock_mask = rock_mask.asarray() b_uncert = b_uncert.asarray() coverage = coverage.asarray() gl04c_WGS84 = gl04c_WGS84.asarray() h[H < thklim] = b[H < thklim] + thklim H[H < thklim] = thklim vara = dict() # extents of domain : dx = 1000 west = -3333500.0 east = 3333500.0 north = 3333500.0 south = -3333500.0 #projection info : proj = 'stere' lat_0 = '-90' lat_ts = '-71' lon_0 = '0' names = [ 'B', 'S', 'H', 'mask', 'rock_mask', 'b_uncert', 'coverage', 'gl04c_WGS84' ] ftns = [b, h, H, mask, rock_mask, b_uncert, coverage, gl04c_WGS84] # retrieve data : vara['dataset'] = 'bedmap 2' for n, f in zip(names, ftns): vara[n] = { 'map_data': f[::-1, :], 'map_western_edge': west, 'map_eastern_edge': east, 'map_southern_edge': south, 'map_northern_edge': north, 'projection': proj, 'standard lat': lat_0, 'standard lon': lon_0, 'lat true scale': lat_ts } return vara
def get_bedmap2(thklim = 0.0): filename = inspect.getframeinfo(inspect.currentframe()).filename home = os.path.dirname(os.path.abspath(filename)) direc = home + '/antarctica/bedmap2/bedmap2_tiff/' sys.path.append(home + '/external_import_scripts') from tifffile import TiffFile b = TiffFile(direc + 'bedmap2_bed.tif') h = TiffFile(direc + 'bedmap2_surface.tif') H = TiffFile(direc + 'bedmap2_thickness.tif') mask = TiffFile(direc + 'bedmap2_icemask_grounded_and_shelves.tif') rock_mask = TiffFile(direc + 'bedmap2_rockmask.tif') b_uncert = TiffFile(direc + 'bedmap2_grounded_bed_uncertainty.tif') coverage = TiffFile(direc + 'bedmap2_coverage.tif') gl04c_WGS84 = TiffFile(direc + 'gl04c_geiod_to_WGS84.tif') b = b.asarray() h = h.asarray() H = H.asarray() mask = mask.asarray() rock_mask = rock_mask.asarray() b_uncert = b_uncert.asarray() coverage = coverage.asarray() gl04c_WGS84 = gl04c_WGS84.asarray() h[H < thklim] = b[H < thklim] + thklim H[H < thklim] = thklim vara = dict() # extents of domain : dx = 1000 west = -3333500.0 east = 3333500.0 north = 3333500.0 south = -3333500.0 #projection info : proj = 'stere' lat_0 = '-90' lat_ts = '-71' lon_0 = '0' names = ['B', 'S', 'H', 'mask', 'rock_mask', 'b_uncert', 'coverage', 'gl04c_WGS84'] ftns = [b, h, H, mask, rock_mask, b_uncert, coverage, gl04c_WGS84] # retrieve data : vara['dataset'] = 'bedmap 2' for n, f in zip(names, ftns): vara[n] = {'map_data' : f[::-1, :], 'map_western_edge' : west, 'map_eastern_edge' : east, 'map_southern_edge' : south, 'map_northern_edge' : north, 'projection' : proj, 'standard lat' : lat_0, 'standard lon' : lon_0, 'lat true scale' : lat_ts} return vara
def get_gre_measures(): """ `Greenland Measures <https://nsidc.org/data/NSIDC-0478/versions/2#>`_ surface velocity data. This function creates a new data field with key ``mask`` that is 1 where velocity measurements are present and 0 where they are not. You will have to download the data from the authors and manually place it in the ``cslvr_root_dir/data/greenland`` directory. The keys of the dictionary returned by this function are : * ``vx`` -- :math:`x`-component of velocity * ``vy`` -- :math:`y`-component of velocity * ``ex`` -- :math:`x`-component of velocity error * ``ey`` -- :math:`y`-component of velocity error * ``mask`` -- observation mask :rtype: dict """ s = "::: getting Greenland 'Measures' data from DataFactory :::" print_text(s, DataFactory.color) global home #direc = home + '/greenland/measures/greenland_vel_mosaic500_2008_2009' direc = home + '/greenland/greenland_vel_mosaic500_2016_2017_' #TODO: find a way to intelligently leave out the error if you don't want # to download them: files = ['mask', 'vx_v2', 'vy_v2']#, '_ex_v2', '_ey_v2'] vara = dict() d = TiffFile(direc + 'vx_v2.tif') mask = (d.asarray() != -2e9).astype('i') ftns = [mask] for n in files[1:]: data = TiffFile(direc + n + '.tif') ftns.append(data.asarray()) print_text(' Measures : %-*s key : "%s" '%(30,n,n), '230') print_text(' Measures : %-*s key : "%s"'%(30,files[0],files[0]), '230') #projection info : proj = 'stere' lat_0 = '90' lat_ts = '70' lon_0 = '-45' # create projection : txt = " +proj=" + proj \ + " +lat_0=" + lat_0 \ + " +lat_ts=" + lat_ts \ + " +lon_0=" + lon_0 \ + " +k=1 +x_0=0 +y_0=0 +no_defs +a=6378137 +rf=298.257223563" \ + " +towgs84=0.000,0.000,0.000 +to_meter=1" p = Proj(txt) # extents of domain : ny,nx = shape(d.asarray()) dx = 500 lon_min = -75.0 lon_max = -14.0 lat_min = 60.0 lat_max = 83.0 # old v1 values : # FIXME: no projection extents provided, only longitude ranges which # do not mach the data. What a f*****g disappointment. west = -645000.0 east = west + nx*dx south = -3370000.0 north = south + ny*dx # set up a dictionary for use with cslvr::DataInput class : vara['pyproj_Proj'] = p vara['map_western_edge'] = west vara['map_eastern_edge'] = east vara['map_southern_edge'] = south vara['map_northern_edge'] = north vara['nx'] = nx vara['ny'] = ny vara['dx'] = dx # retrieve data : vara['dataset'] = 'measures' vara['continent'] = 'greenland' for f,n in zip(ftns, files): vara[n] = f[::-1, :] return vara
def __init__(self, fname): tif = TiffFile(fname) # This class is only for ImageJ tiffs. assert tif.is_imagej is True # 'axes' defines the data arrangement in the image array, e.g. # 'ZCYX' for mutliple-stacks, mulitple-channels images, # 'CYX' for multiple-channels, single stack images, etc. axes = tif.series[0].axes # Images with z-stacks are not yet supported. if 'Z' in axes: raise NotImplementedError("Z-stacks are not supported") # Shape of file will only reflect (x, y) dimensions. Number # of channels is stored elsewhere. x_indx = axes.find('X') y_indx = axes.find('Y') shape = tif.series[0].shape self.shape = (shape[y_indx], shape[x_indx]) # Read tags and extract relevant information. self.fname = tif.filename self.fpath = tif.filehandle.path self.nchannels = tif.imagej_metadata['channels'] # If the image contains its own luts, use them. (Is this the # case with all images where 'mode' is 'composite'?) if 'luts' in tif.imagej_metadata: luts = tif.imagej_metadata['luts'] cmaps = [lut_to_cmap(lut) for lut in luts] # If there are no luts, use a standard colours for each # channel. (Is this the case with all images # tif.imagej_metadata['mode'] == 'color'?) else: colours = ('b', 'g', 'r', 'm', 'c')[:self.nchannels] cmaps = [std_cmap(colour) for colour in colours] ranges = tif.imagej_metadata['Ranges'] ranges = np.array(ranges).reshape(self.nchannels, -1) # Read image data. im = tif.asarray() # Single-channel images. if im.ndim == 2: self.__dict__['chan1'] = Channel(1, im, cmaps, ranges) # Multi-channel images. elif im.ndim == 3: for n in range(self.nchannels): # Multi-channel images are of type 'CYX' (first # dimension of the data array is 'channel'), where each # channel is in its own tiff page, or of type 'YXS' # (third dimension is 'sample per pixel', in practice # equivalent to channel), where all channels are # contained in the same tiff page and the page's # 'samples_per_pixel' is > 1. if axes == 'YXS': yx = im[:, :, n] elif axes == 'CYX': yx = im[n, :, :] # Create the channel. A unit is added to the channel # number's name to keep in line with the way channels # are displayed/named in ImageJ (i.e first channel is # number one, not 0. self.__dict__['chan%i' % (n + 1)] = Channel( n + 1, yx, cmaps[n], ranges[n]) else: raise NotImplementedError("Images with more than " + "3 dimensions are not supported.") # A 'tags' dictionary will hold relevant data. self.tags = { 'image_name': tif.filename, 'image_width': tif.pages[0].imagewidth, 'image_length': tif.pages[0].imagelength, 'unit': tif.imagej_metadata['unit'], 'x_resolution': tif.pages[0].tags['XResolution'].value, 'y_resolution': tif.pages[0].tags['YResolution'].value }
import sys sys.path.append("..") from peak_detection import detect_peaks from tifffile import TiffFile fname = 'sample.tif' detection_parameters = {'w_s': 10, 'peak_radius': 4., 'threshold': 60., 'max_peaks': 10 } sample = TiffFile(fname) peaks = detect_peaks(sample.asarray(), shape_label=('t', 'z', 'x', 'y'), parallel=True, verbose=True, show_progress=False, **detection_parameters) for id, p in peaks.groupby(level="stacks"): print p.shape[0]
def get_bedmap2(thklim = 0.0): """ Antarctica `Bedmap 2 <https://www.bas.ac.uk/project/bedmap-2/>`_ topography data. This data is downloaded by executing the script ``cslvr_root/scripts/download_antarctica_data.py`` The keys of the dictionary returned by this function are : * ``B`` -- basal topography height * ``S`` -- surface topography height * ``H`` -- ice thickness * ``mask`` -- ice shelf mask * ``rock_mask`` -- rock outcrop mask * ``b_uncert`` -- basal-topography uncertainty * ``coverage`` -- is a binary grid showing the distribution of ice thickness data used in the grid of ice thickness * ``gl04c_WGS84`` -- gives the values (as floating point) used to convert from heights relative to WGS84 datum to heights relative to EIGEN-GL04C geoid (to convert back to WGS84, add this grid) :param thklim: minimum-allowed ice thickness :type thklim: float :rtype: dict """ s = "::: getting 'Bedmap 2' data from DataFactory :::" print_text(s, DataFactory.color) global home direc = home + '/antarctica/bedmap2/' B = TiffFile(direc + 'bedmap2_bed.tif') S = TiffFile(direc + 'bedmap2_surface.tif') H = TiffFile(direc + 'bedmap2_thickness.tif') mask = TiffFile(direc + 'bedmap2_icemask_grounded_and_shelves.tif') rock_mask = TiffFile(direc + 'bedmap2_rockmask.tif') b_uncert = TiffFile(direc + 'bedmap2_grounded_bed_uncertainty.tif') coverage = TiffFile(direc + 'bedmap2_coverage.tif') gl04c_WGS84 = TiffFile(direc + 'gl04c_geiod_to_WGS84.tif') B = B.asarray() S = S.asarray() H = H.asarray() mask = mask.asarray() rock_mask = rock_mask.asarray() b_uncert = b_uncert.asarray() coverage = coverage.asarray() gl04c_WGS84 = gl04c_WGS84.asarray() # format the mask for cslvr : mask[mask == 1] = 2 mask[mask == 0] = 1 mask[mask == 127] = 0 # remove the junk data and impose thickness limit : B = S - H H[H == 32767] = thklim H[H <= thklim] = thklim S = B + H vara = dict() # extents of domain : nx = 6667 ny = 6667 dx = 1000.0 west = -3333500.0 east = 3333500.0 north = 3333500.0 south = -3333500.0 #projection info : proj = 'stere' lat_0 = '-90' lat_ts = '-71' lon_0 = '0' # create projection : txt = " +proj=" + proj \ + " +lat_0=" + lat_0 \ + " +lat_ts=" + lat_ts \ + " +lon_0=" + lon_0 \ + " +k=1 +x_0=0 +y_0=0 +no_defs +a=6378137 +rf=298.257223563" \ + " +towgs84=0.000,0.000,0.000 +to_meter=1" p = Proj(txt) # save the data in matlab format : vara['pyproj_Proj'] = p vara['map_western_edge'] = west vara['map_eastern_edge'] = east vara['map_southern_edge'] = south vara['map_northern_edge'] = north vara['nx'] = nx vara['ny'] = ny vara['dx'] = dx names = ['B', 'S', 'H', 'mask', 'rock_mask', 'b_uncert', 'coverage', 'gl04c_WGS84'] ftns = [B, S, H, mask, rock_mask, b_uncert, coverage, gl04c_WGS84] for n in names: print_text(' Bedmap 2 : %-*s key : "%s" '%(30,n,n), '230') # retrieve data : vara['dataset'] = 'bedmap 2' vara['continent'] = 'antarctica' for n, f in zip(names, ftns): vara[n] = f[::-1, :] return vara
import sys sys.path.append("..") from peak_detection import detect_peaks from tifffile import TiffFile fname = 'sample.tif' detection_parameters = { 'w_s': 10, 'peak_radius': 4., 'threshold': 60., 'max_peaks': 10 } sample = TiffFile(fname) peaks = detect_peaks(sample.asarray(), shape_label=('t', 'z', 'x', 'y'), parallel=True, verbose=True, show_progress=False, **detection_parameters) for id, p in peaks.groupby(level="stacks"): print p.shape[0]
class TiffImageReader(BaseImageReader): """ TIFF/LSM files reader. Base reading with :py:meth:`BaseImageReader.read_image` image_file: TiffFile mask_file: TiffFile """ def __init__(self, callback_function=None): super().__init__(callback_function) self.image_file = None self.mask_file: typing.Optional[TiffFile] = None self.colors = None self.labels = None self.ranges = None def read(self, image_path: typing.Union[str, BytesIO, Path], mask_path=None, ext=None) -> Image: """ Read tiff image from tiff_file """ self.spacing, self.colors, self.labels, self.ranges = self.default_spacing, None, None, None self.image_file = TiffFile(image_path) total_pages_num = len(self.image_file.series[0]) if mask_path is not None: self.mask_file = TiffFile(mask_path) total_pages_num += len(self.mask_file.series[0]) self.verify_mask() else: self.mask_file = None # shape = self.image_file.series[0].shape axes = self.image_file.series[0].axes self.callback_function("max", total_pages_num) if self.image_file.is_lsm: self.read_lsm_metadata() elif self.image_file.is_imagej: self.read_imagej_metadata() elif self.image_file.is_ome: self.read_ome_metadata() else: x_spac, y_spac = self.read_resolution_from_tags() self.spacing = self.default_spacing[0], y_spac, x_spac mutex = Lock() count_pages = [0] def report_func(): mutex.acquire() count_pages[0] += 1 self.callback_function("step", count_pages[0]) mutex.release() self.image_file.report_func = report_func try: image_data = self.image_file.asarray() except ValueError as e: # pragma: no cover raise TiffFileException(*e.args) image_data = self.update_array_shape(image_data, axes) if self.mask_file is not None: self.mask_file.report_func = report_func mask_data = self.mask_file.asarray() mask_data = self.update_array_shape( mask_data, self.mask_file.series[0].axes)[..., 0] else: mask_data = None self.image_file.close() if self.mask_file is not None: self.mask_file.close() if not isinstance(image_path, str): image_path = "" return self.image_class( image_data, self.spacing, mask=mask_data, default_coloring=self.colors, labels=self.labels, ranges=self.ranges, file_path=os.path.abspath(image_path), axes_order=self.return_order(), ) def verify_mask(self): """ verify if mask fit to image. Raise ValueError exception on error :return: """ if self.mask_file is None: # pragma: no cover return image_series = self.image_file.pages[0] mask_series = self.mask_file.pages[0] for i, pos in enumerate(mask_series.axes): if mask_series.shape[i] == 1: # pragma: no cover continue try: j = image_series.axes.index(pos) except ValueError: raise ValueError("Incompatible shape of mask and image (axes)") # TODO add verification if problem with T/Z/I if image_series.shape[j] != mask_series.shape[i]: raise ValueError("Incompatible shape of mask and image") # TODO Add verification if mask have to few dimensions @staticmethod def decode_int(val: int): """ This function split 32 bits int on 4 8-bits ints :param val: value to decode :return: list of four numbers with values from [0, 255] """ return [(val >> x) & 255 for x in [24, 16, 8, 0]] def read_resolution_from_tags(self): tags = self.image_file.pages[0].tags try: if self.image_file.is_imagej: scalar = name_to_scalar[ self.image_file.imagej_metadata["unit"]] else: unit = tags["ResolutionUnit"].value if unit == 3: scalar = name_to_scalar["centimeter"] elif unit == 2: scalar = name_to_scalar["cal"] else: raise KeyError( f"wrong scalar {tags['ResolutionUnit']}, {tags['ResolutionUnit'].value}" ) x_spacing = tags["XResolution"].value[1] / tags[ "XResolution"].value[0] * scalar y_spacing = tags["YResolution"].value[1] / tags[ "YResolution"].value[0] * scalar except (KeyError, ZeroDivisionError): x_spacing, y_spacing = self.default_spacing[ 2], self.default_spacing[1] return x_spacing, y_spacing def read_imagej_metadata(self): try: z_spacing = ( self.image_file.imagej_metadata["spacing"] * name_to_scalar[self.image_file.imagej_metadata["unit"]]) except KeyError: z_spacing = self.default_spacing[0] x_spacing, y_spacing = self.read_resolution_from_tags() self.spacing = z_spacing, y_spacing, x_spacing self.colors = self.image_file.imagej_metadata.get("LUTs") self.labels = self.image_file.imagej_metadata.get("Labels") if "Ranges" in self.image_file.imagej_metadata: ranges = self.image_file.imagej_metadata["Ranges"] self.ranges = list(zip(ranges[::2], ranges[1::2])) def read_ome_metadata(self): if isinstance(self.image_file.ome_metadata, str): if hasattr(tifffile, "xml2dict"): meta_data = tifffile.xml2dict( self.image_file.ome_metadata)["OME"]["Image"]["Pixels"] else: return else: meta_data = self.image_file.ome_metadata["Image"]["Pixels"] try: self.spacing = [ meta_data[f"PhysicalSize{x}"] * name_to_scalar[meta_data[f"PhysicalSize{x}Unit"]] for x in ["Z", "Y", "X"] ] except KeyError: # pragma: no cover pass if "Channel" in meta_data and isinstance(meta_data["Channel"], (list, tuple)): try: self.labels = [ch["Name"] for ch in meta_data["Channel"]] except KeyError: pass try: self.colors = [ self.decode_int(ch["Color"])[:-1] for ch in meta_data["Channel"] ] except KeyError: pass def read_lsm_metadata(self): self.spacing = [ self.image_file.lsm_metadata[f"VoxelSize{x}"] for x in ["Z", "Y", "X"] ] if "ChannelColors" in self.image_file.lsm_metadata: if "Colors" in self.image_file.lsm_metadata["ChannelColors"]: self.colors = [ x[:3] for x in self.image_file.lsm_metadata["ChannelColors"]["Colors"] ] if "ColorNames" in self.image_file.lsm_metadata["ChannelColors"]: self.labels = self.image_file.lsm_metadata["ChannelColors"][ "ColorNames"]