Overhauled dataset styling

chartfx-chart/pom.xml

@@ -95,6 +95,11 @@
             <artifactId>pngj</artifactId>
             <version>2.1.0</version>
         </dependency>
+        <dependency>
+            <groupId>org.hdrhistogram</groupId>
+            <artifactId>HdrHistogram</artifactId>
+            <version>2.1.12</version>
+        </dependency>
     </dependencies>
 
     <build>

chartfx-chart/src/main/java/io/fair_acc/chartfx/XYChart.java

@@ -1,13 +1,13 @@
 package io.fair_acc.chartfx;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Optional;
-import java.util.stream.Collectors;
-
 import io.fair_acc.chartfx.axes.spi.AxisRange;
+import io.fair_acc.chartfx.plugins.ChartPlugin;
+import io.fair_acc.chartfx.renderer.spi.ErrorDataSetRenderer;
+import io.fair_acc.chartfx.ui.css.DataSetNode;
 import io.fair_acc.chartfx.utils.PropUtil;
+import io.fair_acc.dataset.benchmark.MeasurementRecorder;
 import io.fair_acc.dataset.events.ChartBits;
+import io.fair_acc.dataset.benchmark.DurationMeasure;
 import javafx.beans.property.BooleanProperty;
 import javafx.beans.property.ObjectProperty;
 import javafx.beans.property.SimpleBooleanProperty;
@@ -18,13 +18,9 @@
 import javafx.geometry.Orientation;
 import javafx.scene.canvas.GraphicsContext;
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import io.fair_acc.chartfx.axes.Axis;
 import io.fair_acc.chartfx.renderer.PolarTickStep;
 import io.fair_acc.chartfx.renderer.Renderer;
-import io.fair_acc.chartfx.renderer.spi.ErrorDataSetRenderer;
 import io.fair_acc.chartfx.renderer.spi.GridRenderer;
 import io.fair_acc.chartfx.renderer.spi.LabelledMarkerRenderer;
 import io.fair_acc.chartfx.ui.geometry.Side;
@@ -44,15 +40,13 @@
  * @author rstein
  */
 public class XYChart extends Chart {
-    private static final Logger LOGGER = LoggerFactory.getLogger(XYChart.class);
     protected static final int BURST_LIMIT_MS = 15;
     protected final BooleanProperty polarPlot = new SimpleBooleanProperty(this, "polarPlot", false);
     private final ObjectProperty<PolarTickStep> polarStepSize = new SimpleObjectProperty<>(PolarTickStep.THIRTY);
-    private final GridRenderer gridRenderer = new GridRenderer();
+    private final GridRenderer gridRenderer = new GridRenderer(this);
 
     /**
      * Construct a new XYChart with the given axes.
-     *
      */
     public XYChart() {
         this(new Axis[] {}); // NOPMD NOSONAR
@@ -94,12 +88,22 @@ public XYChart(final Axis... axes) {
                 gridRenderer.getVerticalMinorGrid().changeCounterProperty(),
                 gridRenderer.drawOnTopProperty());
 
-        this.setAnimated(false);
         getRenderers().addListener(this::rendererChanged);
 
+        // TODO: get rid of default instance. It's created if anyone wants to use getDatasets()
         getRenderers().add(new ErrorDataSetRenderer());
     }
 
+    /**
+     * @return datasets of the first renderer. Creates a renderer if needed.
+     */
+    public ObservableList<DataSet> getDatasets() {
+        if (getRenderers().isEmpty()) {
+            getRenderers().add(new ErrorDataSetRenderer());
+        }
+        return getRenderers().get(0).getDatasets();
+    }
+
     /**
      * @return datasets attached to the chart and datasets attached to all renderers
      */
@@ -110,14 +114,12 @@ public ObservableList<DataSet> getAllDatasets() {
         }
 
         allDataSets.clear();
-        allDataSets.addAll(getDatasets());
         for (Renderer renderer : getRenderers()) {
-            if(renderer instanceof LabelledMarkerRenderer){
+            if (renderer instanceof LabelledMarkerRenderer) {
                 continue;
             }
             allDataSets.addAll(renderer.getDatasets());
         }
-
         return allDataSets;
     }
 
@@ -127,7 +129,6 @@ public ObservableList<DataSet> getAllDatasets() {
      */
     public ObservableList<DataSet> getAllShownDatasets() {
         final ObservableList<DataSet> ret = FXCollections.observableArrayList();
-        ret.addAll(getDatasets());
         getRenderers().stream().filter(Renderer::showInLegend).forEach(renderer -> ret.addAll(renderer.getDatasets()));
         return ret;
     }
@@ -200,28 +201,49 @@ public void setPolarStepSize(final PolarTickStep step) {
 
     @Override
     public void updateAxisRange() {
-        if (isDataEmpty()) {
-            return;
-        }
-
-        // Check that all registered data sets have proper ranges defined. The datasets
-        // are already locked, so we can use parallel stream without extra synchronization.
-        getAllDatasets().stream()
-                .filter(DataSet::isVisible)
-                .filter(ds -> ds.getBitState().isDirty())
+        // Update the axis definitions of all datasets. We do it here, so we can make better
+        // use of multi-threading. The datasets are already locked, so we can use a parallel
+        // stream without extra synchronization.
+        getRenderers().stream()
+                .flatMap(renderer -> renderer.getDatasetNodes().stream())
+                .filter(DataSetNode::isVisible)
+                .map(DataSetNode::getDataSet)
+                .filter(ds -> ds.getBitState().isDirty(ChartBits.DataSetData, ChartBits.DataSetRange))
+                .distinct()
                 .forEach(dataset -> dataset.getAxisDescriptions().parallelStream()
                         .filter(axisD -> !axisD.isDefined() || axisD.getBitState().isDirty())
                         .forEach(axisDescription -> dataset.recomputeLimits(axisDescription.getDimIndex())));
 
-        // Update each of the axes
-        getAxes().forEach(chartAxis -> updateNumericAxis(chartAxis, getDataSetForAxis(chartAxis)));
+        // Update each axis
+        for (Axis axis : getAxes()) {
 
-    }
+            // Determine the current range
+            axisRange.clear();
+            for (Renderer renderer : getRenderers()) {
+                renderer.updateAxisRange(axis, axisRange);
+            }
+
+            // Update the internal auto range
+            boolean changed = false;
+            if (axis.isAutoGrowRanging() && axis.getAutoRange().isDefined()) {
+                if (axisRange.isDefined()) {
+                    changed = axis.getAutoRange().add(axisRange);
+                }
+            } else {
+                changed = axis.getAutoRange().set(axisRange.getMin(), axisRange.getMax());
+            }
+
+            // Trigger a redraw
+            if (changed && (axis.isAutoRanging() || axis.isAutoGrowRanging())) {
+                axis.invalidateRange();
+            }
+
+        }
 
-    private boolean isDataEmpty() {
-        return getAllDatasets() == null || getAllDatasets().isEmpty();
     }
 
+    private final AxisRange axisRange = new AxisRange();
+
     /**
      * add XYChart specific axis handling (ie. placement around charts, add new DefaultNumericAxis if one is missing,
      * etc.)
@@ -246,128 +268,78 @@ protected void axesChanged(final ListChangeListener.Change<? extends Axis> chang
         invalidate();
     }
 
-    /**
-     * checks whether renderer has required x and y axes and adds the first x or y from the chart itself if necessary
-     * <p>
-     * additionally moves axis from Renderer with defined Side that are not yet in the Chart also to the chart's list
-     *
-     * @param renderer to be checked
-     */
-    protected void checkRendererForRequiredAxes(final Renderer renderer) {
-        if (renderer.getAxes().size() < 2) {
-            // not enough axes present in renderer
-            Optional<Axis> xAxis = renderer.getAxes().stream().filter(a -> a.getSide().isHorizontal()).findFirst();
-            Optional<Axis> yAxis = renderer.getAxes().stream().filter(a -> a.getSide().isVertical()).findFirst();
-
-            // search for horizontal/vertical axes in Chart (which creates one if missing) and add to renderer
-            if (xAxis.isEmpty()) {
-                renderer.getAxes().add(getFirstAxis(Orientation.HORIZONTAL));
-            }
-            if (yAxis.isEmpty()) {
-                // search for horizontal axis in Chart (which creates one if missing) and add to renderer
-                renderer.getAxes().add(getFirstAxis(Orientation.VERTICAL));
-            }
-        }
-        // check if there are assignable axes not yet present in the Chart's list
-        getAxes().addAll(renderer.getAxes().stream().limit(2).filter(a -> (a.getSide() != null && !getAxes().contains(a))).collect(Collectors.toList()));
-    }
-
-    protected List<DataSet> getDataSetForAxis(final Axis axis) {
-        final List<DataSet> retVal = new ArrayList<>();
-        if (axis == null) {
-            return retVal;
-        }
-        retVal.addAll(getDatasets());
-        getRenderers().forEach(renderer -> renderer.getAxes().stream().filter(axis::equals).forEach(rendererAxis -> retVal.addAll(renderer.getDatasets())));
-        return retVal;
-    }
-
-    @Override
-    protected void runPreLayout() {
-        for (Renderer renderer : getRenderers()) {
-            // check for and add required axes
-            checkRendererForRequiredAxes(renderer);
-        }
-        super.runPreLayout();
-    }
-
     @Override
     protected void redrawCanvas() {
-        if (DEBUG && LOGGER.isDebugEnabled()) {
-            LOGGER.debug("   xychart redrawCanvas() - pre");
-        }
         FXUtils.assertJavaFxThread();
-        final long now = System.nanoTime();
-        if (DEBUG && LOGGER.isDebugEnabled()) {
-            LOGGER.debug("   xychart redrawCanvas() - executing");
-            LOGGER.debug("   xychart redrawCanvas() - canvas size = {}", String.format("%fx%f", canvas.getWidth(), canvas.getHeight()));
-        }
 
         final GraphicsContext gc = canvas.getGraphicsContext2D();
         gc.clearRect(0, 0, canvas.getWidth(), canvas.getHeight());
 
         // Bottom grid
         if (!gridRenderer.isDrawOnTop()) {
-            gridRenderer.render(gc, this, 0, null);
+            benchDrawGrid.start();
+            gridRenderer.render();
+            benchDrawGrid.stop();
         }
 
         // Data
-        int dataSetOffset = 0;
+        benchDrawData.start();
         for (final Renderer renderer : getRenderers()) {
-            final List<DataSet> drawnDataSets = renderer.render(gc, this, dataSetOffset, getDatasets());
-            dataSetOffset += drawnDataSets == null ? 0 : drawnDataSets.size();
+            renderer.render();
         }
+        benchDrawData.stop();
 
         // Top grid
         if (gridRenderer.isDrawOnTop()) {
-            gridRenderer.render(gc, this, 0, null);
+            benchDrawGrid.start();
+            gridRenderer.render();
+            benchDrawGrid.stop();
         }
 
-        if (DEBUG && LOGGER.isDebugEnabled()) {
-            LOGGER.debug("   xychart redrawCanvas() - done");
-        }
     }
 
-    protected static void updateNumericAxis(final Axis axis, final List<DataSet> dataSets) {
-        if (dataSets == null || dataSets.isEmpty()) {
-            return;
-        }
-
-        final Side side = axis.getSide();
-        final boolean isHorizontal = side.isHorizontal();
-
-        // Determine the range of all datasets for this axis
-        final AxisRange dsRange = new AxisRange();
-        dsRange.clear();
-        dataSets.stream().filter(DataSet::isVisible).forEach(dataset -> {
-            if (dataset.getDimension() > 2 && (side == Side.RIGHT || side == Side.TOP)) {
-                if (!dataset.getAxisDescription(DataSet.DIM_Z).isDefined()) {
-                    dataset.recomputeLimits(DataSet.DIM_Z);
-                }
-                dsRange.add(dataset.getAxisDescription(DataSet.DIM_Z).getMin());
-                dsRange.add(dataset.getAxisDescription(DataSet.DIM_Z).getMax());
+    /**
+     * @param recorder recorder for this chart and all nested components
+     */
+    public void setGlobalRecorder(MeasurementRecorder recorder) {
+        setRecorder(recorder);
+        int i = 0;
+        for (Axis axis : getAxes()) {
+            if (axis == getXAxis()) {
+                axis.setRecorder(recorder.addPrefix("x"));
+            } else if (axis == getYAxis()) {
+                axis.setRecorder(recorder.addPrefix("y"));
             } else {
-                final int nDim = isHorizontal ? DataSet.DIM_X : DataSet.DIM_Y;
-                if (!dataset.getAxisDescription(nDim).isDefined()) {
-                    dataset.recomputeLimits(nDim);
-                }
-                dsRange.add(dataset.getAxisDescription(nDim).getMin());
-                dsRange.add(dataset.getAxisDescription(nDim).getMax());
+                axis.setRecorder(recorder.addPrefix("axis" + i++));
             }
-        });
-
-        // Update the auto range
-        final boolean changed;
-        if (axis.isAutoGrowRanging() && axis.getAutoRange().isDefined()) {
-            changed = axis.getAutoRange().add(dsRange);
-        } else {
-            changed = axis.getAutoRange().set(dsRange.getMin(), dsRange.getMax());
         }
-
-        // Trigger a redraw
-        if (changed && (axis.isAutoRanging() || axis.isAutoGrowRanging())) {
-            axis.invalidateRange();
+        i = 0;
+        gridRenderer.setRecorder(recorder);
+        for (var renderer : getRenderers()) {
+            var p = recorder.addPrefix("renderer" + i);
+            renderer.setRecorder(p);
+            int dsIx = 0;
+            for (var dataset : renderer.getDatasets()) {
+                dataset.setRecorder(p.addPrefix("ds" + dsIx));
+                dataset.lock().setRecorder(p.addPrefix("ds" + dsIx));
+                dsIx++;
+            }
+            i++;
         }
+        i = 0;
+        for (ChartPlugin plugin : getPlugins()) {
+            plugin.setRecorder(recorder.addPrefix("plugin" + i++));
+        }
+    }
 
+    @Override
+    public void setRecorder(MeasurementRecorder recorder) {
+        super.setRecorder(recorder);
+        benchDrawGrid = recorder.newDebugDuration("xychart-drawGrid");
+        benchDrawData = recorder.newDebugDuration("xychart-drawData");
     }
+
+    private DurationMeasure benchDrawGrid = DurationMeasure.DISABLED;
+    private DurationMeasure benchDrawData = DurationMeasure.DISABLED;
+
 }