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 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 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 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 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)
