Wie kann man sich ständig ändernde Grafiken in Java effizient zeichnen?

So zeichnen Sie sich ständig ändernde Grafiken in Java

Einführung

Erstellen dynamischer Grafiken, die aktualisiert werden ständig kann in Java eine herausfordernde Aufgabe sein. In diesem Artikel zeigen wir, wie man dieses Problem mithilfe effizienter Techniken und Thread-Synchronisierung lösen kann.

Problembeschreibung

Der in der Frage bereitgestellte ursprüngliche Code hatte mehrere Leistungsprobleme. Dies führt zu langsamen Grafikaktualisierungen. Ziel ist es, den Code zu optimieren, um ständige Updates mit verbesserter Geschwindigkeit zu erreichen.

Optimierter Code

Hier ist eine optimierte Version des Codes:

import javax.swing.*;
import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.geom.Ellipse2D;
import java.awt.image.BufferedImage;

public class ZoomPanel extends JPanel {

    private static final int STEP = 40;
    private int iter = 0;
    private long cumulativeTimeTaken = 0;

    // Model to hold pixel colors
    private final Color[][] model = new Color[8][8];

    // Flag to prevent concurrent painting
    private boolean isDrawing = false;

    public static void main(String[] args) {
        final JFrame frame = new JFrame("Image zoom");

        final ZoomPanel zoomPanel = new ZoomPanel();
        frame.getContentPane().add(zoomPanel);
        final Ticker t = new Ticker(zoomPanel);

        frame.addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent we) {
                t.done();
                frame.dispose();
            }
        });
        t.start();

        frame.setLocation(new Point(640, 0));
        frame.pack();
        frame.setVisible(true);
    }

    // Sets the pixel color at the given position
    private void setColorAt(int x, int y, Color pixelColor) {
        model[x][y] = pixelColor;
        repaint(40 + x * STEP, 45 + y * STEP, 40 + (x * STEP) - 3, 45 + (y * STEP) - 3);
    }

    // Gets the pixel color at the given position
    private Color getColorAt(int x, int y) {
        return model[x][y];
    }

    // Draws the graphics
    public void paintComponent(Graphics g) {
        long start = System.currentTimeMillis();

        if (!SwingUtilities.isEventDispatchThread()) {
            throw new RuntimeException("Repaint attempt is not on event dispatch thread");
        }

        // Prevent concurrent painting
        isDrawing = true;

        final Graphics2D g2 = (Graphics2D) g;
        g2.setColor(getBackground());

        try {

            for (int x = 0; x < 8; x++) {
                for (int y = 0; y < 8; y++) {
                    g2.setColor(model[x][y]);
                    Ellipse2D e = new Ellipse2D.Double(40 + x * STEP, 45 + y * STEP, STEP - 3, STEP - 3);
                    g2.fill(e);
                    g2.setColor(Color.GRAY);
                    g2.draw(e);
                }
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
        iter++;

        // Display FPS count
        g2.setColor(Color.black);
        long stop = System.currentTimeMillis();
        cumulativeTimeTaken += stop - start;
        StringBuilder sb = new StringBuilder();
        sb.append(iter)
                .append(" frames in ")
                .append((double) (cumulativeTimeTaken) / 1000)
                .append("s.");

        System.out.println(sb);

        // Allow painting again
        isDrawing = false;
    }

    private static class Ticker extends Thread {

        private final Robot robot;

        public boolean update = true;
        private final ZoomPanel view;

        public Ticker(ZoomPanel zoomPanel) {
            view = zoomPanel;
            try {
                robot = new Robot();
            } catch (AWTException e) {
                throw new RuntimeException(e);
            }
        }

        public void done() {
            update = false;
        }

        public void run() {
            int runCount = 0;
            while (update) {
                runCount++;
                if (runCount % 100 == 0) {
                    System.out.println("Ran ticker " + runCount + " times");
                }
                final Point p = MouseInfo.getPointerInfo().getLocation();

                Rectangle rect = new Rectangle(p.x - 4, p.y - 4, 8, 8);
                final BufferedImage capture = robot.createScreenCapture(rect);

                // Synchronized block to prevent concurrent access to the model
                synchronized (view) {
                    // If the panel is not drawing, update the model and repaint
                    if (!view.isDrawing) {
                        for (int x = 0; x < 8; x++) {
                            for (int y = 0; y < 8; y++) {
                                final Color pixelColor = new Color(capture.getRGB(x, y));

                                if (!pixelColor.equals(view.getColorAt(x, y))) {
                                    final int finalX = x;
                                    final int finalY = y;
                                    SwingUtilities.invokeLater(new Runnable() {
                                        public void run() {
                                            view.setColorAt(finalX, finalY, pixelColor);
                                        }
                                    });
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

Verbesserungen

• Roboter Optimierung: Die getPixelColor-Methode im Originalcode war ineffizient. Indem wir createScreenCapture verwenden, um alle 64 Pixel auf einmal abzurufen, verbessern wir die Leistung erheblich.
• Smart Clipping: Nur der geänderte Bereich wird neu gezeichnet, wodurch unnötige Aktualisierungen reduziert werden.
• Verbessertes Threading: Das Modell und die Ansicht werden im Event Dispatch Thread aktualisiert, um eine ordnungsgemäße Thread-Synchronisierung sicherzustellen und potenzielle Parallelität zu vermeiden Probleme.
• FPS-Überwachung: Ein FPS-Zähler druckt die Anzahl der Bilder, die innerhalb einer Sekunde aktualisiert werden.
• Synchronisierung: Eine Sperre verhindert gleichzeitiges Malen, Die Stabilität wird weiter verbessert.

Diese Optimierungen führen zu einer enormen Leistungsverbesserung, da die Bildschirmaktualisierungen virtuell erscheinen augenblicklich. Der FPS-Zähler liefert ein Maß für die verbesserte Geschwindigkeit.

Das obige ist der detaillierte Inhalt vonWie kann man sich ständig ändernde Grafiken in Java effizient zeichnen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!