Java Graphics2D.drawImage() отображает размытое изображение только в Windows с масштабированием 125% и только в версиях Java после Java 8

Я знаю, что в Java 9 исправлены проблемы с масштабированием и разрешением экрана, которые присутствовали в Swing в Java 8. Однако у меня возникла ситуация, когда один и тот же код отображается четко при запуске на Java 8, но размыто при использовании любой версии Java 9 и после (включая самые последние версии LTS Java 21 и Java 22). Загвоздка в том, что это происходит только в Windows, если в настройках дисплея Windows установлено масштабирование 125%.

Похоже, что для того, чтобы это произошло, все условия должны соблюдаться одновременно:

• Windows настроена на использование масштабирования 125 %.
• Для запуска кода используется Java 9 или более поздняя версия JRE.
• Графика визуализируется специально с помощью метода drawImage().

Если я просто рисую линии и текст непосредственно на объекте Graphics2D (тот, который мне предоставила функция JComponentpaint(Graphics g)), то все работает нормально даже на Java 9+ с масштабированием Windows 125%. Однако если я визуализирую ту же самую графику, но использую метод drawImage(), она будет размытой.

Итак, если я запускаю свой код на Java 8 при любом из вышеперечисленных условий (масштаб Windows установлен на 100% или 125%, использование объекта Graphics напрямую или использование drawImage() не имеет значения), все отображается четко (т. е. без каких-либо тип сглаживания или дизеринга или что-то еще происходит).

Если я запускаю свой код на любой версии Java 9+ с масштабированием Windows не 125%, все отображается четко (так же, как на Java 8). Если я запускаю свой код на любой версии Java 9+ с Windows с масштабированием 125%, но напрямую использую объект Graphics (а не drawImage()), то все отображается четко. Только если я воспользуюсь методом drawImage(), дела пойдут наперекосяк.

У меня есть минимальный воспроизводимый пример:

Вот как он отображается на Java 22 с Windows при масштабировании 125 % без использования метода drawImage():

Вот как он отображается на Java 22 с Windows при масштабировании 125% с использованием метода drawImage():

Однако если я использую Java 8, то нет никакой разницы между использованием drawImage() и отсутствием drawImage().

Вот код:

public class MainWindow extends JFrame implements ActionListener {
    
    DrawPanel dp;

    public static void main(String[] args) {
        new MainWindow();
    }
    
    public MainWindow() {
        super("Graphics Test");
        setLayout(new BorderLayout());
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        
        JButton button = new JButton("Redraw");
        button.addActionListener(this);
        add(button, BorderLayout.PAGE_START);
        
        JPanel center = new JPanel(new FlowLayout());
        dp = new DrawPanel();
        center.add(dp);
        add(center, BorderLayout.CENTER);
        
        pack();
        setLocationRelativeTo(null);
        setVisible(true);       
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        dp.drawOnImage = (e.getModifiers() & ActionEvent.CTRL_MASK) == ActionEvent.CTRL_MASK;
        dp.repaint();
    }
}

И кастомный компонент. Обратите внимание, что удержание CTRL вызовет рендеринг с использованием drawImage(), тогда как без CTRL будет напрямую использоваться объект Graphics:

public class DrawPanel extends JComponent {
    
    Graphics2D gSave;
    BufferedImage bi;
    boolean drawOnImage = false;
    
    public DrawPanel() {
    }
    
    @Override
    public Dimension getPreferredSize() {
        return new Dimension(400, 400);
    }

    @Override
    public void paint(Graphics gr) {
        Graphics2D g = (Graphics2D) gr;
        gSave = g;
        
        if (drawOnImage) {
            bi = new BufferedImage(getSize().width, getSize().height, BufferedImage.TYPE_INT_ARGB);
            g = bi.createGraphics();
        }
        
        Font font = new Font("SansSerif", Font.BOLD, 36);
        g.setFont(font);
        g.setColor(Color.BLACK);
        g.drawString("Test String", 5, 40);
        g.setStroke(new BasicStroke(6.0001f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL, 0f, null, 0f));
        g.drawRect(100, 70, 100, 100);
        font = new Font("SansSerif", Font.PLAIN, 16);
        g.setFont(font);
        g.drawString("More Text to test the resolution", 5, 200);
        
        Rectangle rect2 = new Rectangle(300, 40, 100, 100);
        g.rotate(Math.toRadians(45));
        g.draw(rect2);
        
        if (drawOnImage) {
            g.dispose();
            gSave.drawImage(bi, null, 0, 0);
        }
    }
}

Итак, вопрос заключается в следующем: почему в более старой версии Java с этим не было проблем, а в более новых версиях производительность, похоже, снизилась? Есть ли что-то, что drawImage() делает по-другому, что я могу смягчить, чтобы не получить этот результат?

(И на неизбежный вопрос о том, зачем я вообще это делаю и зачем это необходимо (например, если это работает, почему бы вам просто не рисовать напрямую на объекте Graphics, а не использовать метод drawImage()?), отмечу, что фактический код, над которым я работаю, пытается рисовать полупрозрачные перекрывающиеся фигуры при перетаскивании мышью, поэтому был использован этот BufferedImage подход с использованием drawImage(). Возможно, есть другой способ сделать это, который не требует использования drawImage(), но я еще не использовал. нашел.)