def test_linspace(self):
v = values_to_linspace(np.array([1, 2, 3]))
np.testing.assert_equal(np.linspace(*v), [1, 2, 3])
v = values_to_linspace(np.array([1, 2, 3, np.nan]))
np.testing.assert_equal(np.linspace(*v), [1, 2, 3])
v = values_to_linspace(np.array([1]))
np.testing.assert_equal(np.linspace(*v), [1])
v = values_to_linspace(np.array([1.001, 2, 3.002]))
np.testing.assert_equal(np.linspace(*v), [1.001, 2.0015, 3.002])
def test_linspace(self):
v = values_to_linspace(np.array([1, 2, 3]))
np.testing.assert_equal(np.linspace(*v), [1, 2, 3])
v = values_to_linspace(np.array([1, 2, 3, float("nan")]))
np.testing.assert_equal(np.linspace(*v), [1, 2, 3])
v = values_to_linspace(np.array([1]))
np.testing.assert_equal(np.linspace(*v), [1])
v = values_to_linspace(np.array([1.001, 2, 3.002]))
np.testing.assert_equal(np.linspace(*v), [1.001, 2.0015, 3.002])
def test_index(self):
a = np.array([1, 2, 3])
v = values_to_linspace(a)
iv = index_values(a, v)
np.testing.assert_equal(iv, [0, 1, 2])
a = np.array([1, 2, 3, 4])
v = values_to_linspace(a)
iv = index_values(a, v)
np.testing.assert_equal(iv, [0, 1, 2, 3])
a = np.array([1, 2, 3, 6, 5])
v = values_to_linspace(a)
iv = index_values(a, v)
np.testing.assert_equal(iv, [0, 1, 2, 5, 4])
def test_index(self):
a = np.array([1, 2, 3])
v = values_to_linspace(a)
iv = index_values(a, v)
np.testing.assert_equal(iv, [0, 1, 2])
a = np.array([1, 2, 3, 4])
v = values_to_linspace(a)
iv = index_values(a, v)
np.testing.assert_equal(iv, [0, 1, 2, 3])
a = np.array([1, 2, 3, 6, 5])
v = values_to_linspace(a)
iv = index_values(a, v)
np.testing.assert_equal(iv, [0, 1, 2, 5, 4])
def select_2coordinates(self, attr_x, attr_y):
xat = self.data.domain[attr_x]
yat = self.data.domain[attr_y]
def extract_col(data, var):
nd = Orange.data.Domain([var])
d = self.data.transform(nd)
return d.X[:, 0]
coorx = extract_col(self.data, xat)
coory = extract_col(self.data, yat)
lsx = values_to_linspace(coorx)
lsy = values_to_linspace(coory)
xindex, xnan = index_values_nan(coorx, lsx)
yindex, ynan = index_values_nan(coory, lsy)
# trick:
# https://stackoverflow.com/questions/31878240/numpy-average-of-values-corresponding-to-unique-coordinate-positions
coo = np.hstack([xindex.reshape(-1, 1), yindex.reshape(-1, 1)])
sortidx = np.lexsort(coo.T)
sorted_coo = coo[sortidx]
unqID_mask = np.append(True, np.any(np.diff(sorted_coo, axis=0),
axis=1))
ID = unqID_mask.cumsum() - 1
unq_coo = sorted_coo[unqID_mask]
unique, counts = np.unique(ID, return_counts=True)
pos = 0
bins = []
for size in counts:
bins.append(sortidx[pos:pos + size])
pos += size
matrix = []
for indices in bins:
selection = self.data.X[indices]
array = self.calc_table_np(selection)
matrix.append(array)
table_2_coord = Orange.data.Table.concatenate(matrix, axis=0)
with table_2_coord.unlocked():
table_2_coord[:, attr_x] = np.linspace(*lsx)[unq_coo[:,
0]].reshape(
-1, 1)
table_2_coord[:, attr_y] = np.linspace(*lsy)[unq_coo[:,
1]].reshape(
-1, 1)
return table_2_coord
def compute_image(data: Orange.data.Table, attr_x, attr_y, image_values,
image_values_fixed_levels, state: TaskState):
def progress_interrupt(i: float):
if state.is_interruption_requested():
raise InterruptException
class Result():
pass
res = Result()
xat = data.domain[attr_x]
yat = data.domain[attr_y]
def extract_col(data, var):
nd = Domain([var])
d = data.transform(nd)
return d.X[:, 0]
progress_interrupt(0)
res.coorx = extract_col(data, xat)
res.coory = extract_col(data, yat)
res.data_points = np.hstack(
[res.coorx.reshape(-1, 1),
res.coory.reshape(-1, 1)])
res.lsx = lsx = values_to_linspace(res.coorx)
res.lsy = lsy = values_to_linspace(res.coory)
res.image_values_fixed_levels = image_values_fixed_levels
progress_interrupt(0)
if lsx[-1] * lsy[-1] > IMAGE_TOO_BIG:
raise ImageTooBigException((lsx[-1], lsy[-1]))
# the code below does this, but part-wise:
# d = image_values(data).X[:, 0]
parts = []
for slice in split_to_size(len(data), 10000):
part = image_values(data[slice]).X[:, 0]
parts.append(part)
progress_interrupt(0)
d = np.concatenate(parts)
res.d = d
progress_interrupt(0)
return res
def update_view(self):
self.img.clear()
self.img.setSelection(None)
self.lsx = None
self.lsy = None
self.wavenumbers = None
self.data_xs = None
self.data_imagepixels = None
if self.data and len(self.data.domain.attributes):
if self.attr_x is not None:
xat = self.data.domain[self.attr_x]
ndom = Domain([xat])
datam = Table(ndom, self.data)
coorx = datam.X[:, 0]
else:
coorx = np.arange(len(self.data))
self.lsx = lsx = values_to_linspace(coorx)
self.data_xs = coorx
self.wavenumbers = wavenumbers = getx(self.data)
self.lsy = lsy = values_to_linspace(wavenumbers)
# set data
imdata = np.ones((lsy[2], lsx[2])) * float("nan")
xindex = index_values(coorx, lsx)
yindex = index_values(wavenumbers, lsy)
for xind, d in zip(xindex, self.data.X):
imdata[yindex, xind] = d
self.data_imagepixels = xindex
self.img.setImage(imdata, autoLevels=False)
self.img.setLevels([0, 1])
self.update_levels()
self.update_color_schema()
# shift centres of the pixels so that the axes are useful
shiftx = _shift(lsx)
shifty = _shift(lsy)
left = lsx[0] - shiftx
bottom = lsy[0] - shifty
width = (lsx[1]-lsx[0]) + 2*shiftx
height = (lsy[1]-lsy[0]) + 2*shifty
self.img.setRect(QRectF(left, bottom, width, height))
self.refresh_img_selection()
def update_view(self):
self.img.clear()
self.img.setSelection(None)
self.legend.set_colors(None)
self.lsx = None
self.lsy = None
self.wavenumbers = None
self.data_xs = None
self.data_imagepixels = None
if self.data and len(self.data.domain.attributes):
if self.attr_x is not None:
xat = self.data.domain[self.attr_x]
ndom = Domain([xat])
datam = self.data.transform(ndom)
coorx = datam.X[:, 0]
else:
coorx = np.arange(len(self.data))
self.lsx = lsx = values_to_linspace(coorx)
self.data_xs = coorx
self.wavenumbers = wavenumbers = getx(self.data)
self.lsy = lsy = values_to_linspace(wavenumbers)
# set data
imdata = np.ones((lsy[2], lsx[2])) * float("nan")
xindex = index_values(coorx, lsx)
yindex = index_values(wavenumbers, lsy)
for xind, d in zip(xindex, self.data.X):
imdata[yindex, xind] = d
self.data_imagepixels = xindex
self.img.setImage(imdata, autoLevels=False)
self.update_levels()
self.update_color_schema()
# shift centres of the pixels so that the axes are useful
shiftx = _shift(lsx)
shifty = _shift(lsy)
left = lsx[0] - shiftx
bottom = lsy[0] - shifty
width = (lsx[1] - lsx[0]) + 2 * shiftx
height = (lsy[1] - lsy[0]) + 2 * shifty
self.img.setRect(QRectF(left, bottom, width, height))
self.refresh_img_selection()
def compute_image(data: Orange.data.Table, attr_x, attr_y,
integrate_fn, state: TaskState):
def progress_interrupt(i: float):
if state.is_interruption_requested():
raise InterruptException
class Result():
pass
res = Result()
xat = data.domain[attr_x]
yat = data.domain[attr_y]
ndom = Domain([xat, yat])
datam = data.transform(ndom)
progress_interrupt(0)
res.coorx = datam.X[:, 0]
res.coory = datam.X[:, 1]
res.data_points = datam.X
res.lsx = lsx = values_to_linspace(res.coorx)
res.lsy = lsy = values_to_linspace(res.coory)
progress_interrupt(0)
if lsx[-1] * lsy[-1] > IMAGE_TOO_BIG:
raise ImageTooBigException((lsx[-1], lsy[-1]))
# the code bellow does this, but part-wise:
# d = integrate_fn(data).X[:, 0]
parts = []
for slice in split_to_size(len(data), 10000):
part = integrate_fn(data[slice]).X[:, 0]
parts.append(part)
progress_interrupt(0)
d = np.concatenate(parts)
res.d = d
progress_interrupt(0)
return res
def select_1coordinate(self, attr):
at = self.data.domain[attr]
def extract_col(data, var):
nd = Orange.data.Domain([var])
d = self.data.transform(nd)
return d.X[:, 0]
coor = extract_col(self.data, at)
ls = values_to_linspace(coor)
index, _ = index_values_nan(coor, ls)
coo = np.hstack([index.reshape(-1, 1)])
sortidx = np.lexsort(coo.T)
sorted_coo = coo[sortidx]
unqID_mask = np.append(True, np.any(np.diff(sorted_coo, axis=0),
axis=1))
ID = unqID_mask.cumsum() - 1
unq_coo = sorted_coo[unqID_mask]
unique, counts = np.unique(ID, return_counts=True)
pos = 0
bins = []
for size in counts:
bins.append(sortidx[pos:pos + size])
pos += size
matrix = []
for indices in bins:
selection = self.data.X[indices]
array = self.calc_table_np(selection)
matrix.append(array)
table_1_coord = Orange.data.Table.concatenate(matrix, axis=0)
with table_1_coord.unlocked():
table_1_coord[:,
attr] = np.linspace(*ls)[unq_coo[:,
0]].reshape(-1, 1)
return table_1_coord
def test_location(self):
lsc = values_to_linspace(np.array([1, 1, 1])) # a constant
lv = location_values([0, 1, 2], lsc)
np.testing.assert_equal(lv, [-1, 0, 1])
def test_index_nan(self):
a = np.array([1, 2, 3, np.nan])
v = values_to_linspace(a)
iv, nans = index_values_nan(a, v)
np.testing.assert_equal(iv[:-1], [0, 1, 2])
np.testing.assert_equal(nans, [0, 0, 0, 1])
def update_view(self):
self.parent.Error.image_too_big.clear()
self.parent.Information.not_shown.clear()
self.img.clear()
self.img.setSelection(None)
self.legend.set_colors(None)
self.lsx = None
self.lsy = None
self.data_points = None
self.data_values = None
self.data_imagepixels = None
self.data_valid_positions = None
if self.data and self.attr_x and self.attr_y:
xat = self.data.domain[self.attr_x]
yat = self.data.domain[self.attr_y]
ndom = Orange.data.Domain([xat, yat])
datam = Orange.data.Table(ndom, self.data)
coorx = datam.X[:, 0]
coory = datam.X[:, 1]
self.data_points = datam.X
self.lsx = lsx = values_to_linspace(coorx)
self.lsy = lsy = values_to_linspace(coory)
if lsx[-1] * lsy[-1] > IMAGE_TOO_BIG:
self.parent.Error.image_too_big(lsx[-1], lsy[-1])
return
di = {}
if self.parent.value_type == 0: # integrals
imethod = self.parent.integration_methods[
self.parent.integration_method]
if imethod != Integrate.PeakAt:
datai = Integrate(
methods=imethod,
limits=[[self.parent.lowlim,
self.parent.highlim]])(self.data)
else:
datai = Integrate(
methods=imethod,
limits=[[self.parent.choose,
self.parent.choose]])(self.data)
if np.any(self.parent.curveplot.selection_group):
# curveplot can have a subset of curves on the input> match IDs
ind = np.flatnonzero(
self.parent.curveplot.selection_group)[0]
dind = self.data_ids[self.parent.curveplot.data[ind].id]
di = datai.domain.attributes[0].compute_value.draw_info(
self.data[dind:dind + 1])
d = datai.X[:, 0]
else:
dat = self.data.domain[self.parent.attr_value]
ndom = Orange.data.Domain([dat])
d = Orange.data.Table(ndom, self.data).X[:, 0]
self.refresh_markings(di)
xindex, xnan = index_values_nan(coorx, lsx)
yindex, ynan = index_values_nan(coory, lsy)
self.data_valid_positions = valid = np.logical_not(
np.logical_or(xnan, ynan))
invalid_positions = len(d) - np.sum(valid)
if invalid_positions:
self.parent.Information.not_shown(invalid_positions)
imdata = np.ones((lsy[2], lsx[2])) * float("nan")
imdata[yindex[valid], xindex[valid]] = d[valid]
self.data_values = d
self.data_imagepixels = np.vstack((yindex, xindex)).T
self.img.setImage(imdata, autoLevels=False)
self.update_levels()
self.update_color_schema()
# shift centres of the pixels so that the axes are useful
shiftx = _shift(lsx)
shifty = _shift(lsy)
left = lsx[0] - shiftx
bottom = lsy[0] - shifty
width = (lsx[1] - lsx[0]) + 2 * shiftx
height = (lsy[1] - lsy[0]) + 2 * shifty
self.img.setRect(QRectF(left, bottom, width, height))
self.refresh_img_selection()
def update_view(self):
self.img.clear()
self.img.setSelection(None)
self.lsx = None
self.lsy = None
self.data_points = None
self.data_values = None
self.data_imagepixels = None
if self.data and self.attr_x and self.attr_y:
xat = self.data.domain[self.attr_x]
yat = self.data.domain[self.attr_y]
ndom = Orange.data.Domain([xat, yat])
datam = Orange.data.Table(ndom, self.data)
coorx = datam.X[:, 0]
coory = datam.X[:, 1]
self.data_points = datam.X
self.lsx = lsx = values_to_linspace(coorx)
self.lsy = lsy = values_to_linspace(coory)
if lsx[-1] * lsy[-1] > IMAGE_TOO_BIG:
self.parent.Error.image_too_big(lsx[-1], lsy[-1])
return
else:
self.parent.Error.image_too_big.clear()
di = {}
if self.parent.value_type == 0: # integrals
imethod = self.parent.integration_methods[self.parent.integration_method]
if imethod != Integrate.PeakAt:
datai = Integrate(methods=imethod,
limits=[[self.parent.lowlim, self.parent.highlim]])(self.data)
else:
datai = Integrate(methods=imethod,
limits=[[self.parent.choose, self.parent.choose]])(self.data)
if np.any(self.parent.curveplot.selection_group):
# curveplot can have a subset of curves on the input> match IDs
ind = np.flatnonzero(self.parent.curveplot.selection_group)[0]
dind = self.data_ids[self.parent.curveplot.data[ind].id]
di = datai.domain.attributes[0].compute_value.draw_info(self.data[dind:dind+1])
d = datai.X[:, 0]
else:
dat = self.data.domain[self.parent.attr_value]
ndom = Orange.data.Domain([dat])
d = Orange.data.Table(ndom, self.data).X[:, 0]
self.refresh_markings(di)
# set data
imdata = np.ones((lsy[2], lsx[2])) * float("nan")
xindex = index_values(coorx, lsx)
yindex = index_values(coory, lsy)
imdata[yindex, xindex] = d
self.data_values = d
self.data_imagepixels = np.vstack((yindex, xindex)).T
self.img.setImage(imdata, autoLevels=False)
self.img.setLevels([0, 1])
self.update_levels()
self.update_color_schema()
# shift centres of the pixels so that the axes are useful
shiftx = _shift(lsx)
shifty = _shift(lsy)
left = lsx[0] - shiftx
bottom = lsy[0] - shifty
width = (lsx[1]-lsx[0]) + 2*shiftx
height = (lsy[1]-lsy[0]) + 2*shifty
self.img.setRect(QRectF(left, bottom, width, height))
self.refresh_img_selection()
def test_location(self):
lsc = values_to_linspace(np.array([1, 1, 1])) # a constant
lv = location_values([0, 1, 2], lsc)
np.testing.assert_equal(lv, [-1, 0, 1])
