Java: Zeichnen einer kreisförmigen Spirale mit drawArc

Arbeite ich an einem java-Programmierung, wo wir zum zeichnen einer kreisförmigen Spirale über die drawArc-Methode, so dass das Ergebnis etwa so aussieht:
Java: Zeichnen einer kreisförmigen Spirale mit drawArc

Ich habe mit diesem für eine Weile und das ist, was ich habe, so weit:

import java.awt.Graphics;
import javax.swing.JPanel;
import javax.swing.JFrame;

public class CircSpiral extends JPanel {
   public void paintComponent(Graphics g) {
      int x = 100;
      int y = 120;
      int width = 40;
      int height = 60;
      int startAngle = 20;
      int arcAngle = 80;
      for (int i = 0; i < 5; i++) {
         g.drawArc(x, y, width, height, startAngle, arcAngle);
         g.drawArc(x + 10, y + 10, width, height, startAngle + 10, arcAngle);
         x = x + 5;
         y = y + 5;
         startAngle = startAngle - 10;
         arcAngle = arcAngle + 10;
      }
   }

   public static void main(String[] args) {
      CircSpiral panel = new CircSpiral();
      JFrame application = new JFrame();
      application.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      application.add(panel);
      application.setSize(300, 300);
      application.setVisible(true);
   }
}

Mein code gibt mir dieses Ergebnis:
Java: Zeichnen einer kreisförmigen Spirale mit drawArc

Ich weiß, das problem liegt in meinen Argumenten für die drawArc-Methode, da die zahlen nicht richtig sind, aber ich weiß nicht, wie zu gehen über die zahlen gehen in einer kreisförmigen Weise. Jede Hilfe ist willkommen. Danke!

Frage bearbeitet: "Swing" - tag Hinzugefügt. Code formatiert zu verbessern Einzug und die überflüssige Leerzeilen. Original-Plakat, in Zukunft darauf zu achten und die Mühe zu post code, das ist gut formatiert. Code, der leicht zu Lesen ist code, der leichter zu verstehen ist. Vielen Dank für Ihre Kooperation in dieser.

InformationsquelleAutor user3266259 | 2015-04-14

Deine Idee ist fast richtig. Ich habe einige änderungen. Sie müssen inverse der Winkel zu zeichnen, die andere Seite der Spirale, und verwenden Sie festen Punkt zu startAngle.

import java.awt.Graphics;
import javax.swing.JPanel;
import javax.swing.JFrame;

public class CircSpiral extends JPanel {

    public void paintComponent(Graphics g) {
        int x = getSize().width / 2 - 10;
        int y = getSize().height/ 2 - 10;
        int width = 20;
        int height = 20;
        int startAngle = 0;
        int arcAngle = 180;
        int depth = 10;
        for (int i = 0; i < 10; i++) {
            if (i % 2 == 0) {
                //  g.drawArc(x + 10, y + 10, width, height, startAngle + 10, -arcAngle);
                // x = x - 5;
                y = y - depth;
                width = width + 2 * depth;
                height = height + 2 * depth;
                g.drawArc(x, y, width, height, startAngle, -arcAngle);
            } else {
                // g.drawArc(x + 10, y + 10, width, height, startAngle + 10, arcAngle);
                x = x - 2 * depth;
                y = y - depth;
                width = width + 2 * depth;
                height = height + 2 * depth;
                g.drawArc(x, y, width, height, startAngle, arcAngle);
            }
        }
    }

    public static void main(String[] args) {
        CircSpiral panel = new CircSpiral();
        JFrame application = new JFrame();
        application.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        application.add(panel);
        application.setSize(300, 300);
        application.setVisible(true);
    }
}

vielen Dank, das macht Sinn! 🙂

InformationsquelleAutor Fellipe Paes

Wenn das mein Projekt, ja, ich würde zeichnen meine Bögen in einer Schleife, aber innerhalb der Schleife ist, würde ich versuchen, den Bogen bounding box größer, aber immer noch zentriert über der gleichen Stelle. Um dies zu tun, würde ich Dekrementieren x-und y durch einige kleine Konstante, sagen DELTA (was ich eingestellt == 1), und ich würde Schrittweite Breite und Höhe von 2 * DELTA. Würd ich auch lassen mein arcAngle unverändert, sondern würde sich ändern, meine startAngle in der Schleife, etwa so: startAngle = startAngle - arcAngle;.

Beispielsweise diese:

import java.awt.Dimension;
import java.awt.Graphics;

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

@SuppressWarnings("serial")
public class CircSpiral extends JPanel {
   private static final int DELTA = 1;
   private static final int ARC_ANGLE = 20;
   private static final int PREF_W = 300;
   private static final int PREF_H = PREF_W;
   private static final int LOOP_MAX = 400;

   public void paintComponent(Graphics g) {
      int x = PREF_W / 2;
      int y = PREF_H / 2;
      int width = 1;
      int height = 1;
      int startAngle = 0;
      int arcAngle = ARC_ANGLE;
      for (int i = 0; i < LOOP_MAX; i++) {
         g.drawArc(x, y, width, height, startAngle, arcAngle);
         x = x - DELTA;
         y = y - DELTA;
         width += 2 * DELTA;
         height += 2 * DELTA;
         startAngle = startAngle - arcAngle;
      }
   }

   @Override
   public Dimension getPreferredSize() {
      if (isPreferredSizeSet()) {
         return super.getPreferredSize();
      }
      return new Dimension(PREF_W, PREF_H);
   }

   public static void main(String[] args) {
      CircSpiral panel = new CircSpiral();
      JFrame application = new JFrame();
      application.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      application.add(panel);
      application.pack();
      application.setLocationRelativeTo(null);
      application.setVisible(true);
   }
}

Würde zu diesem Ergebnis führen:

Java: Zeichnen einer kreisförmigen Spirale mit drawArc

InformationsquelleAutor Hovercraft Full Of Eels

Dem folgenden code wird die Ausgabe dieses Bild:

Java: Zeichnen einer kreisförmigen Spirale mit drawArc

import java.awt.Graphics;
import javax.swing.JPanel;
import javax.swing.JFrame;

public class CircSpiral extends JPanel {
    public void paintComponent(Graphics g) {
        int centerX = getWidth() / 2;
        int centerY = getHeight() / 2;

        int numIterations = 5;

        int arcWidth = 10;
        int arcGrowDelta = 30;

        for (int i = 0; i < numIterations; i++) {
            g.drawArc(centerX - arcWidth, centerY - arcWidth, 2 * arcWidth, 2 * arcWidth, 0, 180);
            arcWidth += arcGrowDelta;
            g.drawArc(centerX - arcWidth, centerY - arcWidth, 2 * arcWidth - arcGrowDelta, 2 * arcWidth, 180, 180);
        }
    }

    public static void main(String[] args) {
        CircSpiral panel = new CircSpiral();
        JFrame application = new JFrame();
        application.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        application.add(panel);
        application.setSize(300, 300);
        application.setVisible(true);
    }
}

Die Idee ist sehr einfach, ziehen Sie einfach die Obere Hälfte eines Kreises, etwa so:

Java: Zeichnen einer kreisförmigen Spirale mit drawArc

Dann erhöht sich der Bogen der Größe um einen Konstanten Faktor, und zeichnen Sie die untere Hälfte des Kreises, sondern dass der Endpunkt dieses Kreises und dem oberen Kreis passen, für ihn, nur Substrat der arcGrowDelta aus den unteren Kreis Breite:

Java: Zeichnen einer kreisförmigen Spirale mit drawArc

Wiederholt werden.

InformationsquelleAutor higuaro

Dies ist meine Lösung:

package mainpack;

import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;

import javax.swing.JPanel;

public class SpiralPanel extends JPanel {

    private static final long serialVersionUID = 1L;

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

        Graphics2D g2d = (Graphics2D)g;

        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                RenderingHints.VALUE_ANTIALIAS_ON);

        g2d.setRenderingHint(RenderingHints.KEY_RENDERING,
                RenderingHints.VALUE_RENDER_QUALITY);

        int width = 10;
        int height = 10;
        int startAngle = 0;
        int arcAngle = 180;
        int x = (getWidth() - width) / 2;
        int y = (getHeight() - height) / 2;

        int i = 0;
        int t = 0;

        while (i < 36) {

            g2d.drawArc(x + t, y, width, height, startAngle, arcAngle);

            if (i % 2 == 0) {
                t -= 10;
            }
            y -= 5;
            width += 10;
            height += 10;
            startAngle += 180;

            i++;
        }
    }
}

InformationsquelleAutor tunidevone

Ich bin ein Anfänger mit java und schaffte es schließlich, wie die Spirale.

Hier ist mein code:

int lineLength = 20; //starting line length
int x = getWidth() / 2; //start drawing from center of JPanel
int y = getHeight() / 2; //start drawing from center of JPanel
for( int counter = 0; counter < 10; counter++ )
{
    g.drawArc( x, y, lineLength, lineLength, 0, 180 ); //draws top semicircle of equal width and height
    lineLength += 20; //increases arc diameter
    x -= 20; //moves x coordinate left

    g.drawArc( x, y - 10, lineLength, lineLength, 0, -180 ); //draws bottom semicircle; 'y - 10' joins the 2 semicircles
    lineLength += 20; //increases arc diameter
    y -= 20; //moves y coordinate up
}

InformationsquelleAutor ShakeNBlake96

Wenn Sie bereit sind, lassen Sie uns einige der guten alten Trigonometrie die Arbeit zu tun, könnten Sie es so:

import java.awt. *;
import javax.swing. *;
import java.math.*;

public class Spiral extends JFrame {

public Spiral()
{
    //Set Window
    setTitle("Spirale");
    setSize(1500, 1500);
    setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    setVisible(true);
}

public void paint(Graphics g)
{
    super.paint(g);
    for(double i = 1; i < 50000; i++)
    {
        int locY = 600 - (int) (Math.cos((Math.PI*i)/1800)*i/50);
        int locX = 600 - (int) (Math.sin((Math.PI*i)/1800)*i/50);
        g.drawLine(locX, locY, locX, locY);
    }
}

public static void main(String[] args) {
    new Spiral();
}

}

InformationsquelleAutor Michael Keller

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.