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