How can/should one change the x-axis when plotting a continuous stream of data?

[hmf]

This is related to question #68. I am able to update the data at a rate of 1Hx and this works well. I then tried to change the time stamp of the XYPane<CharItem> (not just the "y" value) by changing the time-stamp of the ArrayList[TYChartItem] contained in the XYSeries. This does not seem to work - either no lines are shown or only part of the samples are shown (suspect the latter is my bug).

My question is: can I change the time-stamp for a fixed length x-axis or even change the XYSeries length continuously? A look at the code in XYChart ans see:

private              ObservableList<Axis>      axis;
private              EvtObserver<ChartEvt>     axisObserver;

so I assume changes to the axis will regenerate the plot. However, I see no method to access the private axis member to cause this update.

Using version 17.1.2

TIA

[HanSolo]

Hi there, it would be great if you could provide a code snippet that shows the problem so that I can reproduce it.

[hmf]

I wrote this in Scala. I will code this in Java and post it here. Sorry about that.

[HanSolo]

No worries...you could also simply create a gist that contains the code and link it here...

[hmf]

@HanSolo Apologies for taking so long, but I simply did not have time and my Java is also quite rusty. I have created an example based on your TimeAxisTest.java example. I have uploaded TimeAxisTest.java.txt

I this example I have split the time into 24 hour sections with a sampling rate of 1 minute (noOfValues). The idea is that every second 12 hour data is updated at the same rate (size).

    final int noOfValues = 24 * 60;
    final int size       = 12 * 60;
    ArrayList<TYChartItem> tyData1   = new ArrayList<TYChartItem>(noOfValues); 

Every second I generate an additional 12 hours worth of samples so:

    public Thread generateData() { 

        Thread t = new Thread( () -> {
            try {
                while (true){
                    Thread.sleep(1000);
                    LocalDateTime start = tyData1.get(noOfValues-1).getT();
                    ArrayList<Tuple<LocalDateTime,Double>> data = new ArrayList<Tuple<LocalDateTime,Double>>();
                    for (int i = 0; i < size; i++){
                        double y = rnd.nextDouble() * 12 + rnd.nextDouble() * 6;
                        LocalDateTime x = start.plusMinutes(i);
                        Tuple<LocalDateTime, Double> d = new Tuple<LocalDateTime, Double>(x,y);
                        data.add(d);
                    }
                    addData(data); 
                }
            } 
            catch (Exception e) {
               System.out.println("generateData: " + e);
               e.printStackTrace();
               System.exit(-1);
            }
        }
        );
        return t;
    }

As per the previous discussion I shift the last half (12 hours) of the day to the first part of the data (tyData1) and then add the new 12 hours generated data (newData) to the end of the time-series data (tyData1). This is done in the following function:

    public void addData(final ArrayList<Tuple<LocalDateTime,Double>> newData) { 

Here is the shift:

        LocalDateTime start  = tyData1.get(size).getT(); 
        LocalDateTime middle = tyData1.get(noOfValues-1).getT(); 
        System.out.println("addData (1)  : Start           = " + start);
        System.out.println("addData (2)  : Middle          = " + middle);
        // Shift
        for (int i = 0; i < noOfValues - size; i++) {
            LocalDateTime x = tyData1.get(i+size).getT(); 
            Double y = tyData1.get(i+size).getY();
            TYChartItem item = new TYChartItem( 
                                        x, y,
                                        "P" + i, 
                                        COLORS[ RND.nextInt(3) ]
                                    );
            tyData1.set(i, item);
        }

and here is the addition of the latest 12 hour samples:

        // Add
        LocalDateTime middle2 = LocalDateTime.of(1970, Month.JANUARY, 1, 0,0,0);
        LocalDateTime end = LocalDateTime.of(1970, Month.JANUARY, 1, 0,0,0);
        Iterator<Tuple<LocalDateTime, Double>> iter = newData.iterator();
        for (int i = noOfValues - size; i < noOfValues; i++){
            Tuple<LocalDateTime, Double> record = iter.next();
            LocalDateTime x = record.x; 
            Double y = record.y;
            TYChartItem item = new TYChartItem( x, y, "P" + i, COLORS[RND.nextInt(3)] );
            // println(i)
            tyData1.set(i, item);
            if (i == (noOfValues - size)) 
                middle2 = record.x;
            if (i == noOfValues-1) 
                end = record.x;
        }

And finally I update the plot's XYSeries:

        tySeries1 = new XYSeries(tyData1, ChartType.LINE, Color.RED, Color.rgb(255, 0, 0, 0.5));
        tySeries1.setSymbolsVisible(false);
    
        // Update observable to force redraw
        List<XYSeries<TYChartItem>> series = tyPane.getListOfSeries();
        series.set(0, tySeries1);

I have tried to make sure that the time-stamps are correct. A printout of the sequence is as follows:

addData (1)  : Start           = 2022-01-31T20:06:13.131185
addData (2)  : Middle          = 2022-02-01T08:05:13.131185
addData (3)  : Middle          = 2022-02-01T08:05:13.131185
addData (4)  : End             = 2022-02-01T20:04:13.131185
addData (5)  : start - middle  = PT11H59M
addData (5)  : middle - end    = PT11H59M
addData (1)  : Start           = 2022-02-01T08:05:13.131185
addData (2)  : Middle          = 2022-02-01T20:04:13.131185
addData (3)  : Middle          = 2022-02-01T20:04:13.131185
addData (4)  : End             = 2022-02-02T08:03:13.131185
addData (5)  : start - middle  = PT11H59M
addData (5)  : middle - end    = PT11H59M
addData (1)  : Start           = 2022-02-01T20:04:13.131185
addData (2)  : Middle          = 2022-02-02T08:03:13.131185
addData (3)  : Middle          = 2022-02-02T08:03:13.131185
addData (4)  : End             = 2022-02-02T20:02:13.131185
addData (5)  : start - middle  = PT11H59M
addData (5)  : middle - end    = PT11H59M

That seems to be correct (save for a duplicate middle sample), but I think it should suffice to continually show the data. However, no data appears because the X-Axis is create once and this set-up requires the START and END parameters.

    private Axis createBottomTimeAxis(final LocalDateTime START, final LocalDateTime END, final String PATTERN, final boolean AUTO_SCALE) {
        Axis axis = new Axis(START, END, Orientation.HORIZONTAL, Position.BOTTOM);
        axis.setDateTimeFormatPattern(PATTERN);
        axis.setPrefHeight(AXIS_WIDTH);

        AnchorPane.setBottomAnchor(axis, 0d);
        AnchorPane.setLeftAnchor(axis, 25d);
        AnchorPane.setRightAnchor(axis, 25d);

        return axis;
    }

So my question is: how should we update the X-axis in this case? Note that if I use the same time-stamps the data is updated correctly every second.

For completeness and to allow anyone to experiment I have also upload the Tuple.java.txt source.

TIA