Java实现饼图旋转角度的代码详解

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.util.*;
import java.util.List;
 
/**
 * RotatingPieChartPanel：可自动/手动旋转且正确排序的饼图组件
 */
public class RotatingPieChartPanel extends JPanel {
 
    /** 内部扇区模型 */
    private static class PieSlice {
        double value;          // 扇区数值
        Color color;           // 扇区颜色
        String label;          // 扇区标签
        double startAngle;     // 起始角度（度）
        double arcAngle;       // 扇区角度（度）
        boolean highlighted;   // 是否高亮
 
        PieSlice(double value, Color color, String label) {
            this.value = value;
            this.color = color;
            this.label = label;
            this.highlighted = false;
        }
    }
 
    private final List<PieSlice> slices = new ArrayList<>();
    private double totalValue = 0.0;
 
    // 旋转控制
    private double angleOffset = 0.0;  // 当前偏移角度
    private double rpm = 1.0;          // 每分钟度数
    private boolean clockwise = true;  // 旋转方向
    private Timer animationTimer;      // 用于自动旋转
 
    // 3D 效果深度（像素）
    private double depth = 50.0;
 
    // 拖拽交互状态
    private boolean dragging = false;
    private double dragStartOffset;
    private Point dragStartPoint;
 
    public RotatingPieChartPanel() {
        setBackground(Color.WHITE);
        setPreferredSize(new Dimension(600, 400));
        initInteraction();
    }
 
    /** 初始化鼠标交互：拖拽控制 */
    private void initInteraction() {
        MouseAdapter ma = new MouseAdapter() {
            @Override
            public void mousePressed(MouseEvent e) {
                // 停止自动旋转，进入拖拽状态
                stop();
                dragging = true;
                dragStartOffset = angleOffset;
                dragStartPoint = e.getPoint();
            }
 
            @Override
            public void mouseDragged(MouseEvent e) {
                if (!dragging) return;
                Point pt = e.getPoint();
                double dx = pt.x - dragStartPoint.x;
                // 每像素对应 0.5 度
                angleOffset = dragStartOffset + dx * 0.5;
                repaint();
            }
 
            @Override
            public void mouseReleased(MouseEvent e) {
                dragging = false;
                start(); // 恢复自动旋转
            }
        };
        addMouseListener(ma);
        addMouseMotionListener(ma);
    }
 
    /** 添加扇区 */
    public void addSlice(double value, Color color, String label) {
        slices.add(new PieSlice(value, color, label));
        totalValue += value;
        computeAngles();
        repaint();
    }
 
    /** 重新计算扇区角度 */
    private void computeAngles() {
        double angle = 0.0;
        for (PieSlice s : slices) {
            s.startAngle = angle;
            s.arcAngle = s.value / totalValue * 360.0;
            angle += s.arcAngle;
        }
    }
 
    /** 设置旋转速率（RPM） */
    public void setRotateSpeed(double rpm) {
        this.rpm = rpm;
        if (animationTimer != null && animationTimer.isRunning()) {
            stop();
            start();
        }
    }
 
    /** 设置旋转方向 */
    public void setClockwise(boolean cw) {
        this.clockwise = cw;
    }
 
    /** 设置 3D 深度 */
    public void setDepth(double depth) {
        this.depth = depth;
        repaint();
    }
 
    /** 启动自动旋转 */
    public void start() {
        if (animationTimer != null && animationTimer.isRunning()) return;
        int delay = 40; // 25 FPS
        double deltaDeg = rpm * 360.0 / (60_000.0 / delay);
        animationTimer = new Timer(delay, e -> {
            angleOffset += (clockwise ? -deltaDeg : deltaDeg);
            repaint();
        });
        animationTimer.start();
    }
 
    /** 停止自动旋转 */
    public void stop() {
        if (animationTimer != null) {
            animationTimer.stop();
            animationTimer = null;
        }
    }
 
    /** 获取当前角度 */
    public double getAngle() {
        return angleOffset;
    }
 
    /** 直接设置角度（瞬时跳转） */
    public void setAngle(double angle) {
        this.angleOffset = angle % 360.0;
        repaint();
    }
 
    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        renderPie((Graphics2D) g);
    }
 
    /** 绘制饼图：阴影 → 侧面（深度排序） → 顶面 */
    private void renderPie(Graphics2D g2) {
        // 抗锯齿
        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                            RenderingHints.VALUE_ANTIALIAS_ON);
 
        int w = getWidth(), h = getHeight();
        double cx = w / 2.0, cy = h / 2.0 - depth / 2.0;
        double r = Math.min(w, h - depth) / 2.0 - 20.0;
 
        // 1. 绘制阴影
        drawShadow(g2, cx, cy, r);
 
        // 2. 深度排序并绘制侧面
        List<PieSlice> sorted = new ArrayList<>(slices);
        sorted.sort(Comparator.comparingDouble(this::depthKey));
        for (PieSlice s : sorted) {
            drawSide(g2, cx, cy, r, s);
        }
 
        // 3. 绘制顶面
        for (PieSlice s : sorted) {
            drawTop(g2, cx, cy, r, s);
        }
    }
 
    /** 计算深度排序 key：扇区中心角度的 sin 值 */
    private double depthKey(PieSlice s) {
        double mid = s.startAngle + s.arcAngle / 2.0 + angleOffset;
        return Math.sin(Math.toRadians(mid));
    }
 
    /** 绘制底部阴影 */
    private void drawShadow(Graphics2D g2,
                            double cx, double cy, double r) {
        Ellipse2D shadow = new Ellipse2D.Double(
            cx - r, cy + depth - r / 3.0 * 2, 2 * r, r / 2.0
        );
        Composite old = g2.getComposite();
        g2.setComposite(AlphaComposite.getInstance(
            AlphaComposite.SRC_OVER, 0.3f
        ));
        g2.setColor(Color.BLACK);
        g2.fill(shadow);
        g2.setComposite(old);
    }
 
    /** 绘制扇区侧面 */
    private void drawSide(Graphics2D g2,
                          double cx, double cy, double r, PieSlice s) {
        double sa = Math.toRadians(s.startAngle + angleOffset);
        double ea = Math.toRadians(s.startAngle + s.arcAngle + angleOffset);
 
        Point2D p1 = new Point2D.Double(
            cx + r * Math.cos(sa), cy + r * Math.sin(sa)
        );
        Point2D p2 = new Point2D.Double(
            cx + r * Math.cos(ea), cy + r * Math.sin(ea)
        );
        Point2D p3 = new Point2D.Double(p2.getX(), p2.getY() + depth);
        Point2D p4 = new Point2D.Double(p1.getX(), p1.getY() + depth);
 
        Path2D side = new Path2D.Double();
        side.moveTo(p1.getX(), p1.getY());
        side.lineTo(p4.getX(), p4.getY());
        side.lineTo(p3.getX(), p3.getY());
        side.lineTo(p2.getX(), p2.getY());
        side.closePath();
 
        g2.setColor(s.color.darker());
        g2.fill(side);
        if (s.highlighted) {
            g2.setColor(Color.WHITE);
            g2.setStroke(new BasicStroke(2));
            g2.draw(side);
        }
    }
 
    /** 绘制扇区顶面 */
    private void drawTop(Graphics2D g2,
                         double cx, double cy, double r, PieSlice s) {
        Arc2D top = new Arc2D.Double(
            cx - r, cy - r, 2 * r, 2 * r,
            s.startAngle + angleOffset,
            s.arcAngle, Arc2D.PIE
        );
        g2.setColor(s.color);
        g2.fill(top);
        if (s.highlighted) {
            g2.setColor(Color.WHITE);
            g2.setStroke(new BasicStroke(2));
            g2.draw(top);
        }
    }
 
    // 可扩展：添加高亮与提示功能
}
 
/**
 * DemoMain：演示 RotatingPieChartPanel 用法
 */
class DemoMain {
    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> {
            RotatingPieChartPanel pie = new RotatingPieChartPanel();
            pie.addSlice(30, Color.RED,   "红");
            pie.addSlice(20, Color.BLUE,  "蓝");
            pie.addSlice(40, Color.GREEN, "绿");
            pie.addSlice(10, Color.ORANGE,"橙");
            pie.setDepth(60);
            pie.setRotateSpeed(2.5);
            pie.setClockwise(false);
            pie.start();
 
            JFrame f = new JFrame("可旋转饼图示例");
            f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            f.add(pie);
            f.pack();
            f.setLocationRelativeTo(null);
            f.setVisible(true);
        });
    }
}

double deltaDeg = rpm * 360.0 / (60_000.0 / delay);
angleOffset += clockwise ? -deltaDeg : deltaDeg;