Example usage for com.google.common.collect Range contains

List of usage examples for com.google.common.collect Range contains

Introduction

In this page you can find the example usage for com.google.common.collect Range contains.

Prototype

public boolean contains(C value) 

Source Link

Document

Returns true if value is within the bounds of this range.

Usage

From source file:net.sf.mzmine.modules.peaklistmethods.filtering.rowsfilter.RowsFilterTask.java

/**
 * Filter the peak list rows.//www  .  j  a v a 2  s.  com
 *
 * @param peakList
 *            peak list to filter.
 * @return a new peak list with rows of the original peak list that pass the
 *         filtering.
 */
private PeakList filterPeakListRows(final PeakList peakList) {

    // Create new peak list.
    final PeakList newPeakList = new SimplePeakList(
            peakList.getName() + ' ' + parameters.getParameter(RowsFilterParameters.SUFFIX).getValue(),
            peakList.getRawDataFiles());

    // Copy previous applied methods.
    for (final PeakListAppliedMethod method : peakList.getAppliedMethods()) {

        newPeakList.addDescriptionOfAppliedTask(method);
    }

    // Add task description to peakList.
    newPeakList.addDescriptionOfAppliedTask(new SimplePeakListAppliedMethod(getTaskDescription(), parameters));

    // Get parameters.
    final boolean onlyIdentified = parameters.getParameter(RowsFilterParameters.HAS_IDENTITIES).getValue();
    final boolean filterByIdentityText = parameters.getParameter(RowsFilterParameters.IDENTITY_TEXT).getValue();
    final boolean filterByCommentText = parameters.getParameter(RowsFilterParameters.COMMENT_TEXT).getValue();
    final String groupingParameter = (String) parameters.getParameter(RowsFilterParameters.GROUPSPARAMETER)
            .getValue();
    final boolean filterByMinPeakCount = parameters.getParameter(RowsFilterParameters.MIN_PEAK_COUNT)
            .getValue();
    final boolean filterByMinIsotopePatternSize = parameters
            .getParameter(RowsFilterParameters.MIN_ISOTOPE_PATTERN_COUNT).getValue();
    final boolean filterByMzRange = parameters.getParameter(RowsFilterParameters.MZ_RANGE).getValue();
    final boolean filterByRtRange = parameters.getParameter(RowsFilterParameters.RT_RANGE).getValue();
    final boolean filterByDuration = parameters.getParameter(RowsFilterParameters.PEAK_DURATION).getValue();

    // Filter rows.
    final PeakListRow[] rows = peakList.getRows();
    totalRows = rows.length;
    for (processedRows = 0; !isCanceled() && processedRows < totalRows; processedRows++) {

        final PeakListRow row = rows[processedRows];

        final int peakCount = getPeakCount(row, groupingParameter);

        // Check number of peaks.
        if (filterByMinPeakCount) {
            final int minPeakCount = parameters.getParameter(RowsFilterParameters.MIN_PEAK_COUNT)
                    .getEmbeddedParameter().getValue();
            if (peakCount < minPeakCount)
                continue;
        }

        // Check identities.
        if (onlyIdentified && row.getPreferredPeakIdentity() == null)
            continue;

        // Check average m/z.
        if (filterByMzRange) {
            final Range<Double> mzRange = parameters.getParameter(RowsFilterParameters.MZ_RANGE)
                    .getEmbeddedParameter().getValue();
            if (!mzRange.contains(row.getAverageMZ()))
                continue;
        }

        // Check average RT.
        if (filterByRtRange) {
            final Range<Double> rtRange = parameters.getParameter(RowsFilterParameters.RT_RANGE)
                    .getEmbeddedParameter().getValue();

            if (!rtRange.contains(row.getAverageRT()))
                continue;
        }

        // Search peak identity text.
        if (filterByIdentityText) {
            if (row.getPreferredPeakIdentity() == null)
                continue;
            final String searchText = parameters.getParameter(RowsFilterParameters.IDENTITY_TEXT)
                    .getEmbeddedParameter().getValue().toLowerCase().trim();
            final String rowText = row.getPreferredPeakIdentity().getName().toLowerCase().trim();
            if (!rowText.contains(searchText))
                continue;
        }

        // Search peak comment text.
        if (filterByCommentText) {
            if (row.getComment() == null)
                continue;
            final String searchText = parameters.getParameter(RowsFilterParameters.COMMENT_TEXT)
                    .getEmbeddedParameter().getValue().toLowerCase().trim();
            final String rowText = row.getComment().toLowerCase().trim();
            if (!rowText.contains(searchText))
                continue;
        }

        // Calculate average duration and isotope pattern count.
        int maxIsotopePatternSizeOnRow = 1;
        double avgDuration = 0.0;
        final Feature[] peaks = row.getPeaks();
        for (final Feature p : peaks) {

            final IsotopePattern pattern = p.getIsotopePattern();
            if (pattern != null && maxIsotopePatternSizeOnRow < pattern.getNumberOfDataPoints()) {

                maxIsotopePatternSizeOnRow = pattern.getNumberOfDataPoints();
            }

            avgDuration += RangeUtils.rangeLength(p.getRawDataPointsRTRange());
        }

        // Check isotope pattern count.
        if (filterByMinIsotopePatternSize) {
            final int minIsotopePatternSize = parameters
                    .getParameter(RowsFilterParameters.MIN_ISOTOPE_PATTERN_COUNT).getEmbeddedParameter()
                    .getValue();
            if (maxIsotopePatternSizeOnRow < minIsotopePatternSize)
                continue;
        }

        // Check average duration.
        avgDuration /= (double) peakCount;
        if (filterByDuration) {
            final Range<Double> durationRange = parameters.getParameter(RowsFilterParameters.PEAK_DURATION)
                    .getEmbeddedParameter().getValue();
            if (!durationRange.contains(avgDuration))
                continue;
        }

        // Good row?
        newPeakList.addRow(copyPeakRow(row));
    }

    return newPeakList;
}

From source file:io.github.msdk.features.filtering.FeatureFilterMethod.java

/**
 * Helper function to check if a specific double value from a sample is
 * within a given range.//from   w w w. j av  a2s. co  m
 */
private boolean checkDoubleValue(Range<Double> range, ColumnName columnName, Sample sample,
        FeatureTableRow row) {

    FeatureTableColumn<Double> column = featureTable.getColumn(columnName, sample);
    if (column != null) {
        if (row.getData(column) != null) {
            final Double value = (Double) row.getData(column);
            if (!range.contains(value))
                return false;
        }
    }

    return true;
}

From source file:io.github.msdk.featdet.targeteddetection.BuildingChromatogram.java

/**
 * <p>//www  .j  a  va  2 s.c  o m
 * cropChromatogram.
 * </p>
 *
 * @param rtRange
 *            a {@link com.google.common.collect.Range} object.
 * @param intensityTolerance
 *            a {@link java.lang.Double} object.
 * @param noiseLevel
 *            a {@link java.lang.Double} object.
 */
public void cropChromatogram(Range<Double> rtRange, Double intensityTolerance, Double noiseLevel) {

    // Find peak apex (= most intense data point which fulfill the criteria)
    Integer apexDataPoint = null;
    for (int i = 0; i < size; i++) {
        Float currentIntensity = intensityValues[i];
        Double currentRt = (double) rtValues[i].getRetentionTime();

        // Verify data point
        if ((apexDataPoint == null || currentIntensity > intensityValues[apexDataPoint])
                && rtRange.contains(currentRt) && currentIntensity > noiseLevel) {
            apexDataPoint = i;
        }
    }

    if (apexDataPoint != null) {
        Integer startIndex = apexDataPoint, endIndex = apexDataPoint;

        // Find start data point
        for (int i = apexDataPoint - 1; i >= 0; i--) {

            // Verify the intensity is within the intensity tolerance
            if (intensityValues[i] > intensityValues[i + 1] * (1 + intensityTolerance)
                    || intensityValues[i + 1] == 0) {
                break;
            }
            startIndex = i;
        }

        // Find end data point
        for (int i = apexDataPoint + 1; i < size; i++) {

            // Verify the intensity is within the intensity tolerance
            if (intensityValues[i] > intensityValues[i - 1] * (1 + intensityTolerance)
                    || intensityValues[i - 1] == 0) {
                break;
            }
            endIndex = i;
        }

        // Shift the peakPoints
        int peakPoints = endIndex - startIndex + 1;
        System.arraycopy(rtValues, startIndex, rtValues, 0, peakPoints);
        System.arraycopy(mzValues, startIndex, mzValues, 0, peakPoints);
        System.arraycopy(intensityValues, startIndex, intensityValues, 0, peakPoints);
        size = peakPoints;

    }

}

From source file:com.github.drbookings.ui.controller.EarningsViewController.java

private void doChart() {
    if (manager != null) {
        int numMonthBack = (int) slider.getValue();
        monthCount.setText(Integer.toString(numMonthBack));
        Range<YearMonth> monthRange = Range.closed(YearMonth.from(LocalDate.now().minusMonths(numMonthBack)),
                YearMonth.from(LocalDate.now().minusMonths(1)));
        if (logger.isDebugEnabled()) {
            logger.debug("Month range: " + monthRange);
        }/* w  w  w  .j  a  va2  s  .co  m*/
        doChart(manager.getBookingEntries().stream().filter(e -> e.getElement().getDateOfPayment() != null)
                .filter(e -> monthRange.contains(YearMonth.from(e.getElement().getDateOfPayment())))
                .collect(Collectors.toList()));
    } else {
        if (logger.isDebugEnabled()) {
            logger.debug("Manager null");
        }
    }
}

From source file:net.sf.mzmine.modules.peaklistmethods.peakpicking.deconvolution.savitzkygolay.SavitzkyGolayPeakDetector.java

@Override
public Feature[] resolvePeaks(final Feature chromatogram, final int[] scanNumbers,
        final double[] retentionTimes, final double[] intensities, ParameterSet parameters,
        RSessionWrapper rSession) {//from   ww w.j  a v  a  2 s  .c  o  m

    // Calculate intensity statistics.
    double maxIntensity = 0.0;
    double avgIntensity = 0.0;
    for (final double intensity : intensities) {

        maxIntensity = Math.max(intensity, maxIntensity);
        avgIntensity += intensity;
    }

    avgIntensity /= (double) scanNumbers.length;

    final List<Feature> resolvedPeaks = new ArrayList<Feature>(2);

    // If the current chromatogram has characteristics of background or just
    // noise return an empty array.
    if (avgIntensity <= maxIntensity / 2.0) {

        // Calculate second derivatives of intensity values.
        final double[] secondDerivative = SGDerivative.calculateDerivative(intensities, false, SG_FILTER_LEVEL);

        // Calculate noise threshold.
        final double noiseThreshold = calcDerivativeThreshold(secondDerivative,
                parameters.getParameter(DERIVATIVE_THRESHOLD_LEVEL).getValue());

        // Search for peaks.
        Arrays.sort(scanNumbers);
        final Feature[] resolvedOriginalPeaks = peaksSearch(chromatogram, scanNumbers, secondDerivative,
                noiseThreshold);

        final Range<Double> peakDuration = parameters.getParameter(PEAK_DURATION).getValue();
        final double minimumPeakHeight = parameters.getParameter(MIN_PEAK_HEIGHT).getValue();

        // Apply final filter of detected peaks, according with setup
        // parameters.
        for (final Feature p : resolvedOriginalPeaks) {

            if (peakDuration.contains(RangeUtils.rangeLength(p.getRawDataPointsRTRange()))
                    && p.getHeight() >= minimumPeakHeight) {

                resolvedPeaks.add(p);
            }
        }
    }

    return resolvedPeaks.toArray(new Feature[resolvedPeaks.size()]);
}

From source file:io.github.msdk.features.filtering.FeatureFilterMethod.java

/**
 * Helper function to check if a specific float value from a sample is
 * within a given range.//from w ww.j a v a  2s  . com
 */
private boolean checkFloatValue(Range<Double> range, ColumnName columnName, Sample sample,
        FeatureTableRow row) {

    FeatureTableColumn<Float> column = featureTable.getColumn(columnName, sample);
    if (column != null) {
        if (row.getData(column) != null) {
            final Float value = (Float) row.getData(column);
            final Double doubleValue = (double) value;
            if (!range.contains(doubleValue))
                return false;
        }
    }

    return true;
}

From source file:org.eclipse.fx.ui.controls.styledtext.skin.StyledTextSkin.java

public void scrollOffsetIntoView(int offset, int verticalOffset, int horizontalOffset) {
    if (offset >= 0) {
        int lineIdx = getSkinnable().getContent().getLineAtOffset(offset);
        Range<Integer> visibleLines = this.content.getVisibleLines();
        if (!visibleLines.contains(Integer.valueOf(lineIdx))) {
            int linesVisible = visibleLines.upperEndpoint().intValue()
                    - visibleLines.lowerEndpoint().intValue();
            int delta = linesVisible - verticalOffset;
            int scrollLine = Math.min(lineIdx + delta, getSkinnable().getContent().getLineCount() - 1);
            scrollLineIntoView(scrollLine);
        }/*ww w .ja  v  a 2  s .  c  om*/

        int colIdx = offset - getSkinnable().getContent().getOffsetAtLine(lineIdx);
        String line = getSkinnable().getContent().getLine(lineIdx).substring(0, colIdx);
        int tabCount = (int) line.chars().filter(c -> c == '\t').count();
        scrollColumnIntoView(colIdx + tabCount * (getSkinnable().tabAvanceProperty().get() - 1),
                horizontalOffset);
    } else {
        scrollLineIntoView(0);
        scrollColumnIntoView(0, 0);
    }
}

From source file:com.bigdata.dastor.utils.MerkleTree.java

/**
 * @throws StopRecursion If no match could be found for the range.
 *///from w ww. java 2s  .c  o m
private byte[] hashHelper(Hashable hashable, Range active, Range range) throws StopRecursion {
    if (hashable instanceof Leaf) {
        if (!range.contains(active))
            // we are not fully contained in this range!
            throw new StopRecursion.BadRange();
        return hashable.hash();
    }
    // else: node.

    Inner node = (Inner) hashable;
    Range leftactive = new Range(active.left, node.token);
    Range rightactive = new Range(node.token, active.right);

    if (range.contains(active)) {
        // this node is fully contained in the range
        if (node.hash() != null)
            // we had a cached value
            return node.hash();
        // continue recursing to hash our children
        byte[] lhash = hashHelper(node.lchild(), leftactive, range);
        byte[] rhash = hashHelper(node.rchild(), rightactive, range);
        // cache the computed value (even if it is null)
        node.hash(lhash, rhash);
        return node.hash();
    } // else: one of our children contains the range

    if (leftactive.contains(range))
        // left child contains/matches the range
        return hashHelper(node.lchild, leftactive, range);
    else if (rightactive.contains(range))
        // right child contains/matches the range
        return hashHelper(node.rchild, rightactive, range);
    else
        throw new StopRecursion.BadRange();
}

From source file:net.sf.mzmine.modules.visualization.ida.PeakDataSet.java

PeakDataSet(RawDataFile dataFile, PeakList peakList, Range<Double> rtRange, Range<Double> mzRange) {

    this.peakList = peakList;

    Vector<Feature> processedPeaks = new Vector<Feature>(1024, 1024);
    Vector<PeakDataPoint[]> processedPeakDataPoints = new Vector<PeakDataPoint[]>(1024, 1024);
    Vector<PeakDataPoint> thisPeakDataPoints = new Vector<PeakDataPoint>();

    Feature allPeaks[] = peakList.getPeaks(dataFile);

    for (Feature peak : allPeaks) {

        int scanNumbers[] = peak.getScanNumbers();

        for (int scan : scanNumbers) {

            double rt = dataFile.getScan(scan).getRetentionTime();
            DataPoint dp = peak.getDataPoint(scan);
            if (dp != null) {
                if (rtRange.contains(rt) && mzRange.contains(dp.getMZ())) {
                    PeakDataPoint newDP = new PeakDataPoint(scan, rt, dp);
                    thisPeakDataPoints.add(newDP);
                }/*from ww  w  .  ja va  2s .  c o  m*/
            }

        }

        if (thisPeakDataPoints.size() > 0) {
            PeakDataPoint dpArray[] = thisPeakDataPoints.toArray(new PeakDataPoint[0]);
            processedPeaks.add(peak);
            processedPeakDataPoints.add(dpArray);
            thisPeakDataPoints.clear();
        }

    }

    peaks = processedPeaks.toArray(new Feature[0]);
    dataPoints = processedPeakDataPoints.toArray(new PeakDataPoint[0][]);

}

From source file:net.sf.mzmine.modules.visualization.twod.TwoDBottomPanel.java

/**
 * Returns a peak list with the top peaks defined by the parameter
 * "threshold"/*from   www  . ja  v  a 2 s .  c om*/
 */
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) {
        mzRange = masterFrame.getPlot().getXYPlot().getAxisRange();
        rtRange = masterFrame.getPlot().getXYPlot().getDomainRange();
    }

    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;
}