def read_spectra(self): ai = agilentImage(self.filename) info = ai.info X = ai.data try: features = info['wavenumbers'] except KeyError: #just start counting from 0 when nothing is known features = np.arange(X.shape[-1]) try: px_size = info['FPA Pixel Size'] * info['PixelAggregationSize'] except KeyError: # Use pixel units if FPA Pixel Size is not known px_size = 1 x_locs = np.linspace(0, X.shape[1] * px_size, num=X.shape[1], endpoint=False) y_locs = np.linspace(0, X.shape[0] * px_size, num=X.shape[0], endpoint=False) return _spectra_from_image(X, features, x_locs, y_locs)
def read_spectra(self): om = OmnicMap.OmnicMap(self.filename) info = om.info X = om.data try: lv = info['OmnicInfo']['Last X value'] fv = info['OmnicInfo']['First X value'] features = np.linspace(fv, lv, num=X.shape[-1]) except KeyError: #just start counting from 0 when nothing is known features = np.arange(X.shape[-1]) try: loc_first = info['OmnicInfo']["First map location"] loc_last = info['OmnicInfo']["Last map location"] x_locs = np.linspace(min(loc_first[0], loc_last[0]), max(loc_first[0], loc_last[0]), X.shape[1]) y_locs = np.linspace(min(loc_first[1], loc_last[1]), max(loc_first[1], loc_last[1]), X.shape[0]) except KeyError: x_locs = np.arange(X.shape[1]) y_locs = np.arange(X.shape[0]) return _spectra_from_image(X, features, x_locs, y_locs)
def read_spectra(self): import h5py as h5 if self.sheet: cube_nb = int(self.sheet) else: cube_nb = 1 with h5.File(self.filename, "r") as dataf: cube_h5 = dataf["data/cube_{:0>5d}".format(cube_nb)] # directly read into float64 so that Orange.data.Table does not # convert to float64 afterwards (if we would not read into float64, # the memory use would be 50% greater) cube_np = np.empty(cube_h5.shape, dtype=np.float64) cube_h5.read_direct(cube_np) energies = np.array(dataf['context/energies']) intensities = np.transpose(cube_np, (1, 2, 0)) height, width, _ = np.shape(intensities) x_locs = np.arange(width) y_locs = np.arange(height) return _spectra_from_image(intensities, energies, x_locs, y_locs)
def process_stack(data, xat, yat, upsample_factor=100, use_sobel=False, ref_frame_num=0): hypercube, lsx, lsy = get_hypercube(data, xat, yat) if bn.anynan(hypercube): raise NanInsideHypercube(True) calculate_shift = RegisterTranslation(upsample_factor=upsample_factor) filterfn = sobel if use_sobel else lambda x: x shifts, aligned_stack = alignstack(hypercube.T, shiftfn=calculate_shift, ref_frame_num=ref_frame_num, filterfn=filterfn) xmin, ymin = shifts[:, 0].min(), shifts[:, 1].min() xmax, ymax = shifts[:, 0].max(), shifts[:, 1].max() xmin, xmax = int(round(xmin)), int(round(xmax)) ymin, ymax = int(round(ymin)), int(round(ymax)) shape = hypercube.shape slicex = slice(max(xmax, 0), min(shape[1], shape[1] + xmin)) slicey = slice(max(ymax, 0), min(shape[0], shape[0] + ymin)) cropped = np.array(aligned_stack).T[slicey, slicex] # transform numpy array back to Orange.data.Table return shifts, build_spec_table( *_spectra_from_image(cropped, getx(data), np.linspace(*lsx)[slicex], np.linspace(*lsy)[slicey]))
def read_spectra(self): am = agilentMosaic(self.filename, dtype=np.float64) info = am.info X = am.data visible_images = am.vis try: features = info['wavenumbers'] except KeyError: #just start counting from 0 when nothing is known features = np.arange(X.shape[-1]) try: px_size = info['FPA Pixel Size'] * info['PixelAggregationSize'] except KeyError: # Use pixel units if FPA Pixel Size is not known px_size = 1 x_locs = np.linspace(0, X.shape[1] * px_size, num=X.shape[1], endpoint=False) y_locs = np.linspace(0, X.shape[0] * px_size, num=X.shape[0], endpoint=False) features, data, additional_table = _spectra_from_image( X, features, x_locs, y_locs) if visible_images: additional_table.attributes['visible_images'] = visible_images return features, data, additional_table
def read_spectra(self): import h5py hdf5_file = h5py.File(self.filename) if 'entry1/collection/beamline' in hdf5_file and \ hdf5_file['entry1/collection/beamline'][()].astype('str') == 'Hermes': x_locs = np.array(hdf5_file['entry1/Counter0/sample_x']) y_locs = np.array(hdf5_file['entry1/Counter0/sample_y']) energy = np.array(hdf5_file['entry1/Counter0/energy']) intensities = np.array(hdf5_file['entry1/Counter0/data']).T return _spectra_from_image(intensities, energy, x_locs, y_locs) else: raise IOError("Not an HDF5 HERMES file")
def read_spectra(self): a = spectral.io.envi.open(self.filename) X = np.array(a.load()) try: lv = a.metadata["wavelength"] features = np.array(list(map(float, lv))) except KeyError: #just start counting from 0 when nothing is known features = np.arange(X.shape[-1]) x_locs = np.arange(X.shape[1]) y_locs = np.arange(X.shape[0]) return _spectra_from_image(X, features, x_locs, y_locs)
def read_spectra(self): ai = agilentImageIFG(self.filename) info = ai.info X = ai.data features = np.arange(X.shape[-1]) try: px_size = info['FPA Pixel Size'] * info['PixelAggregationSize'] except KeyError: # Use pixel units if FPA Pixel Size is not known px_size = 1 x_locs = np.linspace(0, X.shape[1] * px_size, num=X.shape[1], endpoint=False) y_locs = np.linspace(0, X.shape[0] * px_size, num=X.shape[0], endpoint=False) features, data, additional_table = _spectra_from_image( X, features, x_locs, y_locs) import_params = [ 'Effective Laser Wavenumber', 'Under Sampling Ratio', ] new_attributes = [] new_columns = [] for param_key in import_params: try: param = info[param_key] except KeyError: pass else: new_attributes.append(ContinuousVariable.make(param_key)) new_columns.append(np.full((len(data), ), param)) domain = Domain(additional_table.domain.attributes, additional_table.domain.class_vars, additional_table.domain.metas + tuple(new_attributes)) table = additional_table.transform(domain) with table.unlocked(): table[:, new_attributes] = np.asarray(new_columns).T return (features, data, table)
def read_spectra(self): import h5py hdf5_file = h5py.File(self.filename, mode='r') if 'entry1/definition' in hdf5_file and \ hdf5_file['entry1/definition'][()].astype('str') == 'NXstxm': grp = hdf5_file['entry1/Counter1'] x_locs = np.array(grp['sample_x']) y_locs = np.array(grp['sample_y']) energy = np.array(grp['photon_energy']) order = [ grp[n].attrs['axis'] - 1 for n in ['sample_y', 'sample_x', 'photon_energy'] ] intensities = np.array(grp['data']).transpose(order) return _spectra_from_image(intensities, energy, x_locs, y_locs) else: raise IOError("Not an NXS HDF5 @I08/Diamond file")
def read_tile(self): am = agilentMosaicTiles(self.filename) info = am.info tiles = am.tiles ytiles = am.tiles.shape[0] features = info['wavenumbers'] attrs = [ Orange.data.ContinuousVariable.make("%f" % f) for f in features ] domain = Orange.data.Domain( attrs, None, metas=[ Orange.data.ContinuousVariable.make("map_x"), Orange.data.ContinuousVariable.make("map_y") ]) try: px_size = info['FPA Pixel Size'] * info['PixelAggregationSize'] except KeyError: # Use pixel units if FPA Pixel Size is not known px_size = 1 for (x, y) in np.ndindex(tiles.shape): tile = tiles[x, y]() x_size, y_size = tile.shape[1], tile.shape[0] x_locs = np.linspace(x * x_size * px_size, (x + 1) * x_size * px_size, num=x_size, endpoint=False) y_locs = np.linspace((ytiles - y - 1) * y_size * px_size, (ytiles - y) * y_size * px_size, num=y_size, endpoint=False) _, data, additional_table = _spectra_from_image( tile, None, x_locs, y_locs) data = np.asarray( data, dtype=np.float64) # Orange assumes X to be float64 tile_table = Orange.data.Table.from_numpy( domain, X=data, metas=additional_table.metas) yield tile_table
def test_hypercube_roundtrip(self): d = self.mosaic xat = [v for v in d.domain.metas if v.name == "map_x"][0] yat = [v for v in d.domain.metas if v.name == "map_y"][0] hypercube, lsx, lsy = get_hypercube(d, xat, yat) features = getx(d) ndom = Orange.data.Domain([xat, yat]) datam = d.transform(ndom) coorx = datam.X[:, 0] coory = datam.X[:, 1] coords = np.ones((lsx[2], lsy[2], 2)) coords[index_values(coorx, lsx), index_values(coory, lsy)] = datam.X x_locs = coords[:, 0, 0] y_locs = coords[0, :, 1] features, spectra, data = _spectra_from_image(hypercube, features, x_locs, y_locs) nd = build_spec_table(features, spectra, data) np.testing.assert_equal(d.X, nd.X) np.testing.assert_equal(d.Y, nd.Y) np.testing.assert_equal(d.metas, nd.metas) self.assertEqual(d.domain, nd.domain)
def read_spectra(self): with open(self.filename, 'r') as f: # Parse file contents into dictionaries/lists self._lex = shlex.shlex(instream=f) try: hdrdata = self.read_hdr_dict(inner=False) except AssertionError as e: raise IOError('Error parsing hdr file ' + self.filename) from e regions = hdrdata['ScanDefinition']['Regions'][0] axes = [ regions['QAxis'], regions['PAxis'], hdrdata['ScanDefinition']['StackAxis'] ] dims = [len(ax['Points']) for ax in axes] spectra = np.empty(dims) for nf in range(dims[2]): ximname = '%s_a%03d.xim' % (self.filename[:-4], nf) xim = np.loadtxt(ximname) spectra[..., nf] = xim x_loc = axes[1]['Points'] y_loc = axes[0]['Points'] features = np.asarray(axes[2]['Points']) return _spectra_from_image(spectra, features, x_loc, y_loc)
def orange_table_from_3d(image3d): info = _spectra_from_image(image3d, range(5), range(image3d[:, :, 0].shape[1]), range(image3d[:, :, 0].shape[0])) data = build_spec_table(*info) return data
def read_spectra(self): X, XRr, YRr = reader_gsf(self.filename) data = _spectra_from_image(X, [1], XRr, YRr) return data
def read_spectra(self): channels = self.get_channels() for c, label in channels.items(): if label.decode("utf-8") == self.sheet: self.data_signal = c break else: self.data_signal = list(channels.keys())[0] import h5py hdf5_file = h5py.File(self.filename, 'r') keys = list(hdf5_file.keys()) hyperspectra = False intensities = [] wavenumbers = [] x_locs = [] y_locs = [] # load measurements for meas_name in filter(lambda s: s.startswith('Measurement'), keys): hdf5_meas = hdf5_file[meas_name] meas_keys = list(hdf5_meas.keys()) meas_attrs = hdf5_meas.attrs # check if this measurement contains the selected data channel selected_signal = False for chan_name in filter(lambda s: s.startswith('Channel'), meas_keys): hdf5_chan = hdf5_meas[chan_name] if hdf5_chan.attrs.keys().__contains__( 'DataSignal' ) and hdf5_chan.attrs['DataSignal'] == self.data_signal: selected_signal = True break if not selected_signal: continue # build range arrays spec_vals = [] try: if meas_attrs.keys().__contains__('RangeWavenumberStart'): wn_start = meas_attrs['RangeWavenumberStart'][0] wn_end = meas_attrs['RangeWavenumberEnd'][0] wn_points = meas_attrs['RangeWavenumberPoints'][0] spec_vals = np.linspace(wn_start, wn_end, wn_points) except: raise IOError("Error reading wavenumber range from " + self.filename) pos_vals = [] try: if meas_attrs.keys().__contains__('RangeXStart'): x_start = meas_attrs['RangeXStart'][0] x_points = meas_attrs['RangeXPoints'][0] x_incr = meas_attrs['RangeXIncrement'][0] x_end = x_start + x_incr * (x_points - 1) x_min = min(x_start, x_end) if meas_attrs.keys().__contains__('RangeYStart'): y_start = meas_attrs['RangeYStart'][0] y_points = meas_attrs['RangeYPoints'][0] y_incr = meas_attrs['RangeYIncrement'][0] y_end = y_start + y_incr * (y_points - 1) y_min = min(y_start, y_end) # construct the positions array for iY in range(int(y_points)): y = y_min + iY * abs(y_incr) for iX in range(int(x_points)): x = x_min + iX * abs(x_incr) pos_vals.append([x, y]) pos_vals = np.array(pos_vals) else: pos_vals = np.array([1]) except: raise IOError("Error reading position data from " + self.filename) hyperspectra = pos_vals.shape[0] > 1 # ignore backgrounds and unchecked data if not hyperspectra: if meas_attrs.keys().__contains__( 'IsBackground') and meas_attrs['IsBackground'][0]: continue if meas_attrs.keys().__contains__( 'Checked') and not meas_attrs['Checked'][0]: continue if len(wavenumbers) == 0: wavenumbers = spec_vals if hyperspectra: x_len = meas_attrs['RangeXPoints'][0] y_len = meas_attrs['RangeYPoints'][0] x_locs = pos_vals[:x_len, 0] y_indices = np.round( np.linspace(0, pos_vals.shape[0] - 1, y_len)).astype(int) y_locs = pos_vals[y_indices, 1] else: x_locs.append(meas_attrs['LocationX'][0]) y_locs.append(meas_attrs['LocationY'][0]) # load channels for chan_name in filter(lambda s: s.startswith('Channel'), meas_keys): hdf5_chan = hdf5_meas[chan_name] chan_attrs = hdf5_chan.attrs signal = chan_attrs['DataSignal'] if signal != self.data_signal: continue data = hdf5_chan['Raw_Data'] if hyperspectra: rows = meas_attrs['RangeYPoints'][0] cols = meas_attrs['RangeXPoints'][0] intensities = np.reshape(data, ( rows, cols, data.shape[1])) # organized rows, columns, wavelengths break else: intensities.append(data[0, :]) intensities = np.array(intensities) features = np.array(wavenumbers) x_locs = np.array(x_locs).flatten() y_locs = np.array(y_locs).flatten() if hyperspectra: return _spectra_from_image(intensities, features, x_locs, y_locs) else: spectra = intensities # locations x_loc = y_loc = np.arange(spectra.shape[0]) metas = np.array([x_locs[x_loc], y_locs[y_loc]]).T domain = Orange.data.Domain( [], None, metas=[ Orange.data.ContinuousVariable.make("map_x"), Orange.data.ContinuousVariable.make("map_y") ]) data = Orange.data.Table.from_numpy(domain, X=np.zeros((len(spectra), 0)), metas=np.asarray(metas, dtype=object)) return features, spectra, data