Zeichne einen Kreis mit einem Radius und zeigt auf die Kante

Ich bin wirklich fest, wie ich das programmieren soll. Wie zeichnet man einen Kreis in Java mit einem Radius und zeigt auf die Kante?

Ich muss einen Kreis innerhalb eines JFrame mit einem Radius und Punkten um den scope zeichnen. Ich kann mathematisch berechnen, wie man die Koordinaten des Punktes um die Kante herum findet, aber ich kann nicht in der Lage sein, den Kreis zu programmieren. Ich verwende derzeit eine Ellipse2D-Methode, aber das scheint nicht zu funktionieren und gibt keinen Radius zurück, da nach meinem Verständnis der Kreis nicht vom Mittelpunkt, sondern von einer Startkoordinate mit einer Höhe und Breite gezeichnet wird.

Mein aktueller Code befindet sich in einem separaten Frame, aber ich muss ihn zu meinem bestehenden Frame hinzufügen.

import java.awt.*; import javax.swing.*; import java.awt.geom.*; public class circle extends JFrame { public circle() { super("circle"); setSize(410, 435); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); Panel sp = new Panel(); Container content = getContentPane(); content.add(sp); setContentPane(content); setVisible(true); } public static void main (String args[]){ circle sign = new circle(); } } class Panel extends JPanel { public void paintComponent(Graphics comp) { super.paintComponent(comp); Graphics2D comp2D = (Graphics2D) comp; comp2D.setColor(Color.red); Ellipse2D.Float sign1 = new Ellipse2D.Float(0F, 0F, 350F, 350F); comp2D.fill(sign1); } } 

    Punkte auf einem Kreis können als eine function des angulars θ angegeben werden:

    x = a + cos (θ)
    y = b + r sin (θ)

    Hier sind Inkremente von 2π / 8 gezeigt.

    Nachtrag: Wie in einem Kommentar von @Christoffer Hammarström vorgeschlagen, reduziert dieses überarbeitete Beispiel die Anzahl der magischen Zahlen im Original. Die gewünschte Anzahl von Punkten wird zu einem Parameter für den Konstruktor. Es passt außerdem das Rendering an die Größe des Containers an.

    Alt-Text

     /** @see https://stackoverflow.com/questions/2508704 */ public class CircleTest extends JPanel { private static final int SIZE = 256; private int a = SIZE / 2; private int b = a; private int r = 4 * SIZE / 5; private int n; /** @param n the desired number of circles. */ public CircleTest(int n) { super(true); this.setPreferredSize(new Dimension(SIZE, SIZE)); this.n = n; } @Override protected void paintComponent(Graphics g) { super.paintComponent(g); Graphics2D g2d = (Graphics2D) g; g2d.setRenderingHint( RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); g2d.setColor(Color.black); a = getWidth() / 2; b = getHeight() / 2; int m = Math.min(a, b); r = 4 * m / 5; int r2 = Math.abs(m - r) / 2; g2d.drawOval(a - r, b - r, 2 * r, 2 * r); g2d.setColor(Color.blue); for (int i = 0; i < n; i++) { double t = 2 * Math.PI * i / n; int x = (int) Math.round(a + r * Math.cos(t)); int y = (int) Math.round(b + r * Math.sin(t)); g2d.fillOval(x - r2, y - r2, 2 * r2, 2 * r2); } } private static void create() { JFrame f = new JFrame(); f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); f.add(new CircleTest(9)); f.pack(); f.setVisible(true); } public static void main(String[] args) { EventQueue.invokeLater(new Runnable() { @Override public void run() { create(); } }); } } 

    Versuchen Sie etwas wie folgt:

      public class CirclePanel extends JPanel { public static void main(String[] args) throws Exception { JFrame f = new JFrame(); f.setContentPane(new CirclePanel()); f.setSize(700,500); f.setVisible(true); } public void paint(Graphics g) { super.paint(g); //Draws the line g.drawOval(0,0,this.getWidth(), this.getHeight()); //draws filled circle g.setColor(Color.red); g.fillOval(0,0,this.getWidth(), this.getHeight()); } } 

    Du kannst auch die Paint-Methode in der Frame-class überschreiben, aber dann müsste man in der Größe der Fensterdekorationen rechnen und es wird dort dreckig …

    Verwende Minueto .

    Ich empfehle, sich etwas Zeit zu nehmen, um den “Mittelpunkt-Kreis-Algorithmus oder den Bresenham-Kreis-Algorithmus” zu überprüfen. Die akzeptierte Lösung basiert auf sehr teuren mathematischen Operationen wie Float-Multiplikation und trigonometrischen functionen.