Search in sources :

Example 1 with KaplanMeierData

use of qupath.lib.analysis.stats.survival.KaplanMeierData in project qupath by qupath.

the class KaplanMeierDisplay method calculateOptimalExtremePositiveNegativeThresholds.

/**
 * Helper method to calculate best splits (in terms of log-rank test) used to identify extreme positive & negative phenotypes.
 *
 * This is useful when looking at P53.
 *
 * @param scoreData
 * @param censorThreshold
 * @return
 */
static double[] calculateOptimalExtremePositiveNegativeThresholds(final KaplanMeierDisplay.ScoreData scoreData, final double censorThreshold) {
    double[] thresholds = scoreData.scores.clone();
    Arrays.sort(thresholds);
    double t1Optimal = Double.NaN;
    double t2Optimal = Double.NaN;
    double bestP = Double.POSITIVE_INFINITY;
    double bestPSplit = Double.POSITIVE_INFINITY;
    int g1 = 0;
    int g2 = 0;
    int g3 = 0;
    // int skip = scoreData.scores.length/10;
    int skip = thresholds.length / 10;
    double median = thresholds[thresholds.length / 2];
    for (int i = skip; i < thresholds.length - skip; i++) {
        double t1 = thresholds[i];
        if (t1 > median)
            break;
        for (int j = i + 1; j < thresholds.length - skip; j++) {
            double t2 = thresholds[j];
            if (t2 < median)
                continue;
            List<KaplanMeierData> kmsTemp = splitByThresholds(scoreData, new double[] { t1, t2 }, censorThreshold, false);
            // Add extreme positive event list to extreme negative
            kmsTemp.get(0).addEvents(kmsTemp.get(2).getEvents());
            LogRankResult test = LogRankTest.computeLogRankTest(kmsTemp.get(0), kmsTemp.get(1));
            double pValue = test.getPValue();
            if (pValue < bestP) {
                double split = (double) kmsTemp.get(0).nEvents() / (kmsTemp.get(0).nEvents() + kmsTemp.get(1).nEvents());
                if (Math.abs(split - 0.5) < bestPSplit) {
                    bestP = pValue;
                    bestPSplit = split;
                    t1Optimal = t1;
                    t2Optimal = t2;
                    g3 = kmsTemp.get(2).getEvents().size();
                    g2 = kmsTemp.get(1).getEvents().size();
                    // Remember we added here...
                    g1 = kmsTemp.get(0).getEvents().size() - g3;
                }
            }
        }
    }
    logger.info("Optimal split thresholds: {} and {} (p-value {}; group sizes {}, {} and {})", t1Optimal, t2Optimal, bestP, g1, g2, g3);
    return new double[] { bestP, t1Optimal, t2Optimal };
}
Also used : KaplanMeierData(qupath.lib.analysis.stats.survival.KaplanMeierData) LogRankResult(qupath.lib.analysis.stats.survival.LogRankTest.LogRankResult)

Example 2 with KaplanMeierData

use of qupath.lib.analysis.stats.survival.KaplanMeierData in project qupath by qupath.

the class KaplanMeierDisplay method generatePlot.

@SuppressWarnings("unchecked")
private void generatePlot() {
    KaplanMeierDisplay.ScoreData newScoreData = scoreData;
    // If we have a hierarchy, update the scores with the most recent data
    if (hierarchy != null) {
        List<TMACoreObject> cores = PathObjectTools.getTMACoreObjects(hierarchy, false);
        double[] survival = new double[cores.size()];
        boolean[] censored = new boolean[cores.size()];
        double[] scores = new double[cores.size()];
        // scoreColumn = "RoughScore";
        for (int i = 0; i < cores.size(); i++) {
            TMACoreObject core = cores.get(i);
            MeasurementList ml = core.getMeasurementList();
            survival[i] = core.getMeasurementList().getMeasurementValue(survivalColumn);
            double censoredValue = core.getMeasurementList().getMeasurementValue(censoredColumn);
            boolean hasCensoredValue = !Double.isNaN(censoredValue) && (censoredValue == 0 || censoredValue == 1);
            censored[i] = censoredValue != 0;
            if (!hasCensoredValue) {
                // If we don't have a censored value, ensure we mask out everything else
                scores[i] = Double.NaN;
                survival[i] = Double.NaN;
            } else if (ml.containsNamedMeasurement(scoreColumn))
                // Get the score if we can
                scores[i] = ml.getMeasurementValue(scoreColumn);
            else {
                // // Try to compute score if we need to
                // Map<String, Number> map = ROIMeaningfulMeasurements.getPathClassSummaryMeasurements(core.getChildObjects(), true);
                // Number value = map.get(scoreColumn);
                // if (value == null)
                scores[i] = Double.NaN;
            // else
            // scores[i] = value.doubleValue();
            }
        }
        // Mask out any scores that don't have associated survival data
        for (int i = 0; i < survival.length; i++) {
            if (Double.isNaN(survival[i]))
                scores[i] = Double.NaN;
        }
        newScoreData = new ScoreData(scores, survival, censored);
    }
    if (newScoreData == null || newScoreData.scores.length == 0)
        return;
    // KaplanMeier kmHigh = new KaplanMeier("Above threshold");
    // KaplanMeier kmLow = new KaplanMeier("Below threshold");
    double[] quartiles = StatisticsHelper.getQuartiles(newScoreData.scores);
    double q1 = quartiles[0];
    double median = quartiles[1];
    double q3 = quartiles[2];
    double[] thresholds;
    if (params != null) {
        Object thresholdMethod = params.getChoiceParameterValue("scoreThresholdMethod");
        if (thresholdMethod.equals("Median")) {
            // panelParams.setNumericParameterValue("scoreThreshold", median);
            // ((DoubleParameter)params.getParameters().get("scoreThreshold")).setValue(median); // TODO: UPDATE DIALOG!
            thresholds = new double[] { median };
        } else if (thresholdMethod.equals("Tertiles")) {
            // ((DoubleParameter)params.getParameters().get("scoreThreshold")).setValue(median); // TODO: UPDATE DIALOG!
            thresholds = StatisticsHelper.getTertiles(newScoreData.scores);
        } else if (thresholdMethod.equals("Quartiles")) {
            // ((DoubleParameter)params.getParameters().get("scoreThreshold")).setValue(median); // TODO: UPDATE DIALOG!
            thresholds = new double[] { q1, median, q3 };
        } else if (thresholdMethod.equals("Manual (1)")) {
            thresholds = new double[] { params.getDoubleParameterValue("threshold1") };
        } else if (thresholdMethod.equals("Manual (2)")) {
            thresholds = new double[] { params.getDoubleParameterValue("threshold1"), params.getDoubleParameterValue("threshold2") };
        } else
            // if (thresholdMethod.equals("Manual (3)")) {
            thresholds = new double[] { params.getDoubleParameterValue("threshold1"), params.getDoubleParameterValue("threshold2"), params.getDoubleParameterValue("threshold3") };
    } else
        thresholds = new double[] { median };
    double minVal = Double.POSITIVE_INFINITY;
    double maxVal = Double.NEGATIVE_INFINITY;
    int numNonNaN = 0;
    for (double d : newScoreData.scores) {
        if (Double.isNaN(d))
            continue;
        if (d < minVal)
            minVal = d;
        if (d > maxVal)
            maxVal = d;
        numNonNaN++;
    }
    // If not this, we don't have valid scores that we can work with
    boolean scoresValid = maxVal > minVal;
    double maxTimePoint = 0;
    for (double d : newScoreData.survival) {
        if (Double.isNaN(d))
            continue;
        if (d > maxTimePoint)
            maxTimePoint = d;
    }
    if (panelParams != null && maxTimePoint > ((IntParameter) params.getParameters().get("censorTimePoints")).getUpperBound()) {
        panelParams.setNumericParameterValueRange("censorTimePoints", 0, Math.ceil(maxTimePoint));
    }
    // Optionally censor at specified time
    double censorThreshold = params == null ? maxTimePoint : params.getIntParameterValue("censorTimePoints");
    // Compute log-rank p-values for *all* possible thresholds
    // Simultaneously determine the threshold that yields the lowest p-value,
    // resolving ties in favour of a more even split between high/low numbers of events
    boolean pValuesChanged = false;
    if (calculateAllPValues) {
        if (!(pValues != null && pValueThresholds != null && newScoreData.equals(scoreData) && censorThreshold == lastPValueCensorThreshold)) {
            Map<Double, Double> mapLogRank = new TreeMap<>();
            Set<Double> setObserved = new HashSet<>();
            for (int i = 0; i < newScoreData.scores.length; i++) {
                Double d = newScoreData.scores[i];
                boolean observed = !newScoreData.censored[i] && newScoreData.survival[i] < censorThreshold;
                if (observed)
                    setObserved.add(d);
                if (mapLogRank.containsKey(d))
                    continue;
                List<KaplanMeierData> kmsTemp = splitByThresholds(newScoreData, new double[] { d }, censorThreshold, false);
                // if (kmsTemp.get(1).nObserved() == 0 || kmsTemp.get(1).nObserved() == 0)
                // continue;
                LogRankResult test = LogRankTest.computeLogRankTest(kmsTemp.get(0), kmsTemp.get(1));
                double pValue = test.getPValue();
                // double pValue = test.hazardRatio < 1 ? test.hazardRatio : 1.0/test.hazardRatio; // Checking usefulness of Hazard ratios...
                if (!Double.isFinite(pValue))
                    continue;
                // if (!Double.isFinite(test.getHazardRatio())) {
                // //						continue;
                // pValue = Double.NaN;
                // }
                mapLogRank.put(d, pValue);
            }
            pValueThresholds = new double[mapLogRank.size()];
            pValues = new double[mapLogRank.size()];
            pValueThresholdsObserved = new boolean[mapLogRank.size()];
            int count = 0;
            for (Entry<Double, Double> entry : mapLogRank.entrySet()) {
                pValueThresholds[count] = entry.getKey();
                pValues[count] = entry.getValue();
                if (setObserved.contains(entry.getKey()))
                    pValueThresholdsObserved[count] = true;
                count++;
            }
            // Find the longest 'significant' stretch
            int maxSigCount = 0;
            int maxSigInd = -1;
            int sigCurrent = 0;
            int[] sigCount = new int[pValues.length];
            for (int i = 0; i < pValues.length; i++) {
                if (pValues[i] < 0.05) {
                    sigCurrent++;
                    sigCount[i] = sigCurrent;
                    if (sigCurrent > maxSigCount) {
                        maxSigCount = sigCurrent;
                        maxSigInd = i;
                    }
                } else
                    sigCurrent = 0;
            }
            if (maxSigCount == 0) {
                logger.info("No p-values < 0.05");
            } else {
                double minThresh = maxSigInd - maxSigCount < 0 ? pValueThresholds[0] - 0.0000001 : pValueThresholds[maxSigInd - maxSigCount];
                double maxThresh = pValueThresholds[maxSigInd];
                int nBetween = 0;
                int nBetweenObserved = 0;
                for (int i = 0; i < newScoreData.scores.length; i++) {
                    if (newScoreData.scores[i] > minThresh && newScoreData.scores[i] <= maxThresh) {
                        nBetween++;
                        if (newScoreData.survival[i] < censorThreshold && !newScoreData.censored[i])
                            nBetweenObserved++;
                    }
                }
                logger.info("Longest stretch of p-values < 0.05: {} - {} ({} entries, {} observed)", minThresh, maxThresh, nBetween, nBetweenObserved);
            }
            pValuesSmoothed = new double[pValues.length];
            Arrays.fill(pValuesSmoothed, Double.NaN);
            int n = (pValues.length / 20) * 2 + 1;
            logger.info("Smoothing log-rank test p-values by " + n);
            for (int i = n / 2; i < pValues.length - n / 2; i++) {
                double sum = 0;
                for (int k = i - n / 2; k < i - n / 2 + n; k++) {
                    sum += pValues[k];
                }
                pValuesSmoothed[i] = sum / n;
            }
            // for (int i = 0; i < pValues.length; i++) {
            // double sum = 0;
            // for (int k = Math.max(0, i-n/2); k < Math.min(pValues.length, i-n/2+n); k++) {
            // sum += pValues[k];
            // }
            // pValuesSmoothed[i] = sum/n;
            // }
            // pValues = pValuesSmoothed;
            lastPValueCensorThreshold = censorThreshold;
            pValuesChanged = true;
        }
    } else {
        lastPValueCensorThreshold = Double.NaN;
        pValueThresholds = null;
        pValues = null;
    }
    // if (params != null && !Double.isNaN(bestThreshold) && (params.getChoiceParameterValue("scoreThresholdMethod").equals("Lowest p-value")))
    if (params != null && (params.getChoiceParameterValue("scoreThresholdMethod").equals("Lowest p-value"))) {
        int bestIdx = -1;
        double bestPValue = Double.POSITIVE_INFINITY;
        for (int i = pValueThresholds.length / 10; i < pValueThresholds.length * 9 / 10; i++) {
            if (pValues[i] < bestPValue) {
                bestIdx = i;
                bestPValue = pValues[i];
            }
        }
        thresholds = bestIdx >= 0 ? new double[] { pValueThresholds[bestIdx] } : new double[0];
    } else if (params != null && (params.getChoiceParameterValue("scoreThresholdMethod").equals("Lowest smoothed p-value"))) {
        int bestIdx = -1;
        double bestPValue = Double.POSITIVE_INFINITY;
        for (int i = pValueThresholds.length / 10; i < pValueThresholds.length * 9 / 10; i++) {
            if (pValuesSmoothed[i] < bestPValue) {
                bestIdx = i;
                bestPValue = pValuesSmoothed[i];
            }
        }
        thresholds = bestIdx >= 0 ? new double[] { pValueThresholds[bestIdx] } : new double[0];
    }
    // Split into different curves using the provided thresholds
    List<KaplanMeierData> kms = splitByThresholds(newScoreData, thresholds, censorThreshold, params != null && "Quartiles".equals(params.getChoiceParameterValue("scoreThresholdMethod")));
    if (plotter == null) {
        plotter = new KaplanMeierChartWrapper(survivalColumn + " time");
    // plotter.setBorder(BorderFactory.createTitledBorder("Survival plot"));
    // plotter.getCanvas().setWidth(300);
    // plotter.getCanvas().setHeight(300);
    }
    KaplanMeierData[] kmArray = new KaplanMeierData[kms.size()];
    plotter.setKaplanMeierCurves(survivalColumn + " time", kms.toArray(kmArray));
    tableModel.setSurvivalCurves(thresholds, params != null && params.getChoiceParameterValue("scoreThresholdMethod").equals("Lowest p-value"), kmArray);
    // Bar width determined using 'Freedman and Diaconis' rule' (but overridden if this gives < 16 bins...)
    double barWidth = (2 * q3 - q1) * Math.pow(numNonNaN, -1.0 / 3.0);
    int nBins = 100;
    if (!Double.isNaN(barWidth))
        barWidth = (int) Math.max(16, Math.ceil((maxVal - minVal) / barWidth));
    Histogram histogram = scoresValid ? new Histogram(newScoreData.scores, nBins) : null;
    if (histogramPanel == null) {
        GridPane paneHistogram = new GridPane();
        histogramPanel = new HistogramPanelFX();
        histogramPanel.getChart().setAnimated(false);
        histogramWrapper = new ThresholdedChartWrapper(histogramPanel.getChart());
        for (ObservableNumberValue val : threshProperties) histogramWrapper.addThreshold(val, ColorToolsFX.getCachedColor(240, 0, 0, 128));
        histogramWrapper.getPane().setPrefHeight(150);
        paneHistogram.add(histogramWrapper.getPane(), 0, 0);
        Tooltip.install(histogramPanel.getChart(), new Tooltip("Distribution of scores"));
        GridPane.setHgrow(histogramWrapper.getPane(), Priority.ALWAYS);
        GridPane.setVgrow(histogramWrapper.getPane(), Priority.ALWAYS);
        NumberAxis xAxis = new NumberAxis();
        xAxis.setLabel("Score threshold");
        NumberAxis yAxis = new NumberAxis();
        yAxis.setLowerBound(0);
        yAxis.setUpperBound(1);
        yAxis.setTickUnit(0.1);
        yAxis.setAutoRanging(false);
        yAxis.setLabel("P-value");
        chartPValues = new LineChart<>(xAxis, yAxis);
        chartPValues.setAnimated(false);
        chartPValues.setLegendVisible(false);
        // Make chart so it can be navigated
        ChartTools.makeChartInteractive(chartPValues, xAxis, yAxis);
        pValuesChanged = true;
        Tooltip.install(chartPValues, new Tooltip("Distribution of p-values (log-rank test) comparing low vs. high for all possible score thresholds"));
        // chartPValues.getYAxis().setAutoRanging(false);
        pValuesWrapper = new ThresholdedChartWrapper(chartPValues);
        for (ObservableNumberValue val : threshProperties) pValuesWrapper.addThreshold(val, ColorToolsFX.getCachedColor(240, 0, 0, 128));
        pValuesWrapper.getPane().setPrefHeight(150);
        paneHistogram.add(pValuesWrapper.getPane(), 0, 1);
        GridPane.setHgrow(pValuesWrapper.getPane(), Priority.ALWAYS);
        GridPane.setVgrow(pValuesWrapper.getPane(), Priority.ALWAYS);
        ContextMenu popup = new ContextMenu();
        ChartTools.addChartExportMenu(chartPValues, popup);
        RadioMenuItem miZoomY1 = new RadioMenuItem("0-1");
        miZoomY1.setOnAction(e -> {
            yAxis.setAutoRanging(false);
            yAxis.setUpperBound(1);
            yAxis.setTickUnit(0.2);
        });
        RadioMenuItem miZoomY05 = new RadioMenuItem("0-0.5");
        miZoomY05.setOnAction(e -> {
            yAxis.setAutoRanging(false);
            yAxis.setUpperBound(0.5);
            yAxis.setTickUnit(0.1);
        });
        RadioMenuItem miZoomY02 = new RadioMenuItem("0-0.2");
        miZoomY02.setOnAction(e -> {
            yAxis.setAutoRanging(false);
            yAxis.setUpperBound(0.2);
            yAxis.setTickUnit(0.05);
        });
        RadioMenuItem miZoomY01 = new RadioMenuItem("0-0.1");
        miZoomY01.setOnAction(e -> {
            yAxis.setAutoRanging(false);
            yAxis.setUpperBound(0.1);
            yAxis.setTickUnit(0.05);
        });
        RadioMenuItem miZoomY005 = new RadioMenuItem("0-0.05");
        miZoomY005.setOnAction(e -> {
            yAxis.setAutoRanging(false);
            yAxis.setUpperBound(0.05);
            yAxis.setTickUnit(0.01);
        });
        RadioMenuItem miZoomY001 = new RadioMenuItem("0-0.01");
        miZoomY001.setOnAction(e -> {
            yAxis.setAutoRanging(false);
            yAxis.setUpperBound(0.01);
            yAxis.setTickUnit(0.005);
        });
        ToggleGroup tgZoom = new ToggleGroup();
        miZoomY1.setToggleGroup(tgZoom);
        miZoomY05.setToggleGroup(tgZoom);
        miZoomY02.setToggleGroup(tgZoom);
        miZoomY01.setToggleGroup(tgZoom);
        miZoomY005.setToggleGroup(tgZoom);
        miZoomY001.setToggleGroup(tgZoom);
        Menu menuZoomY = new Menu("Set y-axis range");
        menuZoomY.getItems().addAll(miZoomY1, miZoomY05, miZoomY02, miZoomY01, miZoomY005, miZoomY001);
        MenuItem miCopyData = new MenuItem("Copy chart data");
        miCopyData.setOnAction(e -> {
            String dataString = ChartTools.getChartDataAsString(chartPValues);
            ClipboardContent content = new ClipboardContent();
            content.putString(dataString);
            Clipboard.getSystemClipboard().setContent(content);
        });
        popup.getItems().addAll(miCopyData, menuZoomY);
        chartPValues.setOnContextMenuRequested(e -> {
            popup.show(chartPValues, e.getScreenX(), e.getScreenY());
        });
        for (int col = 0; col < tableModel.getColumnCount(); col++) {
            TableColumn<Integer, String> column = new TableColumn<>(tableModel.getColumnName(col));
            int colNumber = col;
            column.setCellValueFactory(new Callback<CellDataFeatures<Integer, String>, ObservableValue<String>>() {

                @Override
                public ObservableValue<String> call(CellDataFeatures<Integer, String> p) {
                    return new SimpleStringProperty((String) tableModel.getValueAt(p.getValue(), colNumber));
                }
            });
            column.setCellFactory(new Callback<TableColumn<Integer, String>, TableCell<Integer, String>>() {

                @Override
                public TableCell<Integer, String> call(TableColumn<Integer, String> param) {
                    TableCell<Integer, String> cell = new TableCell<Integer, String>() {

                        @Override
                        protected void updateItem(String item, boolean empty) {
                            super.updateItem(item, empty);
                            setText(item);
                            setTooltip(new Tooltip(item));
                        }
                    };
                    return cell;
                }
            });
            table.getColumns().add(column);
        }
        table.setPrefHeight(250);
        table.setColumnResizePolicy(TableView.CONSTRAINED_RESIZE_POLICY);
        table.maxHeightProperty().bind(table.prefHeightProperty());
        params = new ParameterList();
        // maxTimePoint = 0;
        // for (TMACoreObject core : hierarchy.getTMAGrid().getTMACoreList()) {
        // double os = core.getMeasurementList().getMeasurementValue(TMACoreObject.KEY_OVERALL_SURVIVAL);
        // double rfs = core.getMeasurementList().getMeasurementValue(TMACoreObject.KEY_RECURRENCE_FREE_SURVIVAL);
        // if (os > maxTimePoint)
        // maxTimePoint = os;
        // if (rfs > maxTimePoint)
        // maxTimePoint = rfs;
        // }
        params.addIntParameter("censorTimePoints", "Max censored time", (int) (censorThreshold + 0.5), null, 0, (int) Math.ceil(maxTimePoint), "Latest time point beyond which data will be censored");
        // params.addChoiceParameter("scoreThresholdMethod", "Threshold method", "Manual", Arrays.asList("Manual", "Median", "Log-rank test"));
        if (calculateAllPValues)
            // Don't include "Lowest smoothed p-value" - it's not an established method and open to misinterpretation...
            params.addChoiceParameter("scoreThresholdMethod", "Threshold method", "Median", Arrays.asList("Manual (1)", "Manual (2)", "Manual (3)", "Median", "Tertiles", "Quartiles", "Lowest p-value"));
        else
            // params.addChoiceParameter("scoreThresholdMethod", "Threshold method", "Median", Arrays.asList("Manual (1)", "Manual (2)", "Manual (3)", "Median", "Tertiles", "Quartiles", "Lowest p-value", "Lowest smoothed p-value"));
            params.addChoiceParameter("scoreThresholdMethod", "Threshold method", "Median", Arrays.asList("Manual (1)", "Manual (2)", "Manual (3)", "Median", "Tertiles", "Quartiles"));
        params.addDoubleParameter("threshold1", "Threshold 1", thresholds.length > 0 ? thresholds[0] : (minVal + maxVal) / 2, null, "Threshold to distinguish between patient groups");
        params.addDoubleParameter("threshold2", "Threshold 2", thresholds.length > 1 ? thresholds[1] : (minVal + maxVal) / 2, null, "Threshold to distinguish between patient groups");
        params.addDoubleParameter("threshold3", "Threshold 3", thresholds.length > 2 ? thresholds[2] : (minVal + maxVal) / 2, null, "Threshold to distinguish between patient groups");
        params.addBooleanParameter("showAtRisk", "Show at risk", plotter.getShowAtRisk(), "Show number of patients at risk below the plot");
        params.addBooleanParameter("showTicks", "Show censored ticks", plotter.getShowCensoredTicks(), "Show ticks to indicate censored data");
        params.addBooleanParameter("showKey", "Show key", plotter.getShowKey(), "Show key indicating display of each curve");
        // Hide threshold parameters if threshold can't be used
        if (!scoresValid) {
            // params.setHiddenParameters(true, "scoreThresholdMethod", "scoreThreshold");
            histogramPanel.getChart().setVisible(false);
        }
        panelParams = new ParameterPanelFX(params);
        panelParams.addParameterChangeListener(this);
        updateThresholdsEnabled();
        for (int i = 0; i < threshProperties.length; i++) {
            String p = "threshold" + (i + 1);
            threshProperties[i].addListener((v, o, n) -> {
                if (interactiveThresholds()) {
                    // Need to do a decent double check with tolerance to text field value changing while typing
                    if (!GeneralTools.almostTheSame(params.getDoubleParameterValue(p), n.doubleValue(), 0.0001))
                        panelParams.setNumericParameterValue(p, n);
                }
            });
        }
        BorderPane paneBottom = new BorderPane();
        TitledPane paneOptions = new TitledPane("Options", panelParams.getPane());
        // paneOptions.setCollapsible(false);
        Pane paneCanvas = new StackPane();
        paneCanvas.getChildren().add(plotter.getCanvas());
        GridPane paneLeft = new GridPane();
        paneLeft.add(paneOptions, 0, 0);
        paneLeft.add(table, 0, 1);
        GridPane.setHgrow(paneOptions, Priority.ALWAYS);
        GridPane.setHgrow(table, Priority.ALWAYS);
        paneBottom.setLeft(paneLeft);
        paneBottom.setCenter(paneHistogram);
        paneMain.setCenter(paneCanvas);
        paneMain.setBottom(paneBottom);
        paneMain.setPadding(new Insets(10, 10, 10, 10));
    } else if (thresholds.length > 0) {
        // Ensure the sliders/text fields are set sensibly
        if (!GeneralTools.almostTheSame(thresholds[0], params.getDoubleParameterValue("threshold1"), 0.0001)) {
            panelParams.setNumericParameterValue("threshold1", thresholds[0]);
        }
        if (thresholds.length > 1 && !GeneralTools.almostTheSame(thresholds[1], params.getDoubleParameterValue("threshold2"), 0.0001)) {
            panelParams.setNumericParameterValue("threshold2", thresholds[1]);
        }
        if (thresholds.length > 2 && !GeneralTools.almostTheSame(thresholds[2], params.getDoubleParameterValue("threshold3"), 0.0001)) {
            panelParams.setNumericParameterValue("threshold3", thresholds[2]);
        }
    }
    if (histogram != null) {
        histogramPanel.getHistogramData().setAll(HistogramPanelFX.createHistogramData(histogram, false, (Color) null));
        histogramPanel.getChart().getXAxis().setLabel(scoreColumn);
        histogramPanel.getChart().getYAxis().setLabel("Count");
        ChartTools.addChartExportMenu(histogramPanel.getChart(), null);
    // histogramWrapper.setVerticalLines(thresholds, ColorToolsFX.getCachedColor(240, 0, 0, 128));
    // Deal with threshold adjustment
    // histogramWrapper.getThresholds().addListener((Observable o) -> generatePlot());
    }
    if (pValues != null) {
        // TODO: Raise earlier where p-value calculation is
        if (pValuesChanged) {
            ObservableList<XYChart.Data<Number, Number>> data = FXCollections.observableArrayList();
            for (int i = 0; i < pValueThresholds.length; i++) {
                double pValue = pValues[i];
                if (Double.isNaN(pValue))
                    continue;
                data.add(new XYChart.Data<>(pValueThresholds[i], pValue, pValueThresholdsObserved[i]));
            }
            ObservableList<XYChart.Data<Number, Number>> dataSmoothed = null;
            if (pValuesSmoothed != null) {
                dataSmoothed = FXCollections.observableArrayList();
                for (int i = 0; i < pValueThresholds.length; i++) {
                    double pValueSmoothed = pValuesSmoothed[i];
                    if (Double.isNaN(pValueSmoothed))
                        continue;
                    dataSmoothed.add(new XYChart.Data<>(pValueThresholds[i], pValueSmoothed));
                }
            }
            // Don't bother showing the smoothed data... it tends to get in the way...
            // if (dataSmoothed != null)
            // chartPValues.getData().setAll(new XYChart.Series<>("P-values", data), new XYChart.Series<>("Smoothed P-values", dataSmoothed));
            // else
            chartPValues.getData().setAll(new XYChart.Series<>("P-values", data));
            // Add line to show 0.05 significance threshold
            if (pValueThresholds.length > 1) {
                Data<Number, Number> sigData1 = new Data<>(pValueThresholds[0], 0.05);
                Data<Number, Number> sigData2 = new Data<>(pValueThresholds[pValueThresholds.length - 1], 0.05);
                XYChart.Series<Number, Number> dataSignificant = new XYChart.Series<>("Significance 0.05", FXCollections.observableArrayList(sigData1, sigData2));
                chartPValues.getData().add(dataSignificant);
                sigData1.getNode().setVisible(false);
                sigData2.getNode().setVisible(false);
            }
            // pValuesWrapper.clearThresholds();
            for (XYChart.Data<Number, Number> dataPoint : data) {
                if (!Boolean.TRUE.equals(dataPoint.getExtraValue()))
                    dataPoint.getNode().setVisible(false);
            }
        // if (dataSmoothed != null) {
        // for (XYChart.Data<Number, Number> dataPoint : dataSmoothed) {
        // dataPoint.getNode().setVisible(false);
        // }
        // chartPValues.getData().get(1).getNode().setOpacity(0.5);
        // }
        // int count = 0;
        // for (int i = 0; i < pValueThresholds.length; i++) {
        // double pValue = pValues[i];
        // if (Double.isNaN(pValue))
        // continue;
        // boolean observed = pValueThresholdsObserved[i];
        // //						if (observed)
        // //							pValuesWrapper.addThreshold(new ReadOnlyDoubleWrapper(pValueThresholds[i]), Color.rgb(0, 0, 0, 0.05));
        // 
        // if (!observed) {
        // //							StackPane pane = (StackPane)data.get(count).getNode();
        // //							pane.setEffect(new DropShadow());
        // data.get(count).getNode().setVisible(false);
        // }
        // count++;
        // }
        }
        for (int i = 0; i < threshProperties.length; i++) {
            if (i < thresholds.length)
                threshProperties[i].set(thresholds[i]);
            else
                threshProperties[i].set(Double.NaN);
        }
        boolean isInteractive = interactiveThresholds();
        histogramWrapper.setIsInteractive(isInteractive);
        pValuesWrapper.setIsInteractive(isInteractive);
        chartPValues.setVisible(true);
    }
    // else
    // chartPValues.setVisible(false);
    // Store values for next time
    scoreData = newScoreData;
}
Also used : Histogram(qupath.lib.analysis.stats.Histogram) CellDataFeatures(javafx.scene.control.TableColumn.CellDataFeatures) ObservableValue(javafx.beans.value.ObservableValue) ThresholdedChartWrapper(qupath.lib.gui.charts.HistogramPanelFX.ThresholdedChartWrapper) StackPane(javafx.scene.layout.StackPane) HashSet(java.util.HashSet) ObservableNumberValue(javafx.beans.value.ObservableNumberValue) GridPane(javafx.scene.layout.GridPane) TMACoreObject(qupath.lib.objects.TMACoreObject) Tooltip(javafx.scene.control.Tooltip) Color(javafx.scene.paint.Color) SimpleStringProperty(javafx.beans.property.SimpleStringProperty) TableColumn(javafx.scene.control.TableColumn) StackPane(javafx.scene.layout.StackPane) Pane(javafx.scene.layout.Pane) BorderPane(javafx.scene.layout.BorderPane) GridPane(javafx.scene.layout.GridPane) TitledPane(javafx.scene.control.TitledPane) ParameterList(qupath.lib.plugins.parameters.ParameterList) XYChart(javafx.scene.chart.XYChart) TMACoreObject(qupath.lib.objects.TMACoreObject) HistogramPanelFX(qupath.lib.gui.charts.HistogramPanelFX) LogRankResult(qupath.lib.analysis.stats.survival.LogRankTest.LogRankResult) IntParameter(qupath.lib.plugins.parameters.IntParameter) BorderPane(javafx.scene.layout.BorderPane) NumberAxis(javafx.scene.chart.NumberAxis) Insets(javafx.geometry.Insets) ClipboardContent(javafx.scene.input.ClipboardContent) MeasurementList(qupath.lib.measurements.MeasurementList) ContextMenu(javafx.scene.control.ContextMenu) RadioMenuItem(javafx.scene.control.RadioMenuItem) KaplanMeierData(qupath.lib.analysis.stats.survival.KaplanMeierData) ParameterPanelFX(qupath.lib.gui.dialogs.ParameterPanelFX) TableCell(javafx.scene.control.TableCell) ContextMenu(javafx.scene.control.ContextMenu) Menu(javafx.scene.control.Menu) TitledPane(javafx.scene.control.TitledPane) MenuItem(javafx.scene.control.MenuItem) RadioMenuItem(javafx.scene.control.RadioMenuItem) KaplanMeierData(qupath.lib.analysis.stats.survival.KaplanMeierData) Data(javafx.scene.chart.XYChart.Data) TreeMap(java.util.TreeMap) ToggleGroup(javafx.scene.control.ToggleGroup)

Example 3 with KaplanMeierData

use of qupath.lib.analysis.stats.survival.KaplanMeierData in project qupath by qupath.

the class KaplanMeierChartWrapper method setKaplanMeierCurves.

KaplanMeierChartWrapper setKaplanMeierCurves(final String survivalKey, final KaplanMeierData... kms) {
    kmList.clear();
    double maxTime = 0;
    for (KaplanMeierData km : kms) {
        kmList.add(km);
        maxTime = Math.max(maxTime, km.getMaxTime());
    }
    xAxis.setAutoRanging(false);
    xAxis.setLowerBound(0);
    xAxis.setUpperBound(maxTime);
    xAxis.setLabel(survivalKey);
    yAxis.setAutoRanging(false);
    yAxis.setLowerBound(0);
    yAxis.setUpperBound(1);
    chart.setLegendSide(Side.RIGHT);
    updateChart();
    return this;
}
Also used : KaplanMeierData(qupath.lib.analysis.stats.survival.KaplanMeierData)

Example 4 with KaplanMeierData

use of qupath.lib.analysis.stats.survival.KaplanMeierData in project qupath by qupath.

the class KaplanMeierChartWrapper method updateChart.

void updateChart() {
    // Loop through the plots to get the maximum time that's needed
    double maxTime = -1;
    for (KaplanMeierData km : kmList) {
        maxTime = Math.max(maxTime, km.getMaxTime());
    }
    if (maxTime < 0)
        return;
    chart.setAnimated(false);
    // Loop through the plots to draw them
    int count = 0;
    for (KaplanMeierData km : kmList) {
        XYChart.Series<Number, Number> series = new XYChart.Series<>();
        series.setName(km.getName());
        double[] times = km.getAllTimes();
        double[] stats = km.getStatistic();
        double x1 = 0;
        double y1 = 1;
        series.getData().add(new XYChart.Data<>(x1, y1));
        for (int i = 0; i < times.length; i++) {
            // Transform coordinates for lines
            double x2 = times[i];
            double y2 = stats[i];
            // Draw
            XYChart.Data<Number, Number> data = new XYChart.Data<>(x2, y1);
            series.getData().add(data);
            if (y1 != y2) {
                data = new XYChart.Data<>(x2, y2);
                data.setExtraValue(Boolean.FALSE);
                series.getData().add(data);
            // data.setNode(null);
            } else
                data.setExtraValue(Boolean.TRUE);
            // else {
            // StackPane itemNode = new StackPane();
            // itemNode.setPrefHeight(10);
            // itemNode.setPrefWidth(1);
            // data.setNode(itemNode);
            // }
            // Update
            x1 = x2;
            y1 = y2;
        }
        if (count < chart.getData().size())
            chart.getData().set(count, series);
        else
            chart.getData().add(series);
        // Color color = colors[count % colors.length];
        for (XYChart.Data<Number, Number> data : series.getData()) {
            Node node = data.getNode();
            if (node == null)
                continue;
            if (data.getExtraValue() == Boolean.TRUE)
                ((StackPane) node).setPrefWidth(2);
            else if (data.getNode() != null)
                node.setVisible(false);
        }
        count++;
    }
    while (count < chart.getData().size()) chart.getData().remove(count);
    // Show p-values if we have 2 or 3
    Series<Number, Number> series;
    if (kmList.size() == 2) {
        LogRankResult logRankResult = LogRankTest.computeLogRankTest(kmList.get(0), kmList.get(1));
        String pValueString = "p = " + GeneralTools.formatNumber(logRankResult.getPValue(), 3);
        // series = new Series<>();
        // series.setName("Log-rank test");
        // series.setNode(null);
        // chart.getData().add(series);
        series = new Series<>();
        series.setName(pValueString);
        series.setNode(null);
        chart.getData().add(series);
    } else if (kmList.size() == 3) {
        LogRankResult logRankResult = LogRankTest.computeLogRankTest(kmList.get(0), kmList.get(1));
        // series = new Series<>();
        // series.setName("Log-rank test");
        // series.setNode(null);
        // chart.getData().add(series);
        series = new Series<>();
        series.nameProperty().bind(chart.getData().get(0).nameProperty().concat(" vs ").concat(chart.getData().get(1).nameProperty()).concat(String.format(": p = %.4f", logRankResult.getPValue())));
        series.setNode(null);
        chart.getData().add(series);
        logRankResult = LogRankTest.computeLogRankTest(kmList.get(0), kmList.get(2));
        series = new Series<>();
        series.nameProperty().bind(chart.getData().get(0).nameProperty().concat(" vs ").concat(chart.getData().get(2).nameProperty()).concat(String.format(": p = %.4f", logRankResult.getPValue())));
        series.setNode(null);
        chart.getData().add(series);
        logRankResult = LogRankTest.computeLogRankTest(kmList.get(1), kmList.get(2));
        series = new Series<>();
        series.nameProperty().bind(chart.getData().get(1).nameProperty().concat(" vs ").concat(chart.getData().get(2).nameProperty()).concat(String.format(": p = %.4f", logRankResult.getPValue())));
        series.setNode(null);
        chart.getData().add(series);
    // series = new Series<>();
    // series.nameProperty().bind(
    // chart.getData().get(0).nameProperty()
    // .concat(" vs ")
    // .concat(chart.getData().get(1).nameProperty())
    // .concat(": p = " + GeneralTools.getFormatter(3).format(logRankResult.getPValue())));
    // series.setNode(null);
    // chart.getData().add(series);
    // 
    // logRankResult = LogRankTest.computeLogRankTest(kmList.get(0), kmList.get(2));
    // series = new Series<>();
    // series.nameProperty().bind(
    // chart.getData().get(0).nameProperty()
    // .concat(" vs ")
    // .concat(chart.getData().get(2).nameProperty())
    // .concat(": p = " + GeneralTools.getFormatter(3).format(logRankResult.getPValue())));
    // series.setNode(null);
    // chart.getData().add(series);
    // 
    // logRankResult = LogRankTest.computeLogRankTest(kmList.get(1), kmList.get(2));
    // series = new Series<>();
    // series.nameProperty().bind(
    // chart.getData().get(1).nameProperty()
    // .concat(" vs ")
    // .concat(chart.getData().get(2).nameProperty())
    // .concat(": p = " + GeneralTools.getFormatter(3).format(logRankResult.getPValue())));
    // series.setNode(null);
    // chart.getData().add(series);
    }
// for (Series<Number, Number> series : chart.getData()) {
// System.out.println(series.getName());
// for (Data<Number, Number> data : series.getData()) {
// System.err.println(data);
// }
// }
}
Also used : Node(javafx.scene.Node) KaplanMeierData(qupath.lib.analysis.stats.survival.KaplanMeierData) KaplanMeierData(qupath.lib.analysis.stats.survival.KaplanMeierData) Series(javafx.scene.chart.XYChart.Series) XYChart(javafx.scene.chart.XYChart) LogRankResult(qupath.lib.analysis.stats.survival.LogRankTest.LogRankResult)

Example 5 with KaplanMeierData

use of qupath.lib.analysis.stats.survival.KaplanMeierData in project qupath by qupath.

the class KaplanMeierDisplay method splitByThresholds.

static List<KaplanMeierData> splitByThresholds(final KaplanMeierDisplay.ScoreData scoreData, final double[] thresholds, final double censorThreshold, final boolean usesQuartiles) {
    List<KaplanMeierData> kms = new ArrayList<>();
    int nThresholds = thresholds.length;
    // Ensure thresholds are sorted
    double[] sortedThresholds = thresholds.clone();
    Arrays.sort(sortedThresholds);
    for (int i = 0; i <= nThresholds; i++) {
        if (nThresholds == 0)
            kms.add(new KaplanMeierData("All"));
        else if (nThresholds == 1) {
            kms.add(new KaplanMeierData(i == 0 ? "Low" : "High"));
        } else if (nThresholds == 2 && sortedThresholds[0] < sortedThresholds[1]) {
            kms.add(new KaplanMeierData(i == 0 ? "Low" : (i == 1 ? "Moderate" : "High")));
        } else if (usesQuartiles) {
            kms.add(new KaplanMeierData("Quartile " + (i + 1)));
        } else {
            if (i == 0)
                kms.add(new KaplanMeierData(String.format("x < %.2f", sortedThresholds[i])));
            else if (i == nThresholds)
                kms.add(new KaplanMeierData(String.format("x >= %.2f", sortedThresholds[i - 1])));
            else
                kms.add(new KaplanMeierData(String.format("%.2f <= x < %.2f", sortedThresholds[i - 1], sortedThresholds[i])));
        }
    }
    for (int i = 0; i < scoreData.survival.length; i++) {
        double s = scoreData.scores[i];
        if (Double.isNaN(s))
            continue;
        double surv = scoreData.survival[i];
        if (Double.isNaN(surv))
            continue;
        int t = sortedThresholds.length;
        while (t > 0) {
            if (s >= sortedThresholds[t - 1])
                break;
            t--;
        }
        // Create an event, optionally censoring on a particular time if needed
        if (censorThreshold > 0 && surv > censorThreshold)
            kms.get(t).addEvent(censorThreshold, true);
        else
            kms.get(t).addEvent(surv, scoreData.censored[i]);
    }
    return kms;
}
Also used : ArrayList(java.util.ArrayList) KaplanMeierData(qupath.lib.analysis.stats.survival.KaplanMeierData)

Aggregations

KaplanMeierData (qupath.lib.analysis.stats.survival.KaplanMeierData)5 LogRankResult (qupath.lib.analysis.stats.survival.LogRankTest.LogRankResult)3 XYChart (javafx.scene.chart.XYChart)2 ArrayList (java.util.ArrayList)1 HashSet (java.util.HashSet)1 TreeMap (java.util.TreeMap)1 SimpleStringProperty (javafx.beans.property.SimpleStringProperty)1 ObservableNumberValue (javafx.beans.value.ObservableNumberValue)1 ObservableValue (javafx.beans.value.ObservableValue)1 Insets (javafx.geometry.Insets)1 Node (javafx.scene.Node)1 NumberAxis (javafx.scene.chart.NumberAxis)1 Data (javafx.scene.chart.XYChart.Data)1 Series (javafx.scene.chart.XYChart.Series)1 ContextMenu (javafx.scene.control.ContextMenu)1 Menu (javafx.scene.control.Menu)1 MenuItem (javafx.scene.control.MenuItem)1 RadioMenuItem (javafx.scene.control.RadioMenuItem)1 TableCell (javafx.scene.control.TableCell)1 TableColumn (javafx.scene.control.TableColumn)1