def testNonUniformAxes(self):
im = np.array(
[
[0., 1., 2.],
[30., 10., 50.],
[8., 9., 6.],
[-10., 0., 22.]
]
)
x = FieldContainer(np.array([1., 10., 200.]), unit=Quantity('1 m'))
y = FieldContainer(np.array([0., 2., 4., 8.]), unit=Quantity('1 cm'))
fc = FieldContainer(im, unit=Quantity('5 V'), dimensions=[y, x])
fc.seal()
grad_y, grad_x = np.gradient(fc.data)
grad_y /= np.gradient(y.data).reshape((4, 1))
grad_x /= np.gradient(x.data).reshape((1, 3))
grad_y = FieldContainer(
grad_y, unit=fc.unit / y.unit,
dimensions=copy.deepcopy(fc.dimensions)
)
grad_x = FieldContainer(
grad_x, unit=fc.unit / x.unit,
dimensions=copy.deepcopy(fc.dimensions)
)
grad_x = grad_x.inUnitsOf(grad_y)
expected_result = FieldContainer(
(grad_x.data ** 2 + grad_y.data ** 2) ** 0.5,
unit=copy.deepcopy(grad_y.unit),
dimensions=copy.deepcopy(fc.dimensions)
)
result = Gradient().gradientWorker(fc)
self.assertEqual(expected_result, result)
def testRatiosUpToTenPercentError(self):
delta = .1
from ImageProcessing.CoverageWorker import CoverageWorker
from ImageProcessing import FEATURE_COLOR, BACKGROUND_COLOR
from pyphant.quantities import Quantity
cworker = CoverageWorker()
for rho1Fac in [0.1, 0.25, 0.5, 1.0, 1.5, 2.0, 5.0, 10.0]:
rho1 = '%s mC / m ** 3' % (3000. * rho1Fac, )
rho2 = '3 C / m ** 3'
cworker.paramRho1.value = rho1
cworker.paramRho2.value = rho2
rho1 = Quantity(rho1)
rho2 = Quantity(rho2)
for ratio in numpy.arange(0.0, 1.01, 0.01):
cworker.paramW1.value = '%s%%' % (ratio * 100., )
result = cworker.threshold(self.image)
self.assertEqual(result.dimensions, self.image.dimensions)
stuff1 = numpy.where(result.data == FEATURE_COLOR, True,
False).sum()
stuff2 = numpy.where(result.data == BACKGROUND_COLOR, True,
False).sum()
self.assertEqual(stuff1 + stuff2, result.data.size)
stuff1 = (stuff1 * rho1).inUnitsOf('C / m ** 3').value
stuff2 = (stuff2 * rho2).inUnitsOf('C / m ** 3').value
actualRatio = stuff1 / (stuff1 + stuff2)
self.assertTrue(abs(ratio - actualRatio) <= delta)
def setUp(self):
self.arrays = []
self.arrays.append([1, 2, 3])
self.arrays.append([1.9, -2.2, 3.4])
self.matrix = [[3.8, 4.5], [-3.4, 546.6]]
self.shapes = []
self.shapes.append((5, np.array([6])))
self.shapes.append((5, np.array([6.])))
self.shapes.append(((3, 2), np.array([6])))
self.shapes.append(((3, 2), np.array([6.])))
self.angles = []
self.angles.append(Quantity('1.4 rad'))
self.angles.append(Quantity('2 rad'))
self.angles.append(Quantity('30 deg'))
self.angles.append(Quantity('-40 deg'))
self.length = Quantity('5.3 m')
self.phyunit = PhysicalUnit('m', 1., [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
self.phyunit **= 5
self.exps = [
0, 1, 2, 1. / 5, 1. / (5. + 1e-12), 1. / (5. - 1e-12),
-1. / (5. + 1e-12), -1. / (5. - 1e-12)
]
self.badexps = [
2., 1. / 6, 1. / (5. + 1e-8), 1. / (5. - 1e-8), -1. / (5. + 1e-8),
-1. / (5. - 1e-8)
]
self.values = [0, 1, 0., 1e-10, 4.049, 10.05, 3 - 1e-10]
self.values += [-1, -1e-10, -4.049, -10.05, -(3 - 1e-10)]
def testLoadOneRow(self):
result = self.load('onerow.fmf')
t = FieldContainer(numpy.array([1.0]), unit=Quantity('1 s'),
shortname='t', longname='time')
s = FieldContainer(numpy.array([2.0]), unit=Quantity('1 m'),
shortname='s', longname='distance')
self.checkExpected([t, s], result)
def setUp(self):
super(SampleContainerInSampleContainerTestCase, self).setUp()
sample1 = SampleContainer([self.dependent, self.field],
longname='First Sample',
shortname='X',
attributes=copy.copy(self.attributes).update(
{'isSample': 'It seems so.'}))
self.independent2 = FieldContainer(
0.3 * numpy.linspace(0, 1, self.testData.shape[0] * 10),
longname='independent variable',
shortname='x',
unit=Quantity('1 mg'),
attributes=copy.copy(self.attributes).update({'independent':
True}))
self.dependent2 = FieldContainer(9.81 * self.independent2.data,
dimensions=[self.independent2],
longname='dependent variable',
shortname='f',
unit=Quantity('9.81 nN'),
attributes=copy.copy(
self.attributes).update(
{'independent': False}))
sample2 = SampleContainer([self.dependent2, self.independent2],
longname='Second Sample',
shortname='Y',
attributes=copy.copy(self.attributes).update(
{'sample Nr.': 2}))
self.sample = SampleContainer([sample1, sample2],
longname='SampleContainer with Samples',
shortname='(X,Y)',
attributes=copy.copy(
self.attributes).update(
{'isSample': 'It seems so.'}))
self.sample.seal()
def testFloatAccuracy(self):
result = str2unit('16.8 mm', FMFversion='1.0')
diff = result - Quantity('16.8 mm')
self.assertEqual(abs(diff.value) < 2e-14,True)
result = str2unit('16.8 mm', FMFversion='1.0')
diff = Quantity('16.8 mm')
self.assertEqual(result, diff)
def threshold(self, image, subscriber=0):
th = float(self.paramThreshold.value)
if self.paramUnit.value.lower() != 'ignore':
from pyphant.quantities import Quantity, isQuantity
try:
unit = float(self.paramUnit.value)
assert not isQuantity(image.unit)
except ValueError:
try:
unit = Quantity(self.paramUnit.value)
except TypeError:
unit = Quantity(1.0, self.paramUnit.value)
assert isQuantity(image.unit)
assert unit.isCompatible(image.unit.unit)
th *= unit / image.unit
resultArray = scipy.where(image.data < th,
ImageProcessing.FEATURE_COLOR,
ImageProcessing.BACKGROUND_COLOR)
result = DataContainer.FieldContainer(resultArray,
dimensions=copy.deepcopy(
image.dimensions),
longname=u"Binary Image",
shortname=u"B")
result.seal()
return result
def loadImageAsGreyScale(self, subscriber=0):
im = Image.open(self.paramFilename.value)
if im.mode == "I;16":
im = im.convert("I")
data = scipy.misc.fromimage(im).astype("int16")
else:
data = scipy.misc.fromimage(im, flatten=True)
Ny, Nx = data.shape
xUnit = Quantity(self.paramXScale.value.encode('utf-8'))
xAxis = DataContainer.FieldContainer(scipy.linspace(0.0, xUnit.value,
Nx, True),
xUnit / xUnit.value,
longname = 'x-coordinate',
shortname = 'x')
if self.paramYScale.value == 'link2X':
yUnit = xUnit * float(Ny) / Nx
else:
yUnit = Quantity(self.paramYScale.value.encode('utf-8'))
yAxis = DataContainer.FieldContainer(scipy.linspace(0.0, yUnit.value,
Ny, True),
yUnit / yUnit.value,
longname = 'y-coordinate',
shortname = 'y')
try:
FieldUnit = Quantity(self.paramFieldUnit.value.encode('utf-8'))
except AttributeError:
FieldUnit = self.paramFieldUnit.value
result = DataContainer.FieldContainer(data,
FieldUnit,
longname="Image",
shortname="I",
dimensions=[yAxis, xAxis])
result.seal()
return result
def testLoadOneRowDep(self):
result = self.load('onerow_dep.fmf')
t = FieldContainer(numpy.array([1.0]), unit=Quantity('1 s'),
shortname='t', longname='time')
s = FieldContainer(numpy.array([5.0]), unit=Quantity('1 m'),
shortname='s', longname='distance')
s.dimensions[0] = deepcopy(t)
self.checkExpected([t, s], result)
def setUp(self):
self.quants = []
self.quants.append(Quantity("1000 m"))
self.quants.append(Quantity("1 km"))
self.quants.append(Quantity("1000.1 m"))
self.quants.append(0)
self.quants.append(None)
self.quants.append(Quantity("1000 s"))
def testHourPlanck(self):
"""
In FMF 1.0 unit 'h' denotes hours,
while in FMF 1.1 'h' denotes the Planck constant.
"""
result = str2unit('1h')
self.assertEqual(result, Quantity('6.62606896e-34 J*s'))
result = str2unit('1h', FMFversion='1.0')
self.assertEqual(result, Quantity('3600s'))
def normation(normationStr):
try:
unit = Quantity(str(normationStr))
except:
try:
unit = Quantity(1.0, str(normationStr))
except:
unit = float(normationStr)
return unit
def testUnits(self):
data = (np.arange(0, 256, .01)).reshape((80, 320))
image = FieldContainer(data, unit=Quantity('1 mJ'))
for dim in image.dimensions:
dim.unit = Quantity('1 cm')
image.seal()
gradient = Gradient()
result = gradient.gradientWorker(image)
self.assertEqual(result.dimensions, image.dimensions)
self.assertEqual(result.unit, Quantity('1 mJ / cm'))
def testVariable(self):
column = [('T', Quantity('22.4 degC'), Quantity('0.5 degC')),
('T', Quantity('11.2 degC'), Quantity('0.5 degC'))]
result = LoadFMF.column2FieldContainer('temperature', column)
expectedResult = FieldContainer(numpy.array([22.4, 11.2]),
error=numpy.array([0.5, 0.5]),
mask=numpy.array([False, False]),
unit='1 degC',
longname='temperature',
shortname='T')
assertEqual(result, expectedResult)
def testVariableFirstNaN(self):
column = [('T', 'NaN', Quantity('0.5 degC')),
('T', Quantity('11.2 degC'), None)]
result = LoadFMF.column2FieldContainer('temperature', column)
expectedResult = FieldContainer(numpy.array([numpy.NaN, 11.2]),
error=numpy.array([0.5, 0.0]),
mask=numpy.array([True, False]),
unit='1 degC',
longname='temperature',
shortname='T')
assertEqual(result, expectedResult)
def visit_Str(self, node):
quantity = Quantity(node.s)
class QuantityDummy(object):
pass
dummy = QuantityDummy()
dummy.unit = Quantity(1.0, quantity.unit)
dummy.data = quantity.value
dummy.dimensions = None
newName = self.getName(dummy)
return Name(newName, Load())
def testUnits(self):
from ImageProcessing.Gradient import Gradient
from pyphant.core.DataContainer import FieldContainer
from pyphant.quantities import Quantity
data = (numpy.arange(0, 256, .01)).reshape((80, 320))
image = FieldContainer(data, unit=Quantity('1 mJ'))
for dim in image.dimensions:
dim.unit = Quantity('1 cm')
image.seal()
gradient = Gradient()
result = gradient.gradientWorker(image)
self.assertEqual(result.dimensions, image.dimensions)
self.assertEqual(result.unit, Quantity('1 mJ / cm'))
def getDimension(self, axis, length):
from pyphant.quantities import Quantity
from pyphant.core.DataContainer import FieldContainer
import numpy
delta = Quantity(self.getParam('d' + axis).value)
start = Quantity(self.getParam('start' + axis).value)
start = start.inUnitsOf(delta.unit)
data = start.value + numpy.arange(0, length, dtype=float) * delta.value
dim = FieldContainer(data,
unit=Quantity(1.0, delta.unit),
shortname=axis,
longname='%s-Axis' % (axis.upper(), ))
return dim
def slice2ind(arg, dim):
if isinstance(arg, type("")):
sl = ["0" + a for a in arg.split(':')
] #Hack for quantities. which does not recognize .6 as a number.
unit = dim.unit
try:
hi = Quantity(sl[1])
try:
li = Quantity(sl[0])
except:
li = Quantity(float(sl[0]), hi.unit)
try:
li, hi = [
i.inUnitsOf(unit.unit).value / unit.value
for i in [li, hi]
]
except TypeError:
raise TypeError(
"IncompatibleUnits: Dimension %s: %s [%s] can not be sliced with \"%s\"."
% (dim.longname, dim.shortname, dim.unit, arg))
except SyntaxError:
li, hi = [float(i) / unit for i in sl]
f = dim.data
intervallElements = numpy.logical_and(f >= li, f < hi)
if numpy.alltrue(intervallElements):
start = 0
end = len(intervallElements) + 1
else:
dma = numpy.diff(intervallElements).nonzero()
if len(dma[0]) == 0:
raise NotImplementedError(
"This slice needs interpolation, which is not implemented yet."
)
if li <= f.min():
start = 0
end = dma[0][0] + 1
elif hi > f.max():
start = dma[0][0] + 1
end = len(intervallElements) + 1
elif hi == f.max():
start = dma[0][0] + 1
end = len(intervallElements)
else:
start, end = dma[0] + 1
return slice(start, end)
elif isinstance(arg, type(2)):
return slice(arg, arg + 1)
else:
return arg
def loadImageAsGreyScale(self, subscriber=0):
import os
import re
from scipy.misc import imread
import numpy
from pyphant.core.DataContainer import FieldContainer
from pyphant.quantities import Quantity
path = os.path.realpath(self.paramPath.value)
if os.path.isfile(path):
path = os.path.dirname(path)
pattern = re.compile(self.paramRegex.value)
filenames = filter(lambda x: pattern.match(x) is not None,
os.listdir(path))
filenames.sort()
filenames = [os.path.join(path, fname) for fname in filenames]
print path
zClip = self.getClip(self.paramZClip.value)
filenames = filenames[zClip[0]:zClip[1]]
assert len(filenames) >= 1
yClip = self.getClip(self.paramYClip.value)
xClip = self.getClip(self.paramXClip.value)
dtype = self.paramDtype.value
data = []
for i, fn in enumerate(filenames):
subscriber %= 1 + 99 * i / len(filenames)
data.append(imread(fn, True)[yClip[0]:yClip[1], xClip[0]:xClip[1]])
data = numpy.array(data, dtype=dtype)
axes = ['z', 'y', 'x']
dimensions = [
self.getDimension(a, data.shape[i]) for i, a in enumerate(axes)
]
try:
unit = Quantity(self.paramFieldUnit.value)
except AttributeError:
unit = self.paramFieldUnit.value
longname = self.paramLongname.value
shortname = self.paramShortname.value
image = FieldContainer(data=data,
dimensions=dimensions,
unit=unit,
longname=longname,
shortname=shortname,
attributes={
'yFactor': Quantity(self.paramDy.value),
'xFactor': Quantity(self.paramDx.value)
})
image.seal()
subscriber %= 100
return image
def setUp(self):
super(SampleContainerTestCase,self).setUp()
self.independent = FieldContainer(0.3*numpy.linspace(0,1,self.testData.shape[0]),
longname='independent variable',
shortname='x',
unit = Quantity('1 mg'),
attributes = copy.copy(self.attributes).update({'independent':True}))
self.dependent = FieldContainer(9.81*self.independent.data,
dimensions=[self.independent],
longname='dependent variable',
shortname='f',
unit = Quantity('9.81 nN'),
attributes = copy.copy(self.attributes).update({'independent':False}))
self.sample = SampleContainer([self.dependent,self.field],longname='Sample',shortname='X',
attributes = copy.copy(self.attributes).update({'isSample':'It seems so.'}))
self.sample.seal()
def createFieldContainer(key, array):
def longname2unit(name):
reg = re.compile(r"\[([^]]*)\]")
m = reg.search(name)
if not m or m.group(1) == "counts" or m.group(1) == "":
return 1.0
else:
return Quantity('1 ' + str(m.group(1)))
fieldUnit = longname2unit(key)
if isQuantity(fieldUnit):
fieldContainer = DataContainer.FieldContainer(numpy.array(array),
unit=fieldUnit,
longname=key)
else:
try:
quantities = [
Quantity(string.encode('latin-1')) for string in array
]
firstUnit = quantities[0].unit
scaledArray = [
quant.inUnitsOf(firstUnit).value for quant in quantities
]
fieldContainer = DataContainer.FieldContainer(
numpy.array(scaledArray),
unit='1. %s' % firstUnit.name(),
longname=key)
except:
fieldContainer = DataContainer.FieldContainer(numpy.array(array),
unit=fieldUnit,
longname=key)
return fieldContainer
def longname2unit(name):
reg = re.compile(r"\[([^]]*)\]")
m = reg.search(name)
if not m or m.group(1) == "counts" or m.group(1) == "":
return 1.0
else:
return Quantity('1 ' + str(m.group(1)))
def testLoadOneColumn(self):
result = self.load('onecolumn.fmf')
t = FieldContainer(numpy.array([1, 2, 3, 4]),
unit=Quantity('1 s'),
shortname='t',
longname='time')
self.checkExpected([t], result)
def testLoadOneValue(self):
result = self.load('onevalue.fmf')
t = FieldContainer(numpy.array([1.0]),
unit=Quantity('1 s'),
shortname='t',
longname='time')
self.checkExpected([t], result)
def setUp(self):
import tempfile
import os
self.dir = tempfile.mkdtemp()
self.dbase = self.dir + os.path.sep + "testcase.sqlite3"
self.wrapper = pyphant.core.SQLiteWrapper.SQLiteWrapper(self.dbase)
with self.wrapper:
self.wrapper.setup_dbase()
self.summary = {
'id': 'emd5://PC/aheld/'
'2009-01-01_12:00:00.123456/12345678910.field',
'longname': 'name',
'shortname': 'sn',
'creator': 'aheld',
'date': '2009-01-01_12:00:00.123456',
'machine': 'PC',
'type': 'field',
'unit': Quantity('10.03e-8 mm**-1'),
'attributes': {
'attribute1': 'bla1',
'attribute2': 'bla2'
},
'hash': '12345678910',
'dimensions': [im_id]
}
self.sc_summary = self.summary.copy()
self.sc_summary['id'] = self.summary['id'][:-5] + 'sample'
self.sc_summary.pop('unit')
self.sc_summary.pop('dimensions')
self.sc_summary['columns'] = [self.summary['id'], self.summary['id']]
self.sc_summary['type'] = 'sample'
self.sc_summary['longname'] = u'name2'
self.sc_summary['shortname'] = u'sn2'
def testPowersOfUnits(self):
expected = (1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
result = pyphant.core.SQLiteWrapper.quantity2powers(Quantity('1m'))
self.assertEqual(
expected, result,
"The number of basic units determining a quantity does not fit. The SQTLiteWrapper is expecting"
)
def calcAbsorption(self, osc, subscriber=0):
I = osc[u'I']
I_d = osc[u'I_d']
I_0 = osc[u'I_0']
A = - ((I.data - I_d.data) / (I_0.data - I_d.data) - 1)
if self.paramClipping.value == 1:
A[A > 1] = 1
A[A < 0] = 0
Abso = DataContainer.FieldContainer(A,
longname=u'absorption',
shortname=ur'\tilde{A}')
Abso.dimensions[-1] = I.dimensions[-1]
if self.paramMask_lamp.value == 1:
removePeak(Abso, Quantity('654nm'), Quantity('660nm'))
removePeak(Abso, Quantity('920nm'), Quantity('980nm'))
Abso.seal()
return Abso
def testSimpleQuantity(self):
"""
The the conversion of a simple textual quantity specification
to a quantity object.
"""
expected = Quantity('1V')
result = str2unit('1V')
self.assertEqual(expected, result)
class OscPlotPanel(PlotPanel):
x_key = 0
y_key = 1
c_key = 2
radius = Quantity('0.4mm')
vmin = None
vmax = None
def __init__(self, parent, dataContainer):
self.dataContainer = dataContainer
PlotPanel.__init__(self, parent)
def draw(self):
self.x = self.dataContainer[self.x_key]
self.y = self.dataContainer[self.y_key]
self.c = self.dataContainer[self.c_key]
if self.vmin is not None:
self.vmin /= self.c.unit
if self.vmax is not None:
self.vmax /= self.c.unit
self.figure.clear()
self.ax = self.figure.add_subplot(111)
self.figure.subplots_adjust(hspace=0.8)
aspect = self.y.unit / self.x.unit
if not isinstance(aspect, Quantity):
self.ax.set_aspect(aspect)
try:
if self.c.mask != None:
mask = numpy.logical_not(self.c.mask)
x = self.x.data[mask]
y = self.y.data[mask]
c = self.c.data[mask]
else:
x = self.x.data
y = self.y.data
c = self.c.data
self.scat = self.ax.scatter(x,
y,
s=numpy.pi *
(self.radius / self.x.unit)**2,
c=c,
vmin=self.vmin,
vmax=self.vmax)
self.colorbar = self.figure.colorbar(self.scat,
format=F(self.c),
ax=self.ax)
self.rescale(self.ax)
except Exception, e:
print e
self.ax.set_xlabel(self.x.label)
self.ax.set_ylabel(self.y.label)
try:
self.ax.set_title(self.dataContainer.attributes['title'])
except (KeyError, TypeError):
pass
self.ax.callbacks.connect('xlim_changed', self.rescale)
self.ax.callbacks.connect('ylim_changed', self.rescale)
self.canvas.draw()
