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 findMaskPoints(self, image, mask, subscriber=0):
"""
Returns a table of masked points with each row
giving a tuple (coordinate_1, ..., coordindate_n, value).
"""
self.check(image, mask)
subscriber %= 10.0
index = (mask.data == FEATURE_COLOR).nonzero()
zVal = image.data[index]
subscriber %= 60.0
fields = []
for dim, coord in enumerate(index):
newField = FieldContainer(
image.dimensions[dim].data[coord],
image.dimensions[dim].unit,
longname=image.dimensions[dim].longname + " %i" % dim,
shortname=image.dimensions[dim].shortname)
fields.append(newField)
fields.append(
FieldContainer(zVal,
image.unit,
longname=image.longname,
shortname=image.shortname))
res = SampleContainer(
fields, u"Points from %s at %s" % (image.longname, mask.longname),
u"X1")
res.seal()
subscriber %= 100.0
return res
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 testSCwithSCColumn(self):
fc_child1 = FieldContainer(longname='fc_child1', data=N.ones((10, 10)))
fc_child2 = FieldContainer(longname='fc_child2', data=N.ones((20, 20)))
sc_child = SampleContainer(longname='sc_child', columns=[fc_child1])
sc_parent = SampleContainer(longname='sc_parent',
columns=[sc_child, fc_child2])
sc_parent.seal()
km = KnowledgeManager.getInstance()
km.registerDataContainer(sc_parent, temporary=True)
lnlist = km.search(['longname'], {'col_of': {'longname': 'sc_parent'}})
lnlist = [entry[0] for entry in lnlist]
assert len(lnlist) == 2
assert 'fc_child2' in lnlist
assert 'sc_child' in lnlist
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 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 testCall(self):
from ImageProcessing.FitBackground import FitBackground
from pyphant.core.DataContainer import FieldContainer
data = (numpy.arange(0, 256, .001)).reshape((800, 320))
image = FieldContainer(data)
fbw = FitBackground()
fbw.fit_background(image)
def testStrings(self):
column = ['Hello', 'World']
result = FMFLoader.column2FieldContainer('simple string', column)
expectedResult = FieldContainer(
numpy.array(column), longname='simple string'
)
assertEqual(result, expectedResult)
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 testListofStrings(self):
column = ['World', ['Hello', 'World'], 'World']
result = LoadFMF.column2FieldContainer('simple string', column)
expectedResult = FieldContainer(numpy.array(
['World', 'Hello, World', 'World']),
longname='simple string')
assertEqual(result, expectedResult)
def setUp(self):
data = NPArray([10.0, -103.5, 1000.43, 0.0, 10.0])
unit = PQ('3s')
error = NPArray([0.1, 0.2, 4.5, 0.1, 0.2])
longname = u'Test: FieldContainer H5FileHandler'
shortname = u'TestH5FC'
attributes = {'custom1': u'testing1...', 'custom2': u'testing2...'}
self.fc = FieldContainer(data, unit, error, None, None, longname,
shortname, attributes)
self.fc.seal()
fc2 = FieldContainer(NPArray([4003.2, 5.3, 600.9]), PQ('0.2m'), None,
None, None, 'FieldContainer 2', 'FC2')
fc2.seal()
columns = [self.fc, fc2]
longname = u'Test: SampleContainer H5FileHandler'
shortname = u'TestH5SC'
self.sc = SampleContainer(columns, longname, shortname, attributes)
self.sc.seal()
def testNormalize(self):
from ImageProcessing.EnhanceContrast import EnhanceContrast
from pyphant.core.DataContainer import FieldContainer
data = (numpy.arange(0, 256, 1) * .5 + 20.).reshape((16, 16))
image = FieldContainer(data)
enhanceContrast = EnhanceContrast()
result = enhanceContrast.enhance(image)
self.assertEqual(result.data.min(), 0)
self.assertEqual(result.data.max(), 255)
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 setUp(self):
data = NPArray([10.0, -103.5, 1000.43, 0.0, 10.0])
unit = PQ('3s')
error = NPArray([0.1, 0.2, 4.5, 0.1, 0.2])
longname = u'Test: FieldContainer H5FileHandler'
shortname = u'TestH5FC'
attributes = {'custom1': u'testing1...', 'custom2': u'testing2...'}
self.fc = FieldContainer(data, unit, error, None, None, longname,
shortname, attributes)
self.fc.seal()
def testDateTime(self):
"""Test the correct saving and restoring of object arrays composed from datetime objects."""
objectArray = numpy.array([datetime.datetime.now() for i in range(10)])
objectField = FieldContainer(objectArray,longname=u"timestamp",
shortname='t')
objectField.seal()
self.eln.createGroup(self.eln.root,'testObjectFields')
saveField(self.eln,self.eln.root.testObjectFields,objectField)
restoredField = loadField(self.eln,self.eln.root.testObjectFields)
for i,j in zip(restoredField.data.tolist(),objectField.data.tolist()):
self.assertEqual(i,j,'Expected %s but got %s!' % (j,i))
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 testCall(self):
"""
test call to fillImage
no test for reasonable results
"""
from ImageProcessing.EdgeFillWorker import EdgeFillWorker
from pyphant.core.DataContainer import FieldContainer
image = FieldContainer(numpy.zeros((100, 200), dtype='uint8'))
efw = EdgeFillWorker()
efw.fillImage(image)
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 find(self, image, subscriber=0):
newdata = self.findExtrema(image.data)
longname = "FindLocalExtrema"
from pyphant.core.DataContainer import FieldContainer
result = FieldContainer(newdata, copy.deepcopy(image.unit),
copy.deepcopy(image.error),
copy.deepcopy(image.mask),
copy.deepcopy(image.dimensions),
longname, image.shortname,
copy.deepcopy(image.attributes), False)
result.seal()
return result
def testWatershed(self):
from ImageProcessing.Watershed import Watershed
from pyphant.core.DataContainer import FieldContainer
from pyphant.quantities import Quantity
data = numpy.zeros((10, 10), dtype='uint8')
data[2:8, 2:8] = 1
image = FieldContainer(data)
for dim in image.dimensions:
dim.unit = Quantity('1 mum')
image.seal()
data = numpy.zeros((10, 10), dtype='uint8')
data[3][3] = 1
data[4][6] = 2
markers = FieldContainer(data)
for dim in markers.dimensions:
dim.unit = Quantity('1 mum')
wshed = Watershed()
result = wshed.wsworker(image, markers)
self.assertEqual(result.dimensions, image.dimensions)
from scipy.ndimage import label
self.assertEqual(label(result.data)[1], 2)
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 get_column_fc(col, ln, sn):
try:
from pyphant.quantities import Quantity
unit = Quantity(1.0, col[0].unit)
data = [quant.value for quant in col]
except (KeyError, AttributeError):
unit = 1
data = col
from numpy import array
from pyphant.core.DataContainer import FieldContainer
fc = FieldContainer(data=array(data), unit=unit,
longname=ln, shortname=sn)
return fc
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 invert(self, image, subscriber=0):
max = scipy.amax(image.data)
min = scipy.amin(image.data)
data = max + min - image.data
from pyphant.core.DataContainer import FieldContainer
result = FieldContainer(data,
unit=image.unit,
dimensions=copy.deepcopy(image.dimensions),
mask=copy.deepcopy(image.mask),
error=copy.deepcopy(image.error),
longname=image.longname,
shortname=image.shortname)
result.seal()
return result
def testUnicodeFields(self):
self.field.seal()
unicodeArray = numpy.array([u'Hallo World!',u'Hallo Wörld!'])
unicodeField = FieldContainer(unicodeArray,longname=u"blabla",
shortname=self.shortname,
unit = 1,
attributes = self.attributes
)
unicodeField.seal()
self.eln.createGroup(self.eln.root,'testUnicodeFields')
saveField(self.eln,self.eln.root.testUnicodeFields,unicodeField)
restoredField = loadField(self.eln,self.eln.root.testUnicodeFields)
self.assertEqual(restoredField,unicodeField,
"Restored unicode string is %s (%s) but is expected to be %s (%s)." % (restoredField.data,restoredField.data.dtype,unicodeField.data,unicodeField.data.dtype))
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 testInvert(self):
from ImageProcessing.InvertWorker import InvertWorker
from pyphant.core.DataContainer import FieldContainer
from pyphant.quantities import Quantity
data = numpy.ones((100, 100), dtype='uint8') * 112
data[0][0] = 0
image = FieldContainer(data)
for dim in image.dimensions:
dim.unit = Quantity('1 cm')
image.seal()
invert = InvertWorker()
result = invert.invert(image)
self.assertEqual(result.dimensions, image.dimensions)
expected = numpy.zeros((100, 100), dtype='uint8')
expected[0][0] = 112
self.assertTrue((result.data == expected).all())
def testFindExtrPoint(self):
from ImageProcessing.FindLocalExtrema import FindLocalExtrema
from pyphant.core.DataContainer import FieldContainer
from pyphant.quantities import Quantity
data = numpy.ones((100, 100), dtype='uint8') * 112
data[10][20] = 255
image = FieldContainer(data)
for dim in image.dimensions:
dim.unit = Quantity('2 mum')
image.seal()
fle = FindLocalExtrema()
fle.paramExcolor.value = 1
result = fle.find(image)
self.assertEqual(result.dimensions, image.dimensions)
expected = numpy.zeros((100, 100), dtype='uint8')
expected[10][20] = 1
self.assertTrue((result.data == expected).all())
