Java2D：如何使用GeneralPath绘制圆的切片

我想创建一个命运之轮游戏来练习。 我使用GeneralPath创建了轮子切片，但是我在找出贝泽点应该是什么才能有一个完美的圆时遇到了问题。看一看屏幕截图，你就会看到问题所在

我不知道应该使用什么公式来获得正确的值，现在我基本上只是猜测：

        path.moveTo(x, y); // the center

        this.firstPointX = x + wSize * Math.cos(angle*i);
        this.firstPointY = y + wSize * Math.sin(angle*i);

        path.lineTo(this.firstPointX, this.firstPointY);

        this.secondPointX = x + wSize * Math.cos(angle*(i+1));
        this.secondPointY = y + wSize * Math.sin(angle*(i+1));

        path.moveTo(x, y); // back to the center
        path.lineTo(this.secondPointX, this.secondPointY);

        this.beizerX = x + (THIS IS THE VALUE I NEED) * Math.cos((angle*i+angle/2));
        this.beizerY = y + (THIS IS THE VALUE I NEED) * Math.sin((angle*i+angle/2));

        path.curveTo(this.secondPointX, this.secondPointY, this.beizerX, this.beizerY, this.firstPointX, this.firstPointY);

        path.closePath();

为什么不直接使用或简单地画一个圆和6条线呢？然后基本问题是如何确定圆上的两点（起点和终点，相距180度）

也许像

我试着使用拱门，但旋转起来有困难

很容易

导入java.awt.Dimension；
导入java.awt.EventQueue；
导入java.awt.Graphics；
导入java.awt.Graphics2D；
导入java.awt.RenderingHints；
导入java.awt.event.ActionEvent；
导入java.awt.event.ActionListener；
导入java.awt.geom.AffineTransform；
导入java.awt.geom.Arc2D；
导入java.awt.geom.Ellipse2D；
导入java.awt.geom.GeneralPath；
导入java.awt.geom.Rectangle2D；
导入javax.swing.JFrame；
导入javax.swing.JPanel；
导入javax.swing.Timer；
公开课考试{
公共静态void main（字符串[]args）{
新测试（）；
}
公开考试（）{
invokeLater（新的Runnable（）{
@凌驾
公开募捐{
JFrame=新JFrame（）；
frame.add（newtestpane（））；
frame.pack（）；
frame.setLocationRelativeTo（空）；
frame.setVisible（true）；
}
});
}
公共类TestPane扩展了JPanel{
私有GeneralPath gp=新的GeneralPath（）；
私有双自旋值=0；
公共测试窗格（）{
append（新的Ellipse2D.Double（0，0，200，200），true）；
用于（双角度=0；角度<360；角度+=30）{
Arc2D圆弧=新的Arc2D.Double（0,0,200,200，
角度，
30,
Arc2D.PIE）；
附加总成（弧，假）；
}
计时器计时器=新计时器（5，新ActionListener（）{
@凌驾
已执行的公共无效操作（操作事件e）{
spinValue+=0.01；
重新油漆（）；
}
});
timer.start（）；
}
@凌驾
公共维度getPreferredSize（）{
返回新维度（300300）；
}
@凌驾
受保护组件（图形g）{
超级组件（g）；
Graphics2D g2d=（Graphics2D）g.create（）；
RenderingHists=new RenderingHists（RenderingHists.KEY\u ANTIALIASING，RenderingHists.VALUE\u ANTIALIAS\u ON）；
g2d.setRenderingHints（提示）；
矩形2D边界=gp.getBounds2D（）；
双x=（getWidth（）-bounds.getWidth（））/2d；
双y=（getHeight（）-bounds.getHeight（））/2d；
AffineTransform at=AffineTransform.getTranslateInstance（x，y）；
旋转（spinValue，bounds.getCenterX（），bounds.getCenterY（））；
g2d.变换（at）；
g2d.绘图（gp）；
g2d.dispose（）；
}
}
}

我还想用渐变填充单个切片，并用旋转等方式独立设置动画

---

因此，您不能使用单个

路径

，因为它被视为单个图形元素，您需要使用单个切片，因此我强烈建议使用

Arc2D

，因为维护它们的列表并根据需要简单地转换

图形

上下文

首先用特定的半径绘制一个圆，用6条线分开这个圆我想控制切片，因为我想要动画和渐变填充它们。首先找到圆的区域，然后将该圆划分为6，然后你将得到线之间的角度，你可以使用这些角度绘制线为什么不使用或只是绘制一个圆和6条线？谢谢。我试着使用拱门，但旋转起来有困难。我还想用渐变填充单片，并用旋转等方式独立制作动画。顺便说一下，我现在在手机上，稍后我可以更仔细地检查你的答案。“我还想用渐变填充单片，并用旋转等方式独立制作动画”然后，您不能使用单<代码>路径<代码>，因为它画了一个完整的元素——您需要将每个段创建为一个单独的路径——在这种情况下，我可能只考虑使用个人代码> ARC2D< /代码>元素。谢谢您的详细解答。

import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.geom.Ellipse2D;
import java.awt.geom.GeneralPath;
import java.awt.geom.Point2D;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class Test {

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

    public Test() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                JFrame frame = new JFrame();
                frame.add(new TestPane());
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public class TestPane extends JPanel {

        private GeneralPath gp = new GeneralPath();

        public TestPane() {

            //GeneralPath gp = new GeneralPath();
            gp.append(new Ellipse2D.Double(0, 0, 200, 200), true);

            for (double angle = 0; angle < 180; angle += 30) {
                Point2D startPoint = pointOnCircle(angle, 100);
                Point2D endPoint = pointOnCircle(angle + 180, 100);

                gp.moveTo(startPoint.getX(), startPoint.getY());
                gp.lineTo(endPoint.getX(), endPoint.getY());
            }

        }

        protected Point2D pointOnCircle(double degrees, double radius) {
            double origin = radius;
            double rads = Math.toRadians(degrees);
            double x = origin + (Math.cos(rads) * radius);
            double y = origin + (Math.sin(rads) * radius);

            return new Point2D.Double(x, y);
        }

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

        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            Graphics2D g2d = (Graphics2D) g.create();
            RenderingHints hints = new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
            g2d.setRenderingHints(hints);
            g2d.translate(50, 50);
            g2d.draw(gp);
            g2d.dispose();
        }
    }

}

import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.geom.Arc2D;
import java.awt.geom.Ellipse2D;
import java.awt.geom.GeneralPath;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class Test {

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

    public Test() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                JFrame frame = new JFrame();
                frame.add(new TestPane());
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public class TestPane extends JPanel {

        private GeneralPath gp = new GeneralPath();

        public TestPane() {
            gp.append(new Ellipse2D.Double(0, 0, 200, 200), true);

            for (double angle = 0; angle < 360; angle += 30) {
                Arc2D arc = new Arc2D.Double(0, 0, 200, 200,
                        angle,
                        30,
                        Arc2D.PIE);
                gp.append(arc, false);
            }

        }

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

        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            Graphics2D g2d = (Graphics2D) g.create();
            RenderingHints hints = new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
            g2d.setRenderingHints(hints);
            g2d.translate(50, 50);
            g2d.draw(gp);
            g2d.dispose();
        }
    }

}

import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.geom.AffineTransform;
import java.awt.geom.Arc2D;
import java.awt.geom.Ellipse2D;
import java.awt.geom.GeneralPath;
import java.awt.geom.Rectangle2D;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;

public class Test {

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

    public Test() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                JFrame frame = new JFrame();
                frame.add(new TestPane());
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public class TestPane extends JPanel {

        private GeneralPath gp = new GeneralPath();
        private double spinValue = 0;

        public TestPane() {
            gp.append(new Ellipse2D.Double(0, 0, 200, 200), true);

            for (double angle = 0; angle < 360; angle += 30) {
                Arc2D arc = new Arc2D.Double(0, 0, 200, 200,
                        angle,
                        30,
                        Arc2D.PIE);
                gp.append(arc, false);
            }

            Timer timer = new Timer(5, new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    spinValue += 0.01;
                    repaint();
                }
            });
            timer.start();
        }

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

        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            Graphics2D g2d = (Graphics2D) g.create();
            RenderingHints hints = new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
            g2d.setRenderingHints(hints);

            Rectangle2D bounds = gp.getBounds2D();
            double x = (getWidth() - bounds.getWidth()) / 2d;
            double y = (getHeight() - bounds.getHeight()) / 2d;

            AffineTransform at = AffineTransform.getTranslateInstance(x, y);
            at.rotate(spinValue, bounds.getCenterX(), bounds.getCenterY());

            g2d.transform(at);
            g2d.draw(gp);
            g2d.dispose();
        }
    }

}