@Override public void loadValueFromXML(Element xmlElement) { PeakList[] currentDataPeakLists = MZmineCore.getProjectManager().getCurrentProject().getPeakLists(); PeakListsSelectionType selectionType; final String attrValue = xmlElement.getAttribute("type"); if (Strings.isNullOrEmpty(attrValue)) selectionType = PeakListsSelectionType.GUI_SELECTED_PEAKLISTS; else selectionType = PeakListsSelectionType.valueOf(xmlElement.getAttribute("type")); ArrayList<Object> newValues = new ArrayList<Object>(); NodeList items = xmlElement.getElementsByTagName("specific_peak_list"); for (int i = 0; i < items.getLength(); i++) { String itemString = items.item(i).getTextContent(); for (PeakList df : currentDataPeakLists) { if (df.getName().equals(itemString)) newValues.add(df); } } PeakList specificPeakLists[] = newValues.toArray(new PeakList[0]); String namePattern = null; items = xmlElement.getElementsByTagName("name_pattern"); for (int i = 0; i < items.getLength(); i++) { namePattern = items.item(i).getTextContent(); } this.value = new PeakListsSelection(); this.value.setSelectionType(selectionType); this.value.setSpecificPeakLists(specificPeakLists); this.value.setNamePattern(namePattern); }
/** Returns a peak list with the peaks which intensity is above the parameter "intensity" */ PeakList getIntensityThresholdPeakList(double intensity) { PeakList selectedPeakList = (PeakList) peakListSelector.getSelectedItem(); if (selectedPeakList == null) return null; SimplePeakList newList = new SimplePeakList(selectedPeakList.getName(), selectedPeakList.getRawDataFiles()); for (PeakListRow peakRow : selectedPeakList.getRows()) { Feature peak = peakRow.getPeak(dataFile); if (peak == null) continue; if (peak.getRawDataPointsIntensityRange().upperEndpoint() > intensity) { newList.addRow(peakRow); } } return newList; }
@Override public void saveValueToXML(Element xmlElement) { if (value == null) return; Document parentDocument = xmlElement.getOwnerDocument(); xmlElement.setAttribute("type", value.getSelectionType().name()); if (value.getSpecificPeakLists() != null) { for (PeakList item : value.getSpecificPeakLists()) { Element newElement = parentDocument.createElement("specific_peak_list"); newElement.setTextContent(item.getName()); xmlElement.appendChild(newElement); } } if (value.getNamePattern() != null) { Element newElement = parentDocument.createElement("name_pattern"); newElement.setTextContent(value.getNamePattern()); xmlElement.appendChild(newElement); } }
/** @see java.awt.event.MouseListener#mouseReleased(java.awt.event.MouseEvent) */ public void mouseReleased(MouseEvent e) { if (columnBeingResized == null) return; ColumnSettingParameter<CommonColumnType> csPar = parameters.getParameter(PeakListTableParameters.commonColumns); ColumnSettingParameter<DataFileColumnType> dfPar = parameters.getParameter(PeakListTableParameters.dataFileColumns); final int modelIndex = columnBeingResized.getModelIndex(); final int newWidth = columnBeingResized.getPreferredWidth(); final int numOfCommonColumns = CommonColumnType.values().length; final int numOfDataFileColumns = DataFileColumnType.values().length; if (modelIndex < numOfCommonColumns) { csPar.setColumnWidth(modelIndex, newWidth); } else { int dataFileColumnIndex = (modelIndex - numOfCommonColumns) % numOfDataFileColumns; dfPar.setColumnWidth(dataFileColumnIndex, newWidth); // set same width to other data file columns of this type for (int dataFileIndex = peakList.getNumberOfRawDataFiles() - 1; dataFileIndex >= 0; dataFileIndex--) { int columnIndex = numOfCommonColumns + (dataFileIndex * numOfDataFileColumns) + dataFileColumnIndex; TableColumn col = this.getColumnByModelIndex(columnIndex); int currentWidth = col.getPreferredWidth(); if (currentWidth != newWidth) { col.setPreferredWidth(newWidth); } } } }
/** Returns a peak list with the top peaks defined by the parameter "threshold" */ PeakList getTopThresholdPeakList(int threshold) { PeakList selectedPeakList = (PeakList) peakListSelector.getSelectedItem(); if (selectedPeakList == null) return null; SimplePeakList newList = new SimplePeakList(selectedPeakList.getName(), selectedPeakList.getRawDataFiles()); Vector<PeakListRow> peakRows = new Vector<PeakListRow>(); Range<Double> mzRange = selectedPeakList.getRowsMZRange(); Range<Double> rtRange = selectedPeakList.getRowsRTRange(); PeakThresholdMode selectedPeakOption = (PeakThresholdMode) thresholdCombo.getSelectedItem(); if (selectedPeakOption == PeakThresholdMode.TOP_PEAKS_AREA) { XYPlot xyPlot = masterFrame.getPlot().getXYPlot(); org.jfree.data.Range yAxis = xyPlot.getRangeAxis().getRange(); org.jfree.data.Range xAxis = xyPlot.getDomainAxis().getRange(); rtRange = Range.closed(xAxis.getLowerBound(), xAxis.getUpperBound()); mzRange = Range.closed(yAxis.getLowerBound(), yAxis.getUpperBound()); } for (PeakListRow peakRow : selectedPeakList.getRows()) { if (mzRange.contains(peakRow.getAverageMZ()) && rtRange.contains(peakRow.getAverageRT())) { peakRows.add(peakRow); } } Collections.sort( peakRows, new PeakListRowSorter(SortingProperty.Intensity, SortingDirection.Descending)); if (threshold > peakRows.size()) threshold = peakRows.size(); for (int i = 0; i < threshold; i++) { newList.addRow(peakRows.elementAt(i)); } return newList; }
/** @see Runnable#run() */ public void run() { if ((mzWeight == 0) && (rtWeight == 0)) { setStatus(TaskStatus.ERROR); errorMessage = "Cannot run alignment, all the weight parameters are zero"; return; } setStatus(TaskStatus.PROCESSING); logger.info("Running join aligner"); // Remember how many rows we need to process. Each row will be processed // twice, first for score calculation, second for actual alignment. for (int i = 0; i < peakLists.length; i++) { totalRows += peakLists[i].getNumberOfRows() * 2; } // Collect all data files Vector<RawDataFile> allDataFiles = new Vector<RawDataFile>(); for (PeakList peakList : peakLists) { for (RawDataFile dataFile : peakList.getRawDataFiles()) { // Each data file can only have one column in aligned peak list if (allDataFiles.contains(dataFile)) { setStatus(TaskStatus.ERROR); errorMessage = "Cannot run alignment, because file " + dataFile + " is present in multiple peak lists"; return; } allDataFiles.add(dataFile); } } // Create a new aligned peak list alignedPeakList = new SimplePeakList(peakListName, allDataFiles.toArray(new RawDataFile[0])); // Iterate source peak lists for (PeakList peakList : peakLists) { // Create a sorted set of scores matching TreeSet<RowVsRowScore> scoreSet = new TreeSet<RowVsRowScore>(); PeakListRow allRows[] = peakList.getRows(); // Calculate scores for all possible alignments of this row for (PeakListRow row : allRows) { if (isCanceled()) return; // Calculate limits for a row with which the row can be aligned Range mzRange = mzTolerance.getToleranceRange(row.getAverageMZ()); Range rtRange = rtTolerance.getToleranceRange(row.getAverageRT()); // Get all rows of the aligned peaklist within parameter limits PeakListRow candidateRows[] = alignedPeakList.getRowsInsideScanAndMZRange(rtRange, mzRange); // Calculate scores and store them for (PeakListRow candidate : candidateRows) { if (sameChargeRequired) { if (!PeakUtils.compareChargeState(row, candidate)) continue; } if (sameIDRequired) { if (!PeakUtils.compareIdentities(row, candidate)) continue; } if (compareIsotopePattern) { IsotopePattern ip1 = row.getBestIsotopePattern(); IsotopePattern ip2 = candidate.getBestIsotopePattern(); if ((ip1 != null) && (ip2 != null)) { ParameterSet isotopeParams = parameters .getParameter(JoinAlignerParameters.compareIsotopePattern) .getEmbeddedParameters(); if (!IsotopePatternScoreCalculator.checkMatch(ip1, ip2, isotopeParams)) { continue; } } } RowVsRowScore score = new RowVsRowScore( row, candidate, mzRange.getSize() / 2, mzWeight, rtRange.getSize() / 2, rtWeight); scoreSet.add(score); } processedRows++; } // Create a table of mappings for best scores Hashtable<PeakListRow, PeakListRow> alignmentMapping = new Hashtable<PeakListRow, PeakListRow>(); // Iterate scores by descending order Iterator<RowVsRowScore> scoreIterator = scoreSet.iterator(); while (scoreIterator.hasNext()) { RowVsRowScore score = scoreIterator.next(); // Check if the row is already mapped if (alignmentMapping.containsKey(score.getPeakListRow())) continue; // Check if the aligned row is already filled if (alignmentMapping.containsValue(score.getAlignedRow())) continue; alignmentMapping.put(score.getPeakListRow(), score.getAlignedRow()); } // Align all rows using mapping for (PeakListRow row : allRows) { PeakListRow targetRow = alignmentMapping.get(row); // If we have no mapping for this row, add a new one if (targetRow == null) { targetRow = new SimplePeakListRow(newRowID); newRowID++; alignedPeakList.addRow(targetRow); } // Add all peaks from the original row to the aligned row for (RawDataFile file : row.getRawDataFiles()) { targetRow.addPeak(file, row.getPeak(file)); } // Add all non-existing identities from the original row to the // aligned row PeakUtils.copyPeakListRowProperties(row, targetRow); processedRows++; } } // Next peak list // Add new aligned peak list to the project MZmineProject currentProject = MZmineCore.getCurrentProject(); currentProject.addPeakList(alignedPeakList); // Add task description to peakList alignedPeakList.addDescriptionOfAppliedTask( new SimplePeakListAppliedMethod("Join aligner", parameters)); logger.info("Finished join aligner"); setStatus(TaskStatus.FINISHED); }
/** * Filter the peak list. * * @param peakList peak list to filter. * @return a new peak list with entries of the original peak list that pass the filtering. */ private PeakList filterPeakList(final PeakList peakList) { // Make a copy of the peakList final PeakList newPeakList = new SimplePeakList( peakList.getName() + ' ' + parameters.getParameter(RowsFilterParameters.SUFFIX).getValue(), peakList.getRawDataFiles()); // Get parameters - which filters are active final boolean filterByDuration = parameters.getParameter(PeakFilterParameters.PEAK_DURATION).getValue(); final boolean filterByArea = parameters.getParameter(PeakFilterParameters.PEAK_AREA).getValue(); final boolean filterByHeight = parameters.getParameter(PeakFilterParameters.PEAK_HEIGHT).getValue(); final boolean filterByDatapoints = parameters.getParameter(PeakFilterParameters.PEAK_DATAPOINTS).getValue(); final boolean filterByFWHM = parameters.getParameter(PeakFilterParameters.PEAK_FWHM).getValue(); final boolean filterByTailingFactor = parameters.getParameter(PeakFilterParameters.PEAK_TAILINGFACTOR).getValue(); final boolean filterByAsymmetryFactor = parameters.getParameter(PeakFilterParameters.PEAK_ASYMMETRYFACTOR).getValue(); // Loop through all rows in peak list final PeakListRow[] rows = peakList.getRows(); totalRows = rows.length; for (processedRows = 0; !isCanceled() && processedRows < totalRows; processedRows++) { final PeakListRow row = rows[processedRows]; final RawDataFile[] rawdatafiles = row.getRawDataFiles(); int totalRawDataFiles = rawdatafiles.length; boolean[] keepPeak = new boolean[totalRawDataFiles]; for (int i = 0; i < totalRawDataFiles; i++) { // Peak values keepPeak[i] = true; final Feature peak = row.getPeak(rawdatafiles[i]); final double peakDuration = peak.getRawDataPointsRTRange().upperEndpoint() - peak.getRawDataPointsRTRange().lowerEndpoint(); final double peakArea = peak.getArea(); final double peakHeight = peak.getHeight(); final int peakDatapoints = peak.getScanNumbers().length; Double peakFWHM = peak.getFWHM(); Double peakTailingFactor = peak.getTailingFactor(); Double peakAsymmetryFactor = peak.getAsymmetryFactor(); if (peakFWHM == null) { peakFWHM = -1.0; } if (peakTailingFactor == null) { peakTailingFactor = -1.0; } if (peakAsymmetryFactor == null) { peakAsymmetryFactor = -1.0; } // Check Duration if (filterByDuration) { final Range<Double> durationRange = parameters .getParameter(PeakFilterParameters.PEAK_DURATION) .getEmbeddedParameter() .getValue(); if (!durationRange.contains(peakDuration)) { // Mark peak to be removed keepPeak[i] = false; } } // Check Area if (filterByArea) { final Range<Double> areaRange = parameters .getParameter(PeakFilterParameters.PEAK_AREA) .getEmbeddedParameter() .getValue(); if (!areaRange.contains(peakArea)) { // Mark peak to be removed keepPeak[i] = false; } } // Check Height if (filterByHeight) { final Range<Double> heightRange = parameters .getParameter(PeakFilterParameters.PEAK_HEIGHT) .getEmbeddedParameter() .getValue(); if (!heightRange.contains(peakHeight)) { // Mark peak to be removed keepPeak[i] = false; } } // Check # Data Points if (filterByDatapoints) { final Range<Integer> datapointsRange = parameters .getParameter(PeakFilterParameters.PEAK_DATAPOINTS) .getEmbeddedParameter() .getValue(); if (!datapointsRange.contains(peakDatapoints)) { // Mark peak to be removed keepPeak[i] = false; } } // Check FWHM if (filterByFWHM) { final Range<Double> fwhmRange = parameters .getParameter(PeakFilterParameters.PEAK_FWHM) .getEmbeddedParameter() .getValue(); if (!fwhmRange.contains(peakFWHM)) { // Mark peak to be removed keepPeak[i] = false; } } // Check Tailing Factor if (filterByTailingFactor) { final Range<Double> tailingRange = parameters .getParameter(PeakFilterParameters.PEAK_TAILINGFACTOR) .getEmbeddedParameter() .getValue(); if (!tailingRange.contains(peakTailingFactor)) { // Mark peak to be removed keepPeak[i] = false; } } // Check height if (filterByAsymmetryFactor) { final Range<Double> asymmetryRange = parameters .getParameter(PeakFilterParameters.PEAK_ASYMMETRYFACTOR) .getEmbeddedParameter() .getValue(); if (!asymmetryRange.contains(peakAsymmetryFactor)) { // Mark peak to be removed keepPeak[i] = false; } } } newPeakList.addRow(copyPeakRow(row, keepPeak)); } return newPeakList; }
public void createColumns() { // clear column groups ColumnGroup groups[] = header.getColumnGroups(); if (groups != null) { for (ColumnGroup group : groups) { header.removeColumnGroup(group); } } // clear the column model while (getColumnCount() > 0) { TableColumn col = getColumn(0); removeColumn(col); } // create the "average" group ColumnGroup averageGroup = new ColumnGroup("Average"); header.addColumnGroup(averageGroup); JTextField editorField = new JTextField(); editorField.setFont(editFont); DefaultCellEditor defaultEditor = new DefaultCellEditor(editorField); ColumnSettingParameter<CommonColumnType> csPar = parameters.getParameter(PeakListTableParameters.commonColumns); CommonColumnType visibleCommonColumns[] = csPar.getValue(); // This is a workaround for a bug - we need to always show the ID, m/z // and RT columns, otherwise manual editing of peak identities does not // work. ArrayList<CommonColumnType> commonColumnsList = new ArrayList<>(Arrays.asList(visibleCommonColumns)); commonColumnsList.remove(CommonColumnType.ROWID); commonColumnsList.remove(CommonColumnType.AVERAGEMZ); commonColumnsList.remove(CommonColumnType.AVERAGERT); commonColumnsList.add(0, CommonColumnType.ROWID); commonColumnsList.add(1, CommonColumnType.AVERAGEMZ); commonColumnsList.add(2, CommonColumnType.AVERAGERT); visibleCommonColumns = commonColumnsList.toArray(visibleCommonColumns); ColumnSettingParameter<DataFileColumnType> dfPar = parameters.getParameter(PeakListTableParameters.dataFileColumns); DataFileColumnType visibleDataFileColumns[] = dfPar.getValue(); for (int i = 0; i < visibleCommonColumns.length; i++) { CommonColumnType commonColumn = visibleCommonColumns[i]; int modelIndex = Arrays.asList(CommonColumnType.values()).indexOf(commonColumn); TableColumn newColumn = new TableColumn(modelIndex); newColumn.setHeaderValue(commonColumn.getColumnName()); newColumn.setIdentifier(commonColumn); switch (commonColumn) { case AVERAGEMZ: newColumn.setCellRenderer(mzRenderer); break; case AVERAGERT: newColumn.setCellRenderer(rtRenderer); break; case IDENTITY: newColumn.setCellRenderer(identityRenderer); break; case COMMENT: newColumn.setCellRenderer(defaultRendererLeft); newColumn.setCellEditor(defaultEditor); break; case PEAKSHAPE: newColumn.setCellRenderer(peakShapeRenderer); break; default: newColumn.setCellRenderer(defaultRenderer); } this.addColumn(newColumn); newColumn.setPreferredWidth(csPar.getColumnWidth(modelIndex)); if ((commonColumn == CommonColumnType.AVERAGEMZ) || (commonColumn == CommonColumnType.AVERAGERT)) { averageGroup.add(newColumn); } } for (int i = 0; i < peakList.getNumberOfRawDataFiles(); i++) { RawDataFile dataFile = peakList.getRawDataFile(i); ColumnGroup fileGroup = new ColumnGroup(dataFile.getName()); header.addColumnGroup(fileGroup); for (int j = 0; j < visibleDataFileColumns.length; j++) { DataFileColumnType dataFileColumn = visibleDataFileColumns[j]; int dataFileColumnIndex = Arrays.asList(DataFileColumnType.values()).indexOf(dataFileColumn); int modelIndex = CommonColumnType.values().length + (i * DataFileColumnType.values().length) + dataFileColumnIndex; TableColumn newColumn = new TableColumn(modelIndex); newColumn.setHeaderValue(dataFileColumn.getColumnName()); newColumn.setIdentifier(dataFileColumn); switch (dataFileColumn) { case MZ: newColumn.setCellRenderer(mzRenderer); break; case PEAKSHAPE: newColumn.setCellRenderer(peakShapeRenderer); break; case STATUS: newColumn.setCellRenderer(peakStatusRenderer); break; case RT: newColumn.setCellRenderer(rtRenderer); break; case RT_START: newColumn.setCellRenderer(rtRenderer); break; case RT_END: newColumn.setCellRenderer(rtRenderer); break; case DURATION: newColumn.setCellRenderer(rtRenderer); break; case HEIGHT: newColumn.setCellRenderer(intensityRenderer); break; case AREA: newColumn.setCellRenderer(intensityRenderer); break; default: newColumn.setCellRenderer(defaultRenderer); break; } this.addColumn(newColumn); newColumn.setPreferredWidth(dfPar.getColumnWidth(dataFileColumnIndex)); fileGroup.add(newColumn); } } }