def crossings(y, value, x=None): '''Finds the crossing points where a (poly-)line defined by a 1D y array has the given values and return the (linearly) interpolated index or x value if an x array is given ''' if x is None: return _dsutils.crossings(y, value) return _dsutils.crossings(x, y, value)
def normalise(a, allelements=True): '''Normalise array so all elements lie between 0 and 1 Keyword argument: allelements -- if True, then normalise for all elements rather than per-element ''' if isinstance(a, _compoundds): return _dsutils.norm(a, allelements) return _dsutils.norm(a)
def centroid(weights, coords=None): '''Calculate the centroid of an array with its (half) indexes or coordinates (list of 1D arrays), if given, and returns it as a list ''' if coords is None: return _dsutils.centroid(weights) from .jycore import toList return _dsutils.centroid(weights, toList(coords))
def centroid(weights, coords=None): '''Calculate the centroid of an array with its (half) indexes or coordinates (list of 1D arrays), if given, and returns it as a list ''' if coords is None: return _dsutils.centroid(weights) from jycore import toList return _dsutils.centroid(weights, toList(coords))
def put(self, indices, values): if isinstance(indices, ndarray): inds = indices._jdataset() else: inds = asIterable(indices) if isinstance(values, ndarray): vals = values._jdataset() else: vals = asIterable(values) _dsutils.put(self.__dataset, inds, vals)
def append(arr, values, axis=None): '''Append values to end of array Keyword argument: axis -- if None, then append flattened values to flattened array ''' if not isinstance(values, _ds): values = __cvt_jobj(values, dtype=None, copy=False, force=True) if axis is None: return _dsutils.append(arr.flatten(), values.flatten(), 0) return _dsutils.append(arr, values, axis)
def getPosition(self): fileName = self.getSrsFileName(self.index, self.srsPath) self.dataHolder = dnp.io.load(fileName, formats=['srs']) self.yMax = self.dataHolder[self.yAxis].max() newformatpos = self.dataHolder[self.yAxis].maxPos() self.pos = newformatpos[0] self.xVal = self.dataHolder[self.xAxis][self.pos] # self.centroid=self.dataHolder.centroid(self.dataHolder.getAxis(self.xAxis), self.dataHolder.getAxis(self.yAxis)); self.centroid = DatasetUtils.centroid(self.dataHolder[self.yAxis], [self.dataHolder[self.xAxis]])[0] rtnList = [ self.index, int(self.pos), self.xVal, self.yMax, self.centroid ] self.extraValues = [] for axis in self.extraAxis: self.extraValues.append(self.dataHolder[axis][int(self.pos)]) for axis in self.metaAxis: if axis in self.dataHolder.metadata.keys(): self.extraValues.append(self.dataHolder.metadata[axis]) else: self.extraValues.append(None) return rtnList + self.extraValues
def unravel_index(indices, dims): '''Converts a flat index (or array of them) into a tuple of coordinate arrays ''' if isinstance(indices, (tuple, list)): indices = ndarray(buffer=indices)._jdataset() if not isinstance(indices, _ds): return tuple(_sutils.getNDPositionFromShape(indices, dims)) return tuple(_dsutils.calcPositionsFromIndexes(indices, dims))
def where(condition, x=None, y=None): '''Return items from x or y depending on condition''' if x and y: return _dsutils.select(condition, x, y) elif not x and not y: return _cmps.nonZero(condition) else: raise ValueError, "Both x and y must be specified"
def meshgrid(*a, **kwargs): indexing = kwargs.get('indexing', 'xy') if indexing == 'ij': a = [a[1], a[0]] + (a[2:] if len(a) > 2 else []) elif indexing != 'xy': raise ValueError, 'indexing value is not valid' axes = [ asDataset(x)._jdataset() for x in reversed(a) ] coords = _dsutils.meshGrid(axes) if indexing == 'ij': coords = [coords[1], coords[0]] + (coords[2:] if len(coords) > 2 else []) return tuple([ Sciwrap(x) for x in reversed(coords) ])
def choose(a, choices, mode='raise'): '''Return dataset with items drawn from choices according to conditions''' if mode == 'raise': rf = True cf = False else: rf = False if mode == 'clip': cf = True elif mode == 'wrap': cf = False else: raise ValueError, "mode is not one of raise, clip or wrap" return _dsutils.choose(a, choices, rf, cf)
def display(self, fileName=None): if fileName is None: fileName = self.fileName; self.dataHolder=dnp.io.load(fileName); dataset = self.dataHolder[0]; if self.panel: if self.logScale: SDAPlotter.imagePlot(self.panel, DatasetUtils.lognorm(dataset)); #For RCP GUI else: SDAPlotter.imagePlot(self.panel, dataset); #For RCP GUI else: print "No panel set to display" raise Exception("No panel_name set in %s. Set this or set %s.setAlive(False)" % (self.name,self.name));
def display(self,file=None): if file==None: file = self.getFullFileName() # self.data.loadPilatusData(file) self.data.load(PilatusTiffLoader(file)); dataset = self.data.getAxis(0); if self.panel: if self.logScale: SDAPlotter.imagePlot(self.panel, DatasetUtils.lognorm(dataset)); #For RCP GUI else: SDAPlotter.imagePlot(self.panel, dataset); #For RCP GUI else: print "No panel set to display" raise Exception("No panel_name set in %s. Set this or set %s.setAlive(False)" % (self.name,self.name));
def display(self,file=None): if file==None: file = self.getFullFileName() fileLoader = UViewDetectorClass.ImageFileLoaders[os.path.splitext(file)[-1].split('.')[-1].upper()]; self.data.load( fileLoader(file) ); dataset = self.data.getAxis(0); if self.panel: if self.logScale: RCPPlotter.imagePlot(self.panel, DatasetUtils.lognorm(dataset)); #For RCP GUI else: RCPPlotter.imagePlot(self.panel, dataset); #For RCP GUI else: print "No panel set to display" raise Exception("No panel_name set in %s. Set this or set %s.setAlive(False)" % (self.name,self.name));
def display(self, file=None): if file == None: file = self.getFullFileName() # self.data.loadPilatusData(file) self.data.load(PilatusTiffLoader(file)) dataset = self.data.getAxis(0) if self.panel: if self.logScale: SDAPlotter.imagePlot(self.panel, DatasetUtils.lognorm(dataset)) #For RCP GUI else: SDAPlotter.imagePlot(self.panel, dataset) #For RCP GUI else: print "No panel set to display" raise Exception( "No panel_name set in %s. Set this or set %s.setAlive(False)" % (self.name, self.name))
def ravel_multi_index(multi_index, dims, mode='raise'): '''Converts a tuple of coordinate arrays to an array of flat indexes ''' if isinstance(mode, tuple): mode = [_prep_mode.get(m, -1) for m in mode] else: mode = _prep_mode.get(mode, -1) if isinstance(multi_index, _ds): # split single array multi_index = [ _getslice(multi_index, i) for i in range(multi_index.shape[0]) ] single = False if isinstance(multi_index[0], int): single = True multi_index = [ array(m)._jdataset() for m in multi_index ] pos = _dsutils.calcIndexesFromPositions(multi_index, dims, mode) if single: return pos.getObject([]) return pos
def linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None): '''Create a 1D dataset from start to stop in given number of steps Arguments: start -- starting value stop -- stopping value num -- number of steps, defaults to 50 endpoint -- if True (default), include the stop value retstep -- if False (default), do not include the calculated step value as part of return tuple ''' if not endpoint: stop = ((num - 1) * stop + start)/num dtype = _translatenativetype(dtype) if dtype is None: dtype = _getdtypefromobj(((start, stop))) if dtype.value < float64.value: dtype = float64 if dtype.value >= complex64.value: dtype = complex128 if type(start) is _types.IntType: start = start+0j if type(stop) is _types.IntType: stop = stop+0j rresult = _df.createLinearSpace(start.real, stop.real, num, float64.value) iresult = _df.createLinearSpace(start.imag, stop.imag, num, float64.value) result = Sciwrap(_dsutils.createCompoundDataset(complex128.value, (rresult, iresult))) del rresult, iresult else: result = Sciwrap(_df.createLinearSpace(start, stop, num, dtype.value)) if retstep: step = result[1] - result[0] return (result, step) else: return result
def take(self, indices, axis=None): if isinstance(indices, ndarray): return _dsutils.take(self.__dataset, indices._jdataset(), axis) return _dsutils.take(self.__dataset, asIterable(indices), axis)
def tile(a, reps): return _dsutils.tile(a, asIterable(reps))
def nan_to_num(a): '''Create a copy with infinities replaced by max/min values and NaNs replaced by 0s ''' c = a.copy() _dsutils.removeNansAndInfinities(c) return c
def resize(a, new_shape): return _dsutils.resize(a, new_shape)
def split(ary, indices_or_sections, axis=0): return _dsutils.split(ary, indices_or_sections, axis, True)
def roll(a, shift, axis=None): return _dsutils.roll(a, shift, axis)
def flipud(a): return _dsutils.flipUpDown(a)
def fliplr(a): return _dsutils.flipLeftRight(a)
def indices(dimensions, dtype=int32): ind = _dsutils.indices(asIterable(dimensions)) dtype = _translatenativetype(dtype) if dtype != int32: ind = _dsutils.cast(ind, dtype.value) return ind
def repeat(a, repeats, axis=-1): return _dsutils.repeat(a, asIterable(repeats), axis)
def transpose(a, axes=None): if axes is None: axes = () return _dsutils.transpose(a, asIterable(axes))
def sort(a, axis=-1): if axis is None: return _dsutils.sort(a) return _dsutils.sort(a, axis)
def array_split(ary, indices_or_sections, axis=0): return _dsutils.split(ary, indices_or_sections, axis, False)
def rot90(a, k=1): return _dsutils.rotate90(a, k)
def rollaxis(a, axis, start=0): return _dsutils.rollAxis(a, axis, start)
def compoundarray(a, view=True): '''Create a compound array from an nd array by grouping last axis items into compound items ''' return _dsutils.createCompoundDatasetFromLastAxis(a, view)
def swapaxes(a, axis1, axis2): return _dsutils.swapAxes(a, axis1, axis2)
def cast(a, dtype): return _dsutils.cast(a, dtype.value)