Examples with SimpleFeature net.sf.mzmine.datamodel.impl.SimpleFeature used on opensource projects

Example 16 with SimpleFeature

use of net.sf.mzmine.datamodel.impl.SimpleFeature in project mzmine2 by mzmine.

the class DuplicateFilterTask method copyPeak.

public Feature copyPeak(Feature peak) {
    // Copy the peaks.
    final Feature newPeak = new SimpleFeature(peak);
    PeakUtils.copyPeakProperties(peak, newPeak);
    return newPeak;
}

Example 17 with SimpleFeature

use of net.sf.mzmine.datamodel.impl.SimpleFeature in project mzmine2 by mzmine.

the class LinearNormalizerTask method run.

public void run() {
    setStatus(TaskStatus.PROCESSING);
    logger.info("Running linear normalizer");
    // This hashtable maps rows from original alignment result to rows of
    // the normalized alignment
    Hashtable<PeakListRow, SimplePeakListRow> rowMap = new Hashtable<PeakListRow, SimplePeakListRow>();
    // Create new feature list
    normalizedPeakList = new SimplePeakList(originalPeakList + " " + suffix, originalPeakList.getRawDataFiles());
    // Loop through all raw data files, and find the peak with biggest
    // height
    double maxOriginalHeight = 0.0;
    for (RawDataFile file : originalPeakList.getRawDataFiles()) {
        for (PeakListRow originalpeakListRow : originalPeakList.getRows()) {
            Feature p = originalpeakListRow.getPeak(file);
            if (p != null) {
                if (maxOriginalHeight <= p.getHeight())
                    maxOriginalHeight = p.getHeight();
            }
        }
    }
    // Loop through all raw data files, and normalize peak values
    for (RawDataFile file : originalPeakList.getRawDataFiles()) {
        // Cancel?
        if (isCanceled()) {
            return;
        }
        // Determine normalization type and calculate normalization factor
        double normalizationFactor = 1.0;
        // - normalization by average peak intensity
        if (normalizationType == NormalizationType.AverageIntensity) {
            double intensitySum = 0;
            int intensityCount = 0;
            for (PeakListRow peakListRow : originalPeakList.getRows()) {
                Feature p = peakListRow.getPeak(file);
                if (p != null) {
                    if (peakMeasurementType == PeakMeasurementType.HEIGHT) {
                        intensitySum += p.getHeight();
                    } else {
                        intensitySum += p.getArea();
                    }
                    intensityCount++;
                }
            }
            normalizationFactor = intensitySum / (double) intensityCount;
        }
        // - normalization by average squared peak intensity
        if (normalizationType == NormalizationType.AverageSquaredIntensity) {
            double intensitySum = 0.0;
            int intensityCount = 0;
            for (PeakListRow peakListRow : originalPeakList.getRows()) {
                Feature p = peakListRow.getPeak(file);
                if (p != null) {
                    if (peakMeasurementType == PeakMeasurementType.HEIGHT) {
                        intensitySum += (p.getHeight() * p.getHeight());
                    } else {
                        intensitySum += (p.getArea() * p.getArea());
                    }
                    intensityCount++;
                }
            }
            normalizationFactor = intensitySum / (double) intensityCount;
        }
        // - normalization by maximum peak intensity
        if (normalizationType == NormalizationType.MaximumPeakHeight) {
            double maximumIntensity = 0.0;
            for (PeakListRow peakListRow : originalPeakList.getRows()) {
                Feature p = peakListRow.getPeak(file);
                if (p != null) {
                    if (peakMeasurementType == PeakMeasurementType.HEIGHT) {
                        if (maximumIntensity < p.getHeight())
                            maximumIntensity = p.getHeight();
                    } else {
                        if (maximumIntensity < p.getArea())
                            maximumIntensity = p.getArea();
                    }
                }
            }
            normalizationFactor = maximumIntensity;
        }
        // - normalization by total raw signal
        if (normalizationType == NormalizationType.TotalRawSignal) {
            normalizationFactor = 0;
            for (int scanNumber : file.getScanNumbers(1)) {
                Scan scan = file.getScan(scanNumber);
                normalizationFactor += scan.getTIC();
            }
        }
        // Readjust normalization factor so that maximum height will be
        // equal to maximumOverallPeakHeightAfterNormalization after
        // normalization
        double maxNormalizedHeight = maxOriginalHeight / normalizationFactor;
        normalizationFactor = normalizationFactor * maxNormalizedHeight / maximumOverallPeakHeightAfterNormalization;
        // Normalize all peak intenisities using the normalization factor
        for (PeakListRow originalpeakListRow : originalPeakList.getRows()) {
            // Cancel?
            if (isCanceled()) {
                return;
            }
            Feature originalPeak = originalpeakListRow.getPeak(file);
            if (originalPeak != null) {
                SimpleFeature normalizedPeak = new SimpleFeature(originalPeak);
                PeakUtils.copyPeakProperties(originalPeak, normalizedPeak);
                double normalizedHeight = originalPeak.getHeight() / normalizationFactor;
                double normalizedArea = originalPeak.getArea() / normalizationFactor;
                normalizedPeak.setHeight(normalizedHeight);
                normalizedPeak.setArea(normalizedArea);
                SimplePeakListRow normalizedRow = rowMap.get(originalpeakListRow);
                if (normalizedRow == null) {
                    normalizedRow = new SimplePeakListRow(originalpeakListRow.getID());
                    PeakUtils.copyPeakListRowProperties(originalpeakListRow, normalizedRow);
                    rowMap.put(originalpeakListRow, normalizedRow);
                }
                normalizedRow.addPeak(file, normalizedPeak);
            }
        }
        // Progress
        processedDataFiles++;
    }
    // Finally add all normalized rows to normalized alignment result
    for (PeakListRow originalpeakListRow : originalPeakList.getRows()) {
        SimplePeakListRow normalizedRow = rowMap.get(originalpeakListRow);
        if (normalizedRow == null)
            continue;
        normalizedPeakList.addRow(normalizedRow);
    }
    // Add new peaklist to the project
    project.addPeakList(normalizedPeakList);
    // Load previous applied methods
    for (PeakListAppliedMethod proc : originalPeakList.getAppliedMethods()) {
        normalizedPeakList.addDescriptionOfAppliedTask(proc);
    }
    // Add task description to peakList
    normalizedPeakList.addDescriptionOfAppliedTask(new SimplePeakListAppliedMethod("Linear normalization of by " + normalizationType, parameters));
    // Remove the original peaklist if requested
    if (removeOriginal)
        project.removePeakList(originalPeakList);
    logger.info("Finished linear normalizer");
    setStatus(TaskStatus.FINISHED);
}

Example 18 with SimpleFeature

use of net.sf.mzmine.datamodel.impl.SimpleFeature in project mzmine2 by mzmine.

the class RTCalibrationTask method normalizeRow.

/**
 * Normalize retention time of given row using selected standards
 *
 * @param originalRow Feature list row to be normalized
 * @param standards Standard rows in same feature list
 * @param normalizedStdRTs Normalized retention times of standard rows
 * @return New feature list row with normalized retention time
 */
private PeakListRow normalizeRow(PeakListRow originalRow, PeakListRow[] standards, double[] normalizedStdRTs) {
    PeakListRow normalizedRow = new SimplePeakListRow(originalRow.getID());
    // Standard rows preceding and following this row
    int prevStdIndex = -1, nextStdIndex = -1;
    for (int stdIndex = 0; stdIndex < standards.length; stdIndex++) {
        // If this standard peak is actually originalRow
        if (standards[stdIndex] == originalRow) {
            prevStdIndex = stdIndex;
            nextStdIndex = stdIndex;
            break;
        }
        // If this standard peak is before our originalRow
        if (standards[stdIndex].getAverageRT() < originalRow.getAverageRT()) {
            if ((prevStdIndex == -1) || (standards[stdIndex].getAverageRT() > standards[prevStdIndex].getAverageRT()))
                prevStdIndex = stdIndex;
        }
        // If this standard peak is after our originalRow
        if (standards[stdIndex].getAverageRT() > originalRow.getAverageRT()) {
            if ((nextStdIndex == -1) || (standards[stdIndex].getAverageRT() < standards[nextStdIndex].getAverageRT()))
                nextStdIndex = stdIndex;
        }
    }
    // Calculate normalized retention time of this row
    double normalizedRT = -1;
    if ((prevStdIndex == -1) || (nextStdIndex == -1)) {
        normalizedRT = originalRow.getAverageRT();
    } else if (prevStdIndex == nextStdIndex) {
        normalizedRT = normalizedStdRTs[prevStdIndex];
    } else {
        double weight = (originalRow.getAverageRT() - standards[prevStdIndex].getAverageRT()) / (standards[nextStdIndex].getAverageRT() - standards[prevStdIndex].getAverageRT());
        normalizedRT = normalizedStdRTs[prevStdIndex] + (weight * (normalizedStdRTs[nextStdIndex] - normalizedStdRTs[prevStdIndex]));
    }
    // Set normalized retention time to all peaks in this row
    for (RawDataFile file : originalRow.getRawDataFiles()) {
        Feature originalPeak = originalRow.getPeak(file);
        if (originalPeak != null) {
            SimpleFeature normalizedPeak = new SimpleFeature(originalPeak);
            PeakUtils.copyPeakProperties(originalPeak, normalizedPeak);
            normalizedPeak.setRT(normalizedRT);
            normalizedRow.addPeak(file, normalizedPeak);
        }
    }
    return normalizedRow;
}

Example 19 with SimpleFeature

use of net.sf.mzmine.datamodel.impl.SimpleFeature in project mzmine2 by mzmine.

the class StandardCompoundNormalizerTask method run.

public void run() {
    setStatus(TaskStatus.PROCESSING);
    logger.finest("Starting standard compound normalization of " + originalPeakList + " using " + normalizationType + " (total " + standardRows.length + " standard peaks)");
    // Check if we have standards
    if (standardRows.length == 0) {
        setErrorMessage("No internal standard peaks selected");
        setStatus(TaskStatus.ERROR);
        return;
    }
    // Initialize new alignment result for the normalized result
    normalizedPeakList = new SimplePeakList(originalPeakList + " " + suffix, originalPeakList.getRawDataFiles());
    // Copy raw data files from original alignment result to new alignment
    // result
    totalRows = originalPeakList.getNumberOfRows();
    // Loop through all rows
    rowIteration: for (PeakListRow row : originalPeakList.getRows()) {
        // Cancel ?
        if (isCanceled()) {
            return;
        }
        // Do not add the standard rows to the new peaklist
        for (int i = 0; i < standardRows.length; i++) {
            if (row == standardRows[i]) {
                processedRows++;
                continue rowIteration;
            }
        }
        // Copy comment and identification
        SimplePeakListRow normalizedRow = new SimplePeakListRow(row.getID());
        PeakUtils.copyPeakListRowProperties(row, normalizedRow);
        // Get m/z and RT of the current row
        double mz = row.getAverageMZ();
        double rt = row.getAverageRT();
        // Loop through all raw data files
        for (RawDataFile file : originalPeakList.getRawDataFiles()) {
            double[] normalizationFactors = null;
            double[] normalizationFactorWeights = null;
            if (normalizationType == StandardUsageType.Nearest) {
                // Search for nearest standard
                PeakListRow nearestStandardRow = null;
                double nearestStandardRowDistance = Double.MAX_VALUE;
                for (int standardRowIndex = 0; standardRowIndex < standardRows.length; standardRowIndex++) {
                    PeakListRow standardRow = standardRows[standardRowIndex];
                    double stdMZ = standardRow.getAverageMZ();
                    double stdRT = standardRow.getAverageRT();
                    double distance = MZvsRTBalance * Math.abs(mz - stdMZ) + Math.abs(rt - stdRT);
                    if (distance <= nearestStandardRowDistance) {
                        nearestStandardRow = standardRow;
                        nearestStandardRowDistance = distance;
                    }
                }
                assert nearestStandardRow != null;
                // Calc and store a single normalization factor
                normalizationFactors = new double[1];
                normalizationFactorWeights = new double[1];
                Feature standardPeak = nearestStandardRow.getPeak(file);
                if (standardPeak == null) {
                    // What to do if standard peak is not available?
                    normalizationFactors[0] = 1.0;
                } else {
                    if (peakMeasurementType == PeakMeasurementType.HEIGHT) {
                        normalizationFactors[0] = standardPeak.getHeight();
                    } else {
                        normalizationFactors[0] = standardPeak.getArea();
                    }
                }
                logger.finest("Normalizing row #" + row.getID() + " using standard peak " + standardPeak + ", factor " + normalizationFactors[0]);
                normalizationFactorWeights[0] = 1.0f;
            }
            if (normalizationType == StandardUsageType.Weighted) {
                // Add all standards as factors, and use distance as weight
                normalizationFactors = new double[standardRows.length];
                normalizationFactorWeights = new double[standardRows.length];
                for (int standardRowIndex = 0; standardRowIndex < standardRows.length; standardRowIndex++) {
                    PeakListRow standardRow = standardRows[standardRowIndex];
                    double stdMZ = standardRow.getAverageMZ();
                    double stdRT = standardRow.getAverageRT();
                    double distance = MZvsRTBalance * Math.abs(mz - stdMZ) + Math.abs(rt - stdRT);
                    Feature standardPeak = standardRow.getPeak(file);
                    if (standardPeak == null) {
                        // What to do if standard peak is not available?
                        normalizationFactors[standardRowIndex] = 1.0;
                        normalizationFactorWeights[standardRowIndex] = 0.0;
                    } else {
                        if (peakMeasurementType == PeakMeasurementType.HEIGHT) {
                            normalizationFactors[standardRowIndex] = standardPeak.getHeight();
                        } else {
                            normalizationFactors[standardRowIndex] = standardPeak.getArea();
                        }
                        normalizationFactorWeights[standardRowIndex] = 1 / distance;
                    }
                }
            }
            assert normalizationFactors != null;
            assert normalizationFactorWeights != null;
            // Calculate a single normalization factor as weighted average
            // of all factors
            double weightedSum = 0.0f;
            double sumOfWeights = 0.0f;
            for (int factorIndex = 0; factorIndex < normalizationFactors.length; factorIndex++) {
                weightedSum += normalizationFactors[factorIndex] * normalizationFactorWeights[factorIndex];
                sumOfWeights += normalizationFactorWeights[factorIndex];
            }
            double normalizationFactor = weightedSum / sumOfWeights;
            // For simple scaling of the normalized values
            normalizationFactor = normalizationFactor / 100.0f;
            logger.finest("Normalizing row #" + row.getID() + "[" + file + "] using factor " + normalizationFactor);
            // How to handle zero normalization factor?
            if (normalizationFactor == 0.0)
                normalizationFactor = Double.MIN_VALUE;
            // Normalize peak
            Feature originalPeak = row.getPeak(file);
            if (originalPeak != null) {
                SimpleFeature normalizedPeak = new SimpleFeature(originalPeak);
                PeakUtils.copyPeakProperties(originalPeak, normalizedPeak);
                double normalizedHeight = originalPeak.getHeight() / normalizationFactor;
                double normalizedArea = originalPeak.getArea() / normalizationFactor;
                normalizedPeak.setHeight(normalizedHeight);
                normalizedPeak.setArea(normalizedArea);
                normalizedRow.addPeak(file, normalizedPeak);
            }
        }
        normalizedPeakList.addRow(normalizedRow);
        processedRows++;
    }
    // Add new peaklist to the project
    project.addPeakList(normalizedPeakList);
    // Load previous applied methods
    for (PeakListAppliedMethod proc : originalPeakList.getAppliedMethods()) {
        normalizedPeakList.addDescriptionOfAppliedTask(proc);
    }
    // Add task description to peakList
    normalizedPeakList.addDescriptionOfAppliedTask(new SimplePeakListAppliedMethod("Standard compound normalization", parameters));
    // Remove the original peaklist if requested
    if (removeOriginal)
        project.removePeakList(originalPeakList);
    logger.info("Finished standard compound normalizer");
    setStatus(TaskStatus.FINISHED);
}

Example 20 with SimpleFeature

use of net.sf.mzmine.datamodel.impl.SimpleFeature in project mzmine2 by mzmine.

the class ADAP3DTask method run.

/**
 * @see Runnable#run()
 */
public void run() {
    setStatus(TaskStatus.PROCESSING);
    logger.info("Started ADAP3D on " + dataFile);
    List<Scan> selectedScans = Arrays.asList(scanSelection.getMatchingScans(dataFile));
    // Check if we have any scans
    if (selectedScans.size() == 0) {
        setStatus(TaskStatus.ERROR);
        setErrorMessage("No scans match the selected criteria");
        return;
    }
    // Check if the scans are properly ordered by RT
    double prevRT = Double.NEGATIVE_INFINITY;
    for (Scan s : selectedScans) {
        if (s.getRetentionTime() < prevRT) {
            setStatus(TaskStatus.ERROR);
            final String msg = "Retention time of scan #" + s.getScanNumber() + " is smaller then the retention time of the previous scan." + " Please make sure you only use scans with increasing retention times." + " You can restrict the scan numbers in the parameters, or you can use the Crop filter module";
            setErrorMessage(msg);
            return;
        }
        prevRT = s.getRetentionTime();
    }
    // Run MSDK module
    MZmineToMSDKRawDataFile msdkRawDataFile = new MZmineToMSDKRawDataFile(dataFile);
    Predicate<MsScan> scanSelectionPredicate = scan -> selectedScans.contains(((MZmineToMSDKMsScan) scan).getMzmineScan());
    msdkADAP3DMethod = new ADAP3DFeatureDetectionMethod(msdkRawDataFile, scanSelectionPredicate, new ADAP3DFeatureDetectionParameters());
    List<Feature> features = null;
    try {
        if (isCanceled())
            return;
        features = msdkADAP3DMethod.execute();
        if (isCanceled())
            return;
    } catch (Exception e) {
        e.printStackTrace();
        setStatus(TaskStatus.ERROR);
        setErrorMessage("Error in ADAP3D: " + e.getMessage());
    }
    if (features == null)
        features = new ArrayList<>(0);
    logger.info("ADAP3D detected " + features.size() + " features in " + dataFile + ", converting to MZmine peaklist");
    // Create new MZmine 2 feature list
    SimplePeakList newPeakList = new SimplePeakList(dataFile + " " + suffix, dataFile);
    int rowId = 1;
    for (Feature msdkFeature : features) {
        if (isCanceled())
            return;
        SimpleFeature mzmineFeature = new SimpleFeature(dataFile, FeatureStatus.DETECTED, msdkFeature);
        PeakListRow row = new SimplePeakListRow(rowId);
        row.addPeak(dataFile, mzmineFeature);
        newPeakList.addRow(row);
        rowId++;
    }
    // Add new peaklist to the project
    project.addPeakList(newPeakList);
    // Add quality parameters to peaks
    QualityParameters.calculateQualityParameters(newPeakList);
    setStatus(TaskStatus.FINISHED);
    logger.info("Finished ADAP3D feature detection on " + dataFile);
}