Zeichnung einen schönen Kreis in Java

Ich bin mit Java-Grafik und ich bekomme den "falschen" Kreisen.

Hier ist, was mein Java-Programm macht
Zeichnung einen schönen Kreis in Java

Und hier ist die gleiche Sache in Matlab Zeichnung einen schönen Kreis in Java

Ich denke, es ist klar, dass die Java one ist nicht so "schön" aussieht, als die Matlab-eine, besonders auf den Kanten des Kreises. Beachten Sie, dass dies hat nichts zu tun mit der Auflösung...diese Bilder sind praktisch die gleiche Größe. Beachten Sie auch, dass ich bereits die Einstellung rendering-hints.

Hier ist ein stand-alone mit einer Main-Funktion, die Sie ausführen können, um dies auszuprobieren.

package test;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.Shape;
import java.awt.geom.AffineTransform;
import java.awt.geom.Ellipse2D;
import java.awt.image.BufferedImage;

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

public class SimplePaint02 {

    private static final int LINE_THICKNESS = 4;
    private static final int LINE_GAP = 10;
    private Color lineColor = Color.red;

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

    public SimplePaint02() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                try {
                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                } catch (Exception ex) {
                }

                JFrame frame = new JFrame();
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setLayout(new BorderLayout());
                frame.add(new TestPane());
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public class TestPane extends JPanel {

        @Override
        public Dimension getPreferredSize() {
            return new Dimension(100, 100);
        }

        @Override
        public void paintComponent(Graphics g) {

            int radius = 50;
            BufferedImage buffer = new BufferedImage(radius, radius, BufferedImage.TYPE_INT_ARGB);
            Graphics2D g2d = buffer.createGraphics();
            g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION,RenderingHints.VALUE_INTERPOLATION_BILINEAR);

            Ellipse2D circle = new Ellipse2D.Float(0, 0, radius,radius);
            Shape clip = g2d.getClip();
            g2d.setClip(circle);
            AffineTransform at = g2d.getTransform();

            g2d.setTransform(AffineTransform.getRotateInstance(Math.toRadians(45),radius / 2, radius / 2));

            int gap = LINE_GAP;

            g2d.setColor(Color.WHITE);
            g2d.fill(circle);

            g2d.setColor(lineColor);
            //g2d.setStroke(new BasicStroke(LINE_THICKNESS));
            for (int index = 0; index < 10; index++) {
                int x1 = index*gap-(LINE_THICKNESS/2);
                int y1 = 0;
                int x2 = index*gap+(LINE_THICKNESS/2);
                int y2 = radius;
                int width = x2 - x1;
                int height = y2 - y1;

                g2d.fillRect(x1, y1, width, height);
                //g2d.drawLine(index * gap, 0, index * gap, getRadius());
            }

            g2d.setTransform(at);
            g2d.setClip(clip);
            g2d.dispose();
            g.drawImage(buffer, 0, 0, this);
        }

    }

}

aktivieren Sie Anti-Aliasing? stackoverflow.com/questions/179955/...
1) Für besser zu helfen, schneller zu veröffentlichen, SSCCE. 2) Halten Sie das hinzufügen, rendering hints. Ich vergesse immer, welche zaubern.
gibt es ein äquivalent für die Grafik? das scheint für Schriftarten
Ich habe eine SSCCE
developmentality.wordpress.com/2010/02/09/...

InformationsquelleAutor CodeGuy | 2013-01-20

5

EDIT: Bitte siehe Code-Guy ' s Antwort weiter unten für eine Lösung. Dieser markiert ist richtig, denn es war Joey Rohan, der es herausgefunden hat anfangs!

Ich habe glatten Rand, wenn ich versuchte die gleiche Sache:
```
  g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,    RenderingHints.VALUE_ANTIALIAS_ON);
```
```
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.image.BufferedImage;
import java.io.File;
import javax.imageio.ImageIO;

public class DrawSmoothCircle {
    public static void main(String[] argv) throws Exception {
        BufferedImage bufferedImage = new BufferedImage(100, 100, BufferedImage.TYPE_INT_RGB);
        Graphics2D g2d = bufferedImage.createGraphics();

        g2d.setRenderingHint (RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        g2d.setPaint(Color.green);
        g2d.fillOval(10, 10, 50, 50);
        g2d.dispose();

        ImageIO.write(bufferedImage, "png", new File("e:\\newimage.png"));
    }
}
```
UPDATE:

Nach der Suche eine Menge:

Es ist nichts falsch mit dem code aber,

Gut, leider Java 2D (oder zumindest Sun ' s aktuelle Implementierung) nicht unterstützt "soft-clipping".

Aber habe Auch einen trick für die clips:
Folgen Sie Dieser link,können Sie erreichen, was Sie fordern.

(Auch, ich habe einen glatten Rand, denn ich din nicht verwenden, clip-Zeug,in meinem Bild oben)

Wo hast die Zeilen gehen? Wenn Sie den code ausführen, erhalten Sie einen Kreis mit Linien.
Nein, ich meine din nicht mit der mittleren Linien.Ok, werde versuchen, aus.
Ja, es funktioniert gut, ohne die Linien. Etwas in den Prozess der Herstellung der Linien ist es zu tun.
Das problem ist nicht eigentlich beim zeichnen von Formen, sondern, wenn die Befüllung oder die Malerei zu einem Clip.
Ich sehe. Du meinst also, es ist eine andere Art zu zeichnen dieser Form, ohne einen clip?

InformationsquelleAutor joey rohan

Hier war die Antwort. Ich angepasst, der Großteil des Codes aus diese Website. Werfen Sie einen Blick:

Zeichnung einen schönen Kreis in Java

Hier der code:

public void paintComponent(Graphics g) {

        //Create a translucent intermediate image in which we can perform
        //the soft clipping
        GraphicsConfiguration gc = ((Graphics2D) g).getDeviceConfiguration();
        BufferedImage img = gc.createCompatibleImage(getWidth(), getHeight(), Transparency.TRANSLUCENT);
        Graphics2D g2 = img.createGraphics();

        //Clear the image so all pixels have zero alpha
        g2.setComposite(AlphaComposite.Clear);
        g2.fillRect(0, 0, getWidth(), getHeight());

        //Render our clip shape into the image.  Note that we enable
        //antialiasing to achieve the soft clipping effect.  Try
        //commenting out the line that enables antialiasing, and
        //you will see that you end up with the usual hard clipping.
        g2.setComposite(AlphaComposite.Src);
        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        g2.setColor(Color.WHITE);
        g2.fillOval(0, 0, getRadius(), getRadius());

        //Here's the trick... We use SrcAtop, which effectively uses the
        //alpha value as a coverage value for each pixel stored in the
        //destination.  For the areas outside our clip shape, the destination
        //alpha will be zero, so nothing is rendered in those areas.  For
        //the areas inside our clip shape, the destination alpha will be fully
        //opaque, so the full color is rendered.  At the edges, the original
        //antialiasing is carried over to give us the desired soft clipping
        //effect.
        g2.setComposite(AlphaComposite.SrcAtop);
        g2.setColor(lineColor);
        int gap = LINE_GAP;
        AffineTransform at = g2.getTransform();

        g2.setTransform(AffineTransform.getRotateInstance(Math.toRadians(45),getRadius() / 2, getRadius() / 2));

        for (int index = 0; index < 10; index++) {
            int x1 = index*gap-(LINE_THICKNESS/2);
            int y1 = 0;
            int x2 = index*gap+(LINE_THICKNESS/2);
            int y2 = getRadius();
            int width = x2 - x1;
            int height = y2 - y1;

            g2.fillRect(x1, y1, width, height);
        }

        g2.setTransform(at);
        g2.dispose();

        //Copy our intermediate image to the screen
        g.drawImage(img, 0, 0, null);
    }

Froh, dass Sie es heraus :)+1

InformationsquelleAutor CodeGuy

Update

OK. Dann ist die Idee zu nicht verwenden clipping an alle sondern um die beschnittene Form, indem Bereiche von einander.

Zeichnung einen schönen Kreis in Java

import java.awt.*;
import java.awt.geom.*;
import java.awt.image.BufferedImage;
import javax.swing.*;

public class SimplePaint02 {

    private static final int LINE_THICKNESS = 4;
    private static final int LINE_GAP = 10;
    private Color lineColor = Color.red;

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

    public SimplePaint02() {
        EventQueue.invokeLater(new Runnable() {

            @Override
            public void run() {
                try {
                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                } catch (Exception ex) {
                }

                JFrame frame = new JFrame();
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setLayout(new BorderLayout());
                frame.add(new TestPane());
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public class TestPane extends JPanel {

        int radius = 75;

        @Override
        public Dimension getPreferredSize() {
            return new Dimension(radius, radius);
        }

        @Override
        public void paintComponent(Graphics g) {


            Ellipse2D circle = new Ellipse2D.Float(0, 0, radius, radius);
            Area lines = new Area();

            int gap = LINE_GAP;

            for (int index = 0; index < 10; index++) {
                int x1 = index * gap - (LINE_THICKNESS / 2);
                int y1 = 0;
                int x2 = index * gap + (LINE_THICKNESS / 2);
                int y2 = radius;
                int width = x2 - x1;
                int height = y2 - y1;

                Shape lineShape = new Rectangle2D.Double(x1, y1, width, height);
                lines.add(new Area(lineShape));

                //g3d.fillRect(x1, y1, width, height);
                //g2d.drawLine(index * gap, 0, index * gap, getRadius());
            }
            //g2d.setClip(circle);

            Area circleNoLines = new Area(circle);
            circleNoLines.subtract(lines);

            Area linesCutToCircle = new Area(circle);
            linesCutToCircle.subtract(circleNoLines);

            //g2d.setTransform(at);
            BufferedImage buffer = new BufferedImage(radius * 2, radius * 2, BufferedImage.TYPE_INT_ARGB);
            Graphics2D g2d = buffer.createGraphics();

            RenderingHints rh = new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
            g2d.setTransform(AffineTransform.getRotateInstance(Math.toRadians(45), radius / 2, radius / 2));
            g2d.setRenderingHints(rh);
            g2d.setColor(Color.ORANGE);
            g2d.fill(linesCutToCircle);
            g2d.setColor(Color.RED);
            g2d.fill(circleNoLines);

            g2d.dispose();
            g.drawImage(buffer, 0, 0, this);
        }
    }
}

Alten code

Teil des Problems ist, dass die rendering-Operationen in der Regel nicht anzuwenden, um eine Clip, obwohl Sie auf anwenden, um die Shape wenn es gezogen wird. Ich in der Regel lösen, die durch (letzten) Anstrich der Shape selbst. E. G.

Zeichnung einen schönen Kreis in Java

1,5 pixel BasicStroke hier verwendet wird, für die der rote Kreis - die Glättung der Ecken und Kanten produziert von der Clip.

import java.awt.*;
import java.awt.geom.AffineTransform;
import java.awt.geom.Ellipse2D;
import java.awt.image.BufferedImage;

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

public class SimplePaint02 {

    private static final int LINE_THICKNESS = 4;
    private static final int LINE_GAP = 10;
    private Color lineColor = Color.red;

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

    public SimplePaint02() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                try {
                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                } catch (Exception ex) {
                }

                JFrame frame = new JFrame();
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setLayout(new BorderLayout());
                frame.add(new TestPane());
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public class TestPane extends JPanel {

        int radius = 75;

        @Override
        public Dimension getPreferredSize() {
            return new Dimension((int)(1.1*radius), (int)(1.1*radius));
        }

        @Override
        public void paintComponent(Graphics g) {

            BufferedImage buffer = new BufferedImage(radius*2, radius*2, BufferedImage.TYPE_INT_ARGB);
            Graphics2D g2d = buffer.createGraphics();

            RenderingHints rh = new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
            rh.put(RenderingHints.KEY_DITHERING,RenderingHints.VALUE_DITHER_ENABLE);
            rh.put(RenderingHints.KEY_COLOR_RENDERING,RenderingHints.VALUE_COLOR_RENDER_QUALITY);
            g2d.setRenderingHints(rh);

            Ellipse2D circle = new Ellipse2D.Float(0, 0, radius,radius);
            Shape clip = g2d.getClip();
            g2d.setClip(circle);
            AffineTransform at = g2d.getTransform();

            g2d.setTransform(AffineTransform.getRotateInstance(Math.toRadians(45),radius / 2, radius / 2));

            int gap = LINE_GAP;

            g2d.setColor(Color.WHITE);
            g2d.fill(circle);

            g2d.setColor(lineColor);
            //g2d.setStroke(new BasicStroke(LINE_THICKNESS));
            for (int index = 0; index < 10; index++) {
                int x1 = index*gap-(LINE_THICKNESS/2);
                int y1 = 0;
                int x2 = index*gap+(LINE_THICKNESS/2);
                int y2 = radius;
                int width = x2 - x1;
                int height = y2 - y1;

                g2d.fillRect(x1, y1, width, height);
                //g2d.drawLine(index * gap, 0, index * gap, getRadius());
            }

            g2d.setTransform(at);
            g2d.setClip(clip);
            g2d.setClip(null);
            g2d.setStroke(new BasicStroke(1.5f));
            g2d.draw(circle);
            g2d.dispose();
            g.drawImage(buffer, 0, 0, this);
        }
    }
}

Die Gliederung macht es so Aussehen, jetzt glatt. Allerdings kann ich nicht zählen die Gliederung in meinem Kreis mit Linien. Haben Sie eine Lösung, die nicht zeichnen diesen Rahmen?
Ah.. pingelig, pingelig ( ich habe gotta bewundern ;). Das update angezeigt.
Gut gemacht. Ganz nett!
Du bist herzlich willkommen. 🙂 SrcAtop scheint zu funktionieren ganz gut, wie gut.

InformationsquelleAutor Andrew Thompson

Ich verwendet drawPolygon Methode zeichne einen Kreis durch die Generierung array mit den meisten Punkten auf dem Umfang des Kreises mit den vorgeschlagenen radius.
Code:

           import java.awt.*;
           import java.applet.*;

            /*<applet code="OnlyCircle" width=500 height=500>
                 </applet>*/

          public class OnlyCircle extends Applet{

            public void paint(Graphics g){


              int r=200;//radius
              int x1=250;//center x coordinate
              int y1=250;//center y coordinate
              double x2,y2;
              double a=0;
              double pi=3.14159;
              int count=0; 
              int i=0;
              int f=0;
              int[] x22=new int[628319];
              int[] y22=new int[628319];

             while(a<=2*pi&&i<628319&&f<628319)
                  {
                   double k=Math.cos(a);
                   double l=Math.sin(a);
                     x2=x1+r*k;
                     y2=y1+r*l;
                  x22[i]=(int)x2;
                  y22[f]=(int)y2;
                   i++;
                   f++;
                   a+=0.00001;
                  }
               int length=x22.length;
               g.drawPolygon(x22,y22,length);
                 }
               }

InformationsquelleAutor Deepeshkumar

0

Aktivieren Sie anti-aliasing:
```
Graphics2D g2 = (Graphics2D) g;
Map<RenderingHints.Key, Object> hints = new HashMap<RenderingHints.Key, Object>();
hints.put(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); 
g2.setRenderingHints(hints);
```
Ich auch empfehlen, zeichnen Sie auf das Graphics-Objekt erhalten Sie von der paintComponent Methode eher als die Schaffung einer intermediate -BufferedImage.

Ich bin schon dabei, glaube ich (siehe code, den ich gepostet)...ich bin einfach nicht tun es, indem Sie eine Karte erstellen, das ist alles. Ich bin mit g2d.setRenderingHints
Sie tun es auf dem BufferedImage Graphics2D-Objekt, tun Sie es auf die Grafiken erhalten Sie in der paintComponent-Methode sowie.
Aber das wird nicht unbedingt die Ausgabe verändern, woudld?

InformationsquelleAutor Dan D.

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.