Java : How to visualize/plot time intervals

Question

我有一个具有以下结构的表:

[间隔名称、开始时间、结束时间]

我想在带有时间轴的图上可视化这些时间间隔，Some thing like this但显然漂亮得多。有没有免费的java库可以做到这一点？关于如何自己可视化它有什么想法吗？

非常感谢大家:)

Answer 1

我认为使用 Java Swing 从头开始​​创建时间线图会很有趣。

这是我想出的 GUI。您可能需要右键单击图像并选择“在新选项卡中打开链接”才能清楚地查看详细信息。

我做的第一件事是创建一个 Event 类。我使用 LocalDateTime 字段来保存事件开始和事件结束。

我在 Event 类构造函数中添加了一个 Color 字段，以便可以用不同的颜色绘制绘图上的事件。在上面的示例中，我使用蓝色表示个人时间，使用黑色表示工作时间。

接下来，我创建了一个 TimeLine 类来保存事件的 List。

然后我在主 TimeLinePlot 类的构造函数中创建了一个时间线。

最后，我创建了一个 JFrame 和一个绘图 JPanel。我在绘图 JPanel 上绘制了时间线图。

此代码并不意味着是一个完整的解决方案。此代码旨在向 OP 和其他人展示如何创建时间线图。

import java.awt.BasicStroke;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.time.Duration;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.List;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;

public class TimeLinePlot implements Runnable {

    public static void main(String[] args) {
        SwingUtilities.invokeLater(new TimeLinePlot());
    }

    private final int plotWidth;
    private final int plotHeight;
    private final int margin;

    private int increment;

    private final String[] xAxis;

    private final TimeLine timeLine;

    public TimeLinePlot() {
        this.plotWidth = 1000;
        this.plotHeight = 500;
        this.margin = 50;
        this.timeLine = generateTimeLine();
        this.xAxis = createXAxis();
    }

    private TimeLine generateTimeLine() {
        TimeLine timeLine = new TimeLine();

        Event event = new Event("Breakfast", Color.BLUE,
                "5/29/2020 7:00AM", "5/29/2020 8:00AM");
        timeLine.addEvent(event);

        event = new Event("Shower", Color.BLUE,
                "5/29/2020 8:00AM", "5/29/2020 8:30AM");
        timeLine.addEvent(event);

        event = new Event("Stack Overflow", Color.BLACK,
                "5/29/2020 8:30AM", "5/29/2020 11:45AM");
        timeLine.addEvent(event);

        event = new Event("Lunch", Color.BLUE,
                "5/29/2020 11:30AM", "5/29/2020 12:30PM");
        timeLine.addEvent(event);

        event = new Event("Stack Overflow", Color.BLACK,
                "5/29/2020 12:00PM", "5/29/2020 4:30PM");
        timeLine.addEvent(event);

        return timeLine;
    }

    private String[] createXAxis() {
        LocalDateTime startDateTime =
                timeLine.getEarliestStartDate();
        LocalDateTime endDateTime =
                timeLine.getLatestEndDate();
        Duration duration = Duration.between(
                startDateTime, endDateTime);
//      System.out.println(duration);

        if (duration.toDays() > 0L) {
            // TODO Figure out a multi-day timeline
            return new String[0];
        } else {
            long minutes = duration.toMinutes();
            int hours = (int) Math.ceil(minutes / 60D);
//          System.out.println(hours);

            increment = 1;
            if (hours > 12) {
                increment = 2;
                hours /= 2;
            }

            String[] axis = new String[hours + 1];
            LocalDateTime dateTime = startDateTime;
            for (int i = 0; i <= hours; i += increment) {
                axis[i] = createTimeLabel(dateTime);
                dateTime = dateTime.plusHours(increment);
            }

//          System.out.println(Arrays.asList(axis));
            return axis;
        }
    }

    private String createTimeLabel(LocalDateTime dateTime) {
        return dateTime.format(
                DateTimeFormatter.ofPattern("h:mm a"));
    }

    @Override
    public void run() {
        JFrame frame = new JFrame("Time Line Plot");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        TimeLinePanel timeLinePanel = new TimeLinePanel(
                plotWidth, plotHeight, margin, timeLine,
                increment, xAxis);
        frame.add(timeLinePanel, BorderLayout.CENTER);

        frame.pack();
        frame.setLocationByPlatform(true);
        frame.setVisible(true);
    }

    public class TimeLinePanel extends JPanel {

        private static final long serialVersionUID = 1L;

        private final int plotWidth;
        private final int plotHeight;
        private final int margin;
        private final int tickLength;
        private final int increment;

        private final String[] xAxis;

        private final TimeLine timeLine;

        public TimeLinePanel(int plotWidth, int plotHeight,
                int margin, TimeLine timeLine, int increment,
                String[] xAxis) {
            this.plotWidth = plotWidth;
            this.plotHeight = plotHeight;
            this.margin = margin;
            this.tickLength = 20;
            this.increment = increment;
            this.timeLine = timeLine;
            this.xAxis = xAxis;
            this.setPreferredSize(new Dimension(
                    plotWidth, plotHeight));
        }

        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);

            Graphics2D g2d = (Graphics2D) g;
            g2d.setColor(Color.WHITE);
            g2d.fillRect(0, 0, getWidth(), getHeight());

            g2d.setFont(getFont().deriveFont(14f)
                    .deriveFont(Font.BOLD));
            createXAxis(g2d);
            createTimeLines(g2d);
        }

        private void createXAxis(Graphics2D g2d) {
            int height = plotHeight - margin;
            int width = plotWidth - margin * 4;
            int pixelGap = width / (xAxis.length - 1);

            int x = margin + margin;
            int x1 = x;
            int y = height - tickLength - 10;

            g2d.setColor(Color.BLACK);
            g2d.setStroke(new BasicStroke(3f));
            FontMetrics metrics = g2d.getFontMetrics(getFont());
            for (int i = 0; i < xAxis.length; i++) {
                g2d.drawLine(x, y, x, y + tickLength);

                int a = x - metrics.stringWidth(xAxis[i]) / 2;
                int b = y + tickLength + metrics.getHeight() / 2 +
                        metrics.getAscent();
                g2d.drawString(xAxis[i], a, b);
                x += pixelGap;
            }
            g2d.drawLine(x1, y, x - pixelGap, y);
        }

        private void createTimeLines(Graphics2D g2d) {
            LocalDateTime earliestStartTime =
                    timeLine.getEarliestStartDate();
            List<Event> events = timeLine.getEvents();

            int height = plotHeight - margin;
            int width = plotWidth - margin * 4;
            int pixelGapH = height / events.size();
            int pixelGapW = width / (xAxis.length - 1);

            int x = margin + margin;
            int y = height - tickLength - 30;

            g2d.setStroke(new BasicStroke(9f));
            FontMetrics metrics = g2d.getFontMetrics(getFont());
            for (int i = events.size() - 1; i >= 0; i--) {
                Event event = events.get(i);
                LocalDateTime startTime = event.getStartTime();
                LocalDateTime endTime = event.getEndTime();

                Duration duration1 = Duration.between(
                        earliestStartTime, startTime);
                Duration duration2 = Duration.between(
                        earliestStartTime, endTime);
                long minutes1 = duration1.toMinutes();
                long minutes2 = duration2.toMinutes();
                String text = event.getName();

                int a1 = x + (int) (Math.round((double) minutes1 *
                        pixelGapW * increment / 60D));
                int a2 = x + (int) (Math.round((double) minutes2 *
                        pixelGapW * increment / 60D));
                int a = a1 + ((a2 - a1) / 2) -
                        (metrics.stringWidth(text) / 2) - 4;
                int b = y - 8;

                g2d.setColor(event.getColor());
                g2d.drawLine(a1, y, a2, y);
                g2d.drawString(text, a, b);

                y -= pixelGapH;
            }

        }

    }

    public class TimeLine {

        private List<Event> events;

        public TimeLine() {
            this.events = new ArrayList<>();
        }

        public void addEvent(Event event) {
            this.events.add(event);
        }

        public List<Event> getEvents() {
            return events;
        }

        public LocalDateTime getEarliestStartDate() {
            LocalDateTime minimumStartDateTime = null;

            for (Event event : events) {
                if (minimumStartDateTime == null ||
                        event.getStartTime().compareTo(
                                minimumStartDateTime) < 0) {
                    minimumStartDateTime = event.getStartTime();
                }
            }

            return minimumStartDateTime;
        }

        public LocalDateTime getLatestEndDate() {
            LocalDateTime maximumEndDateTime = null;

            for (Event event : events) {
                if (maximumEndDateTime == null ||
                        event.getEndTime().compareTo(
                                maximumEndDateTime) > 0) {
                    maximumEndDateTime = event.getEndTime();
                }
            }

            return maximumEndDateTime;
        }

    }

    public class Event {

        private final DateTimeFormatter formatter =
                DateTimeFormatter.ofPattern("M/d/yyyy h:mma");

        private Color color;

        private final String name;

        private final LocalDateTime startTime;
        private final LocalDateTime endTime;

        public Event(String name, Color color, String startTimeString,
                String endTimeString) {
            this.name = name;
            this.color = color;
            this.startTime = LocalDateTime.parse(startTimeString,
                    formatter);
            this.endTime = LocalDateTime.parse(endTimeString,
                    formatter);
        }

        public String getName() {
            return name;
        }

        public Color getColor() {
            return color;
        }

        public LocalDateTime getStartTime() {
            return startTime;
        }

        public LocalDateTime getEndTime() {
            return endTime;
        }

    }

}