def on_popup_five(self, event=None): """ Spawns a dialog for the first selected item to select the color. Redraws the list control with the new colors and then triggers an EVT_DELETE_SELECTION_2. :param event: Unused Event :return: None """ # Change Color item = self.list_ctrl.GetFirstSelected() col = self.list_ctrl.GetItemBackgroundColour(item) print("Color In:", col) col = wx.Colour(int(col[0]), int(col[1]), int(col[2]), alpha=int(col.alpha)) col2 = wx.ColourData() col2.SetColour(col) colout = col2 dlg = wx.ColourDialog(None, data=col2) if dlg.ShowModal() == wx.ID_OK: coloutdlg = dlg.GetColourData() colout = deepcopy(coloutdlg.GetColour()) print("Color Out", colout) dlg.Destroy() else: dlg.Destroy() return topcolor = ([colout[0] / 255., colout[1] / 255., colout[2] / 255.]) self.list_ctrl.SetItemBackgroundColour(item, col=colout) luminance = ud.get_luminance(wx.Colour(colout), type=2) #print(wx.Colour(colout), luminance) if luminance < luminance_cutoff: self.list_ctrl.SetItemTextColour(item, col=white_text) else: self.list_ctrl.SetItemTextColour(item, col=black_text) peak = tofloat(self.list_ctrl.GetItem(item, col=1).GetText()) i = ud.nearest(self.pks.masses, peak) self.pks.peaks[i].color = topcolor num = self.list_ctrl.GetSelectedItemCount() for i in range(1, num): item = self.list_ctrl.GetNextSelected(item) self.list_ctrl.SetItemBackgroundColour(item, col=colout) if luminance < luminance_cutoff: self.list_ctrl.SetItemTextColour(item, col=white_text) else: self.list_ctrl.SetItemTextColour(item, col=black_text) peak = tofloat(self.list_ctrl.GetItem(item, col=1).GetText()) i = ud.nearest(self.pks.masses, peak) self.pks.peaks[i].color = topcolor newevent = wx.PyCommandEvent(self.EVT_DELETE_SELECTION_2._getEvtType(), self.GetId()) self.GetEventHandler().ProcessEvent(newevent)
def on_selection(self, min, max): minscan = ud.nearest(self.eng.ticdat[:, 0], min) if self.eng.ticdat[minscan, 0] < min: minscan += 1 maxscan = ud.nearest(self.eng.ticdat[:, 0], max) if self.eng.ticdat[maxscan, 0] > max: maxscan -= 1 if maxscan <= minscan: maxscan = minscan + 1 self.scans = [minscan, maxscan, min, max] self.get_scan_data()
def createcompareplot(self): xvals = self.plot2.zoom.comparexvals yvals = self.plot2.zoom.compareyvals data2d = win_fft_grid(self.rawdata, self.binsize, self.wbin, self.window_fwhm, self.diffrange) for x in range(0, len(xvals) // 2): if xvals[x * 2] > xvals[x * 2 + 1]: xvals[x * 2], xvals[x * 2 + 1] = xvals[x * 2 + 1], xvals[x * 2] if yvals[x * 2] > yvals[x * 2 + 1]: yvals[x * 2], yvals[x * 2 + 1] = yvals[x * 2 + 1], yvals[x * 2] # assure that x and y values are not equal if xvals[x * 2] == xvals[x * 2 + 1] or yvals[x * 2] == yvals[x * 2 + 1]: self.comparetext.SetLabel("Line or point drawn, please try again.") return 0 # Round to nearest value, find index for that value nearestxvalind = [] for val in xvals: roundedval = self.wbin * round(val / self.wbin) nearestxvalind.append(nearest(data2d[:, 0], roundedval)) nearestyvalind = [] indexdiff = ((self.diffrange[1] - self.diffrange[0]) / self.binsize) - 1 for val in yvals: roundedval = self.binsize * round(val / self.binsize) nearestyvalind.append(nearest(data2d[0:int(indexdiff), 1], roundedval)) # Sum up the rows in each box boxsums = [] rowdiffs = [] maxsum = 0 for x in range(0, len(xvals) // 2): rowsums = [] tmpdiff = [] for row in range(nearestyvalind[x * 2], nearestyvalind[x * 2 + 1]): sum = 0 for col in range(nearestxvalind[x * 2], nearestxvalind[x * 2 + 1], int(indexdiff)): sum += data2d[int(col + row), 2] rowsums.append(sum) tmpdiff.append(self.diffrange[0] + self.binsize + (self.binsize * row)) if sum > maxsum: maxsum = sum boxsums.append(rowsums) rowdiffs.append(tmpdiff) colormap = cm.get_cmap('rainbow', len(xvals) / 2) cols = colormap(np.arange(len(xvals) / 2)) tmp = [y / maxsum for y in boxsums[0]] self.on_get_peaks(data=np.transpose([rowdiffs[0],tmp])) self.plot4.plotrefreshtop(rowdiffs[0], tmp, color=cols[0], xlabel="Mass Difference", ylabel="Intensity", linestyle="solid") for x in range(1, len(xvals) // 2): tmp = [y / maxsum for y in boxsums[x]] self.on_get_peaks(data=np.transpose([rowdiffs[x], tmp])) self.plot4.plotadd(rowdiffs[x], tmp, cols[x], None) self.plot4.repaint() return 1
def peaks_error_FWHM(self, pks, data): """ Calculates the error of each peak in pks using FWHM. Looks for the left and right point of the peak that is 1/2 the peaks max intensity, rightmass - leftmass = error :param pks: :param data: self.data.massdat :return: """ pmax = np.amax([p.height for p in pks.peaks]) datamax = np.amax(np.asarray(data)[:, 1]) div = datamax / pmax for pk in pks.peaks: int = pk.height index = ud.nearest(data[:, 0], pk.mass) leftwidth = 0 rightwidth = 0 counter = 1 leftfound = False rightfound = False while rightfound is False and leftfound is False: if leftfound is False: if data[index - counter, 1] <= (int * div) / 2: leftfound = True else: leftwidth += 1 if rightfound is False: if data[index + counter, 1] <= (int * div) / 2: rightfound = True else: rightwidth += 1 counter += 1 pk.errorFWHM = data[index + rightwidth, 0] - data[index - leftwidth, 0]
def linearize_2d(xvals, yvals, igrid, binsize): """ Linearize the x-axis of a 2D grid :param xvals: 2D numpy array (x values) :param yvals: 2D numpy array (y values) :param igrid: 2D numpy array (intensity values) :param binsize: difference between consecutive linear x points :return: x, y, and z grid linearized along the x-axis """ firstpoint = math.ceil(xvals[0] / binsize) * binsize lastpoint = math.floor(xvals[len(xvals) - 1] / binsize) * binsize intx = np.arange(firstpoint, lastpoint, binsize) iout = np.zeros((len(intx), len(yvals))) shape = igrid.shape for i in xrange(0, shape[0]): if intx[0] < xvals[i] < intx[len(intx) - 1]: index = ud.nearest(intx, xvals[i]) # iout[index]+=C[i] if intx[index] == xvals[i]: iout[index] += igrid[i] if intx[index] < xvals[i] and index < shape[0] - 1: index2 = index + 1 interpos = ud.linear_interpolation(intx[index], intx[index2], xvals[i]) iout[index] += (1 - interpos) * igrid[i] iout[index2] += interpos * igrid[i] if intx[index] > xvals[i] and index > 0: index2 = index - 1 interpos = ud.linear_interpolation(intx[index], intx[index2], xvals[i]) iout[index] += (1 - interpos) * igrid[i] iout[index2] += interpos * igrid[i] xout, yout = np.meshgrid(intx, yvals, indexing='ij') return xout, yout, iout
def add_peaks_mass(self, e=None): for p in self.pks.peaks: if p.ignore == 0: pos = ud.nearest(self.datalist[self.pos][:, 0], p.mass) data = self.datalist[self.pos][pos] if data[1] > self.config.peakplotthresh * np.amax( self.datalist[self.pos][:, 1]): self.plot.plotadddot(data[0], data[1], p.color, p.marker) self.plot.repaint()
def peaks_error_replicates(self, pks, spectra, config): peakvals = [] for x in range(0, len(pks.peaks)): peakvals.append([]) for i, pk in enumerate(pks.peaks): ints = [] for spec in spectra: index = ud.nearest(spec.massdat[:, 0], pk.mass) startindmass = ud.nearest(spec.massdat[:, 0], spec.massdat[index, 0] - config.peakwindow) endindmass = ud.nearest(spec.massdat[:, 0], spec.massdat[index, 0] + config.peakwindow) maxind = index for x in range(startindmass, endindmass + 1): if spec.massdat[x, 1] > spec.massdat[maxind, 1]: maxind = x peakvals[i].append(spec.massdat[maxind, 0]) ints.append(spec.massdat[maxind, 1]) print peakvals[i], ints pk.errorreplicate = ud.weighted_std(peakvals[i], ints)
def on_popup_nine(self, e=None): item = self.list_ctrl.GetFirstSelected() peak = float(self.list_ctrl.GetItem(item, col=1).GetText()) i = ud.nearest(self.pks.masses, peak) dlg = SelectMarker(self) dlg.initialize_interface(self.pks, i) self.list_ctrl.SetItem(i, 0, self.pks.peaks[i].textmarker) newevent = wx.PyCommandEvent(self.EVT_DELETE_SELECTION_2._getEvtType(), self.GetId()) self.GetEventHandler().ProcessEvent(newevent)
def on_get_peaks(self, e=None, data=None): if data is None: data=self.diffdat print("Data range", np.amin(data[:,0]), "to", np.amax(data[:,0])) peaks = peakdetect(data, window=1000.)[:, 0] for p in peaks: index = nearest(data[:, 0], p) idiff = int(3 / self.binsize) print("Peak value:", p) fit, fitdat = fitting.isolated_peak_fit(data[index - idiff:index + idiff, 0], data[index - idiff:index + idiff, 1], psfun=0) print("Peak Fit:", fit[1, 0], "+/-", fit[1, 1])
def on_fit(self, e): peaks = ud.peakdetect(self.data1d, window=3) print("Peaks:", peaks[:, 0]) peaks = np.concatenate((peaks, [[0, np.amin(self.data1d[:, 1])]])) fitdat, fits = MassFitter(self.data1d, peaks, 3, "microguess").perform_fit() print("Fits:", fits[:, 0]) self.plot3.plotadd(self.data1d[:, 0], fitdat, "green", nopaint=False) for f in fits[:, 0]: if np.amin(self.data1d[:, 0]) <= f <= np.amax(self.data1d[:, 0]): y = np.amax(self.data1d[ud.nearest(self.data1d[:, 0], f), 1]) self.plot3.addtext(str(np.round(f, 3)), f + 0.075, y * 0.95, vlines=False) self.plot3.addtext("", f, y, vlines=True)
def get_data_from_times(self, min, max): minscan = ud.nearest(self.ticdat[:, 0], min) if self.ticdat[minscan, 0] < min: minscan += 1 maxscan = ud.nearest(self.ticdat[:, 0], max) if self.ticdat[maxscan, 0] > max: maxscan -= 1 if maxscan <= minscan: maxscan = minscan + 1 self.scans = [minscan, maxscan, min, max] attrs = { "timestart": min, "timeend": max, "timemid": (min + max) / 2., "scanstart": minscan, "scanend": maxscan, "scanmid": (minscan + maxscan) / 2. } self.attrs = attrs self.get_data_from_scans([minscan, maxscan]) return self.mzdata
def get_chrom_peaks(self, window=None): # Cleanup TIC Data ticdat = deepcopy(self.ticdat) ticdat = ud.gsmooth(ticdat, 2) ticdat[:, 1] -= np.amin(ticdat[:, 1]) # ticdat = ud.gaussian_backgroud_subtract(ticdat, 100) maxval = np.amax(ticdat[:, 1]) ticdat[:, 1] /= maxval maxt = np.amax(ticdat[:, 0]) mint = np.amin(ticdat[:, 0]) # Set Window if window is None: window = self.config.chrom_peak_width # Set Threshold noise = ud.noise_level2(ticdat, percent=0.50) print("Noise Level:", noise, "Window:", window) # Detect Peaks peaks = ud.peakdetect_nonlinear(ticdat, window=window, threshold=noise) # Filter Peaks goodpeaks = [] tranges = [] diffs = np.diff(ticdat[:, 0]) for p in peaks: fwhm, range = ud.calc_FWHM(p[0], ticdat) index = ud.nearest(ticdat[:, 0], p[0]) if index >= len(diffs): index = len(diffs) - 1 localdiff = diffs[index] if p[0] - fwhm / 2. < mint or p[ 0] + fwhm / 2. > maxt or fwhm > 4 * window or fwhm < localdiff * 2 or range[ 0] == p[0] or range[1] == p[0]: print("Bad Peak", p, fwhm, range) pass else: print(p[0], fwhm) goodpeaks.append(p) tranges.append(range) self.chrompeaks = goodpeaks self.chrompeaks_tranges = tranges return goodpeaks, tranges
def get_maxima(self): """ Detect peaks in self.offset_totals (the total extracted intensitites) and set default parameters. Plot the results. :return: None """ defaultcolors = [[255, 0, 0, 255], [0, 0, 255, 255], [0, 255, 0, 255], [255, 0, 255, 255]] defaultmarkers = ['o', 'v', '^', '>', 's', 'd', '*'] peaks = ud.peakdetect(self.offset_totals, window=2, threshold=0.1) print(peaks) self.zoffs = [] for p in peaks: i = ud.nearest(self.offset_totals[:, 0], p[0]) zoff = Zoffset() zoff.make(p[0], p[1], i, defaultcolors[len(self.zoffs) % len(defaultcolors)], defaultmarkers[len(self.zoffs)]) self.zoffs.append(zoff) self.plot_zoffs()
def on_com(self, e=None): print("Starting COM calculations") dims = self.data2d.shape x = np.unique(self.data2d[:, 0]) y = np.unique(self.data2d[:, 1]) xl = len(x) yl = len(y) z = self.data2d[:, 2].reshape((xl, yl)) zlin = np.array([np.max(d) for d in z]) self.on_label_peaks(e=0) coms = [] for d in z.transpose(): data = np.transpose([x, d]) b1 = d > np.amax(d) * 0.1 com, std = ud.center_of_mass(data[b1]) coms.append(com) for p in self.peaks: index = ud.nearest(y, p[0]) c = coms[index] carray = [c] try: carray.append(coms[index - 1]) except: pass try: carray.append(coms[index + 1]) except: pass com = np.average(carray) print(p[0], com) self.plot1.plotrefreshtop(y, coms, xlabel="Mass Defect", ylabel="Center of Mass (Da)")
def peak_extract(self): """ Extract the values for local max (height) and area for peaks in pks from each zoff.extract. Plot the results. Write the results to files. :return: None """ # TODO: Add extra peaks here to compensate for shifts in the peaks. peakextracts = np.zeros((len(self.zoffs), self.pks.plen)) peakextractsarea = np.zeros((len(self.zoffs), self.pks.plen)) try: xvals = self.pks.masses except AttributeError: print("No Peaks to Extract") return None if xvals is not None: # Extraction for i, z in enumerate(self.zoffs): for j, p in enumerate(self.pks.peaks): x = z.extract[:, 0] y = z.extract[:, 1] index = ud.nearest(x, p.mass) peakextracts[i, j] = ud.localmax2( y, index, int(self.config.peakwindow / self.config.massbins)) if not ud.isempty(p.integralrange): integral, intdat = ud.integrate( z.extract, p.integralrange[0], p.integralrange[1]) peakextractsarea[i, j] = integral # Switch to subunit numbers if self.massoffset > 0: xvals = np.round(np.array(xvals) / self.massoffset) label = "Subunit Number" else: label = "Mass (Da)" # Plots # Create height extraction line plot sum1 = np.sum(peakextracts, axis=0) smax1 = np.amax(sum1) if np.amax(sum1) != 0: sum1 /= smax1 self.plot3.plotrefreshtop(xvals, sum1, title="Extracted Heights", xlabel=label, ylabel="Intensity", integerticks=True, test_kda=True) for i, z in enumerate(self.zoffs): self.plot3.plotadd(xvals, peakextracts[i] / smax1, np.array(z.color) / 255., str(i)) self.plot3.repaint() # Create height extraction bar chart xvals2 = np.arange(0, len(sum1)) colormap = cm.get_cmap(self.config.peakcmap, len(xvals)) peakcolors = colormap(np.arange(len(xvals))) self.plot5.barplottop(xvals2, sum1, [int(i) for i in xvals], peakcolors, label, "Normalized Intensity", "Extracted Total Peak Heights") # Make Plots for Integrals sum2 = np.sum(peakextractsarea, axis=0) smax2 = np.amax(sum2) if np.amax(sum2) != 0: sum2 /= smax2 # Make line plots self.plot4.plotrefreshtop(xvals, sum2, title="Extracted Areas", xlabel=label, ylabel="Area", integerticks=True, test_kda=True) for i, z in enumerate(self.zoffs): self.plot4.plotadd(xvals, peakextractsarea[i] / smax2, np.array(z.color) / 255., str(i)) self.plot4.repaint() # Make bar charts self.plot6.barplottop(xvals2, sum2, [int(i) for i in xvals], peakcolors, label, "Normalized Intensity", "Extracted Total Peak Areas") else: print("No integration provided") # Save total outputs for extracted peaks try: np.savetxt(self.config.outfname + "_extracted_heights.txt", peakextracts) np.savetxt( self.config.outfname + "_total_extracted_heights.txt", np.transpose([self.pks.masses, xvals, sum1])) if np.amax(sum2) != 0: np.savetxt(self.config.outfname + "_extracted_areas.txt", peakextractsarea) np.savetxt( self.config.outfname + "_total_extracted_areas.txt", np.transpose([self.pks.masses, xvals, sum2])) except Exception as e: print("Error saving files", e)