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 process_stack(data, xat, yat, upsample_factor=100, use_sobel=False, ref_frame_num=0):
hypercube, lsx, lsy = get_hypercube(data, xat, yat)
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 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 test_image_computation(self):
spectra = [[[0, 0, 2, 0],
[0, 0, 1, 0]],
[[1, 2, 2, 0],
[0, 1, 1, 0]]]
wns = [0, 1, 2, 3]
x_locs = [0, 1]
y_locs = [0, 1]
data = build_spec_table(*_spectra_from_image(spectra, wns, x_locs, y_locs))
def last_called_array(m):
arrays = [a[0][0] for a in m.call_args_list
if a and a[0] and isinstance(a[0][0], np.ndarray)]
return arrays[-1]
wrap = self.widget.imageplot.img
# integrals from zero; default
self.send_signal("Data", data)
with patch.object(wrap, 'setImage', wraps=wrap.setImage) as m:
wait_for_image(self.widget)
called = last_called_array(m)
target = [[2, 1], [4.5, 2]]
np.testing.assert_equal(called.squeeze(), target)
# peak from zero
self.widget.integration_method = \
self.widget.integration_methods.index(IntegrateFeaturePeakSimple)
self.widget._change_integral_type()
with patch.object(wrap, 'setImage', wraps=wrap.setImage) as m:
wait_for_image(self.widget)
called = last_called_array(m)
target = [[2, 1], [2, 1]]
np.testing.assert_equal(called.squeeze(), target)
# single wavenumber (feature)
self.widget.controls.value_type.buttons[1].click()
self.widget.attr_value = data.domain.attributes[1]
self.widget.update_feature_value()
with patch.object(wrap, 'setImage', wraps=wrap.setImage) as m:
wait_for_image(self.widget)
called = last_called_array(m)
target = [[0, 0], [2, 1]]
np.testing.assert_equal(called.squeeze(), target)
# RGB
self.widget.controls.value_type.buttons[2].click()
self.widget.rgb_red_value = data.domain.attributes[0]
self.widget.rgb_green_value = data.domain.attributes[1]
self.widget.rgb_blue_value = data.domain.attributes[2]
self.widget.update_rgb_value()
with patch.object(wrap, 'setImage', wraps=wrap.setImage) as m:
wait_for_image(self.widget)
called = last_called_array(m)
# first three wavenumbers (features) should be passed to setImage
target = [data.X[0, :3], data.X[1, :3]], [data.X[2, :3], data.X[3, :3]]
np.testing.assert_equal(called, target)
def process_stack(data,
xat,
yat,
upsample_factor=100,
use_sobel=False,
ref_frame_num=0):
ndom = Domain([xat, yat])
datam = Table(ndom, data)
coorx = datam.X[:, 0]
coory = datam.X[:, 1]
lsx = values_to_linspace(coorx)
lsy = values_to_linspace(coory)
lsz = data.X.shape[1]
if lsx is None:
raise InvalidAxisException("x")
if lsy is None:
raise InvalidAxisException("y")
# set data
hypercube = np.ones((lsy[2], lsx[2], lsz)) * np.nan
xindex = index_values(coorx, lsx)
yindex = index_values(coory, lsy)
hypercube[yindex, xindex] = data.X
if np.any(np.isnan(hypercube)):
raise NanInsideHypercube(np.sum(np.isnan(hypercube)))
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 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 = Orange.data.Table(ndom, d)
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_tile(self):
ret_table = None
am = agilentMosaicTiles(self.filename)
info = am.info
tiles = am.tiles
ytiles = am.tiles.shape[0]
xtiles = am.tiles.shape[1]
try:
features = info['wavenumbers']
except KeyError:
#just start counting from 0 when nothing is known
features = np.arange(X.shape[-1])
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