def actionRestore(self): """Restore dataset translated by values""" for uc, d in self.trcum.iteritems(): obj = self.document.resolveFullWidgetPath(uc) logging.debug('restoring curve', uc, d, obj) yds_name = obj.settings.yData yds = self.document.data[yds_name] new = yds.data + d # Create a copy of the dataset ydsn = copy.copy(yds) # Change copy's values ydsn.data = new # Set original dataset to copied one op = document.OperationDatasetSet(yds_name, ydsn) self.ops.append(op) logging.debug('axmap', self.axmap) for uc, (newax, oldax, (minVal, maxVal)) in self.axmap.iteritems(): obj = self.document.resolveFullWidgetPath(uc) self.toset(obj, 'yAxis', oldax) ox = self.parent.getChild(oldax) self.toset(ox, 'min', minVal) self.toset(ox, 'max', minVal) if newax != oldax: n = self.parent.getChild(newax) op = document.OperationWidgetDelete(n) self.ops.append(op) self.trcum = {} self.axmap = {} self.apply_ops('SynAxis: Restore')
def add_datasets(self, start_index, start_value): """Add standard and fitted datasets for further evaluations (plotting, etc)""" # Adding plot data fields = self.fld name = fields['std'].replace(' ', '_') p = fields['d'] + '/' + name Tds = self.doc.data[fields['T']] T = Tds.data old_unit = getattr(self.ds, 'old_unit', 'percent') # Fitting # f=np.poly1d((self.slope,0)) f = np.poly1d((self.quad, self.slope, 0)) df = f(T) df += start_value - df[start_index] # TODO: define new derived datasets for these dsf = copy(Tds) dsf.attr = dict({}, **Tds.attr) dsf.tags = set([]) dsf.data = plugins.numpyCopyOrNone(df) dsf.m_var = name + '_fit' dsf.m_pos = 2 dsf.m_name = dsf.m_var dsf.m_col = dsf.m_var dsf.old_unit = old_unit dsf.unit = 'percent' dsf.m_initialDimension = self.inidim dsf.m_label = _('Calibration Fitting') self.ops.append(document.OperationDatasetSet(p + '_fit', dsf)) # Evaluate std fit over regular T d = self.f(T) # Translate zero so it matches the fit d -= d[start_index] - df[start_index] dsd = copy(Tds) dsd.attr = dict({}, **Tds.attr) dsd.tags = set([]) dsd.data = plugins.numpyCopyOrNone(d) dsd.m_var = name dsd.m_pos = 1 dsd.m_name = name dsd.m_col = name dsd.unit = 'percent' dsd.old_unit = old_unit dsd.m_initialDimension = self.inidim dsd.m_label = _(name) self.ops.append(document.OperationDatasetSet(p, dsd))
def translate_values(self, dataset, dataset_name, delta, doc): translated_data = dataset.data - delta translated_dataset = copy.copy(dataset) translated_dataset.data = translated_data op = document.OperationDatasetSet(dataset_name, translated_dataset) self.ops.append(op) self.apply_ops() return True
def newDataset(self, ds): """Add new dataset to document.""" # get a name for dataset name = _('new dataset') if name in self.document.data: count = 1 while name in self.document.data: name = _('new dataset %i') % count count += 1 # add new dataset self.document.applyOperation(document.OperationDatasetSet(name, ds)) self.dsbrowser.selectDataset(name)
def removeGaps(self): gap_range = self.settings.setdict['remove_gaps_range'].val gaps_thershold = self.settings.setdict['remove_gaps_thershold'].val start_index = int(round(self.point_index - gap_range / 2.0)) end_index = start_index + gap_range data = self.parent.settings.get('yData').getFloatArray(self.document) dataset_name = self.parent.settings.get('yData').val dataset = copy(self.document.data[dataset_name]) data_without_gap = remove_gaps_from(data, gaps_thershold, start_index, end_index) dataset.data = data_without_gap operation = document.OperationDatasetSet(dataset_name, dataset) self.ops.append(operation) self.up_coord(yData=data_without_gap) self.apply_ops('Remove Gap')
def new_dataset_operation(original_dataset, data, name, label, path, unit='volt', opt=False, error=None): """Create a new dataset by copying `original_dataset` and overwriting with `data`. Returns an operation to be executed by the document.""" old_unit = unit if opt: if unit is False: unit = opt.get('csunit', False) old_unit = opt.get('unit', unit) old_unit = getattr(original_dataset, 'old_unit', old_unit) if not opt: opt = original_dataset.m_opt new_dataset = copy(original_dataset) new_dataset.attr = dict({}, **original_dataset.attr) new_dataset.tags = set([]) new_dataset.data = plugins.numpyCopyOrNone(data) new_dataset.m_opt = opt new_dataset.m_var = name new_dataset.m_pos = 2 new_dataset.m_col = new_dataset.m_var new_dataset.old_unit = old_unit new_dataset.unit = unit new_dataset.m_label = _(label) prefix = original_dataset.linked.prefix if not path.startswith(prefix): path = prefix + path.lstrip('/') new_dataset.m_name = path if error is not None: new_dataset.serr = error return document.OperationDatasetSet(path, new_dataset)
def apply(self, interface, fields): """Do the work of the plugin. interface: veusz command line interface object (exporting commands) fields: dict mapping field names to values """ self.ops = [] self.doc = interface.document # raise DatasetPluginException if there are errors ds = interface.document.data.get(fields['ds'], False) if not ds: raise plugins.DatasetPluginException('Dataset not found' + fields['ds']) if isinstance(ds, document.datasets.Dataset1DPlugin): logging.error( 'Cannot convert to percent a derived dataset. Please convert the source.' ) return False action = units.percent_action(ds, fields['action']) ds1 = units.percent_conversion(ds, action, fields['auto']) ds = ds1 self.ops.append(document.OperationDatasetSet(fields['ds'], ds)) #self.ops.append(document.OperationDatasetSetVal(fields['ds'], 'data',slice(None,None),ds1.data[:])) self.apply_ops() logging.debug('Converted %s %s using initial dimension %.2f.' % (fields['ds'], fields['action'], ds.m_initialDimension)) # QtGui.QMessageBox.information(None,'Percentage output', # 'Converted %s %s using initial dimension %.2f.' % (fields['ds'], msg, ds.m_initialDimension)) # updating all dependent datapoints convert_func = units.percent_func(ds, action, fields['auto']) utils.convert_datapoint_units(convert_func, fields['ds'], self.doc) if not fields['propagate']: return # Find all datasets plotted with the same Y axis cvt = [] tree = get_plotted_tree(self.doc.basewidget) upax = [] for axp, dslist in tree['axis'].iteritems(): if not fields['ds'] in dslist: continue logging.debug('Propagating to', cvt) cvt += dslist upax.append(axp) cvt = list(set(cvt)) if fields['ds'] in cvt: cvt.remove(fields['ds']) act = 'To Percent' if ds.m_percent else 'To Absolute' # Create a non-propagating percentage operation for each dataset found for nds in cvt: ncur = getattr(self.doc.data[nds], 'm_percent', None) if ncur == ds.m_percent: continue logging.debug('Really propagating percentage to', nds) fields = { 'ds': nds, 'propagate': False, 'action': act, 'auto': True } self.ops.append( document.OperationToolsPlugin(PercentPlugin(), fields)) # Update axis labels old = units.symbols.get(ds.old_unit, False) new = units.symbols.get(ds.unit, False) if old and new: for ax in upax: ax = self.doc.resolveFullWidgetPath(ax) lbl = ax.settings.label.replace(old, new) self.toset(ax, 'label', lbl) # Apply everything self.apply_ops('Percentage: Propagate')
def actionUp(self): logging.debug('SYNC LINE UP') self.ops = [] doc = self.document ref = None # Reference curve is the first child xref = [] yref = [] # Fractional position on x axis apos = self.settings.otherPosition # Translation mode trmode = self.settings.trans # Maximum translations up_ext = 0 down_ext = 0 axmap = {} objmap = {} # Search for all curves in parent graph for i in range(self.ncurves): u = 'curve' + str(i) uc = getattr(self.settings, u) obj = self.parent.getChild(uc) if obj is None: if i == 0: logging.debug('No reference curve defined') return break xax = self.parent.getChild(obj.settings.xAxis) # Get the y axis yax = self.parent.getChild(obj.settings.yAxis) if None in [xax, yax]: continue # Obtain real position relative to xax pos = apos * \ (xax.plottedrange[1] - xax.plottedrange[0]) + \ xax.plottedrange[0] # Set reference values if ref is None: ref = obj xref = doc.data[ref.settings.xData].data yref = doc.data[ref.settings.yData].data yaxref = yax # Reference ranges ymin_ref, ymax_ref = yaxref.plottedrange # Search the nearest X value on ref X-array dst = np.abs(xref - pos) i = np.where(dst == dst.min())[0][0] # Get the corresponding Y value on the ref Y-array yval_ref = yref[i] axmap[yax.name] = obj objmap[obj] = (yax, 0) continue # Getting curve data xtr = doc.data[obj.settings.xData].data yds_name = obj.settings.yData yds = doc.data[yds_name] ytr = yds.data # Search the nearest X value on trans X-array dst = np.abs(xtr - pos) i = np.where(dst == dst.min())[0][0] # Delta d = ytr[i] - yval_ref objmap[obj] = (yax, d) # Create axes - only for axis translation if trmode == 'Values': new = yds.data - d # Create a copy of the dataset ydsn = copy.copy(yds) # Change copy's values ydsn.data = new # Set original dataset to copied one op = document.OperationDatasetSet(yds_name, ydsn) self.ops.append(op) # Remember translation if not self.trcum.has_key(obj.path): self.trcum[obj.path] = 0 self.trcum[obj.path] += d continue # Remember for future translation if ytr.min() < ymin_ref: ymin_ref = ytr.min() if ytr.max() > ymax_ref: ymax_ref = ytr.max() # Each Y axis MUST be unique. # Create new one if current obj happens to share its axis with a # previous one if axmap.has_key(yax.name): axname = 'ax_%s_%s' % (obj.name, self.name) axset = { 'name': axname, 'direction': 'vertical', 'label': 'Trans:' + yax.settings.label, 'hide': False } # will be True! don't want to see all that axes self.ops.append( document.OperationWidgetAdd(self.parent, 'axis', **axset)) self.toset(obj, 'yAxis', axname) axmap[axname] = obj self.axmap[obj.path] = (axname, yax.name, (yax.settings.min, yax.settings.max)) # else: # self.axmap[obj.path]=(yax.name,yax.name,(yax.settings.min,yax.settings.max)) if trmode == 'Values': # Remove dissociated objects ucs = set([obj.path for obj in objmap.keys()]) for uc in set(self.trcum.keys()) - ucs: del self.trcum[uc] self.apply_ops('SynAxis: Translation') return # Remove unused restore info ucs = set([obj.path for obj in objmap.keys()]) for uc in set(self.axmap.keys()) - ucs: del self.axmap[uc] self.trcum = {} # Apply axis creation self.apply_ops('SynAxis: Create') # Extend axes and apply translations self.toset(yaxref, 'max', float(ymax_ref)) self.toset(yaxref, 'min', float(ymin_ref)) for obj, (yax, d) in objmap.iteritems(): self.toset(yax, 'max', float(ymax_ref + d)) self.toset(yax, 'min', float(ymin_ref + d)) self.apply_ops('SynAxis: Update')
def apply(self, interface, fields): """Do the work of the plugin. interface: veusz command line interface object (exporting commands) fields: dict mapping field names to values """ self.ops = [] self.doc = interface.document # raise DatasetPluginException if there are errors ds = self.doc.data.get(fields['ds'], False) if not ds: raise plugins.DatasetPluginException('Dataset not found' + fields['ds']) out = numpy.array(ds.data) # If data was converted to percentage, convert back to real numbers percent = getattr(ds, 'm_percent', False) if percent: out = out * ds.m_initialDimension / 100. # Calculate automatic initial value ini = fields['ini'] n = fields['num'] start = fields['start'] if fields['auto']: if n > len(out) / 2: raise plugins.DatasetPluginException( 'Too many points used for calculation: %i/%i' % (n, len(out))) x = interface.document.data.get(fields['ds_x'], False) if x is not False: x = numpy.array(x.data) i = 0 # Cut from start T if start != -1 and x is not False: diff = abs(x - start) i = numpy.where(diff == min(diff))[0][0] x = x[i:] ini = out[i:i + n] if fields['method'] == 'mean': ini = ini.mean() elif fields['method'] == 'linear-regression': if x is False: raise plugins.DatasetPluginException('Dataset not found' + fields['ds_x']) (slope, const) = scipy.polyfit(x[:n], ini, 1) ini = x[0] * slope + const # Convert back to percent if needed ds1 = copy(ds) if percent: out = 100. * out / ini ds1.data = plugins.numpyCopyOrNone(out) orig = getattr(ds, 'm_initialDimension', False) if orig and orig != ini and not fields['suppress_messageboxes']: repl = QtGui.QMessageBox.warning( None, 'Initial dimension', 'Changing initial dimension from %.2f to %.2f. Confirm?' % (orig, ini), QtGui.QMessageBox.Ok | QtGui.QMessageBox.Cancel, defaultButton=QtGui.QMessageBox.Ok) if repl != QtGui.QMessageBox.Ok: QtGui.QMessageBox.information(None, 'Initial dimension', 'Change cancelled') return ds1.m_initialDimension = ini self.ops.append(document.OperationDatasetSet(fields['ds'], ds1)) self.apply_ops() if not fields['suppress_messageboxes']: QtGui.QMessageBox.information( None, 'Initial dimension output', 'Initial dimension configured to %.2f' % ini)
def apply(self, interface, fields): """Do the work of the plugin. interface: veusz command line interface object (exporting commands) fields: dict mapping field names to values """ self.ops = [] self.doc = interface.document ds = interface.document.data.get(fields['ds'], False) if not ds: raise plugins.DatasetPluginException('Dataset not found' + fields['ds']) ds1 = units.convert(ds, fields['convert']) self.ops.append(document.OperationDatasetSet(fields['ds'], ds1)) self.apply_ops() # Update DataPoints convert_func = units.convert_func(ds, fields['convert']) utils.convert_datapoint_units(convert_func, fields['ds'], self.doc) # Update file-wise time unit if ds is the time dataset if ds.linked and fields['ds'] == ds.linked.prefix + 't': ds.linked.params.time_unit = ds1.unit #### # PROPAGATION if not fields['propagate']: return # Find all datasets plotted with the same Y axis cvt = [] tree = get_plotted_tree(self.doc.basewidget) upax = [] for axp, dslist in tree['axis'].iteritems(): if not fields['ds'] in dslist: continue logging.debug('Propagating to', cvt) cvt += dslist upax.append(axp) # If time dataset, propagate to all time datasets if ds.m_var == 't': for k, nds in self.doc.data.iteritems(): if k == fields['ds']: continue if getattr(nds, 'm_var', False) != 't': continue cvt.append(k) cvt = list(set(cvt)) # Create a non-propagating unit conversion operation for each dataset # found for nds in cvt: if nds == fields['ds']: continue ncur = getattr(self.doc.data[nds], 'unit', False) if not ncur: continue logging.debug('Really propagating unit conversion to', nds) fields = { 'ds': nds, 'propagate': False, 'convert': fields['convert'] } self.ops.append( document.OperationToolsPlugin(UnitsConverterTool(), fields)) # Update axis labels old = units.symbols.get(ds.unit, False) new = units.symbols.get(fields['convert'], False) if old and new: for ax in upax: ax = self.doc.resolveFullWidgetPath(ax) lbl = ax.settings.label.replace(old, new) self.toset(ax, 'label', lbl) # Apply everything self.apply_ops('UnitsConverterTool: Propagate')