React中如何使用echarts写出3d旋转扇形图

import * as echarts from "echarts";
import react, { useeffect, useref } from "react";
import "echarts-gl";
import "./index.less";

const leftecharts = () => {
    const chartdom = useref(null);

    useeffect(() => {
        const mychart = echarts.init(chartdom.current);
        // 数据源
        const optionsdata: any = [
            {
                name: "it运营管控团队",
                value: 1000,
                itemstyle: {
                    color: "#dd4b3d",
                },
            },
            {
                name: "业务支撑团队",
                value: 600,
                itemstyle: {
                    color: "#dd9c3c",
                },
            },
            {
                name: "计费结算团队",
                value: 900,
                itemstyle: {
                    color: "#f6bb50",
                },
            },
            {
                name: "数据应用运营团队",
                value: 800,
                itemstyle: {
                    color: "#5ec7f8",
                },
            },
            {
                name: "paas组件运营团队",
                value: 400,
                itemstyle: {
                    color: "#31dda1",
                },
            },
            {
                name: "云数安全团队",
                value: 300,
                itemstyle: {
                    color: "#637aff",
                },
            },
        ];

        // 生成扇形的曲面参数方程，用于 series-surface.parametricequation
        function getparametricequation(
            startratio,
            endratio,
            isselected,
            ishovered,
            k,
            h
        ) {
            // 计算
            let midratio = (startratio + endratio) / 2;

            let startradian = startratio * math.pi * 2;
            let endradian = endratio * math.pi * 2;
            let midradian = midratio * math.pi * 2;

            // 如果只有一个扇形，则不实现选中效果。
            // if (startratio === 0 && endratio === 1) {
            //     isselected = false;
            // }
            isselected = false;
            // 通过扇形内径/外径的值，换算出辅助参数 k（默认值 1/3）
            k = typeof k !== "undefined" ? k : 1 / 3;

            // 计算选中效果分别在 x 轴、y 轴方向上的位移（未选中，则位移均为 0）
            let offsetx = isselected ? math.sin(midradian) * 0.1 : 0;
            let offsety = isselected ? math.cos(midradian) * 0.1 : 0;

            // 计算高亮效果的放大比例（未高亮，则比例为 1）
            let hoverrate = ishovered ? 1.05 : 1;

            // 返回曲面参数方程
            return {
                u: {
                    min: -math.pi,
                    max: math.pi * 3,
                    step: math.pi / 32,
                },

                v: {
                    min: 0,
                    max: math.pi * 2,
                    step: math.pi / 20,
                },

                x: function (u, v) {
                    if (u < startradian) {
                        return (
                            offsetx +
                            math.cos(startradian) * (1 + math.cos(v) * k) * hoverrate
                        );
                    }
                    if (u > endradian) {
                        return (
                            offsetx +
                            math.cos(endradian) * (1 + math.cos(v) * k) * hoverrate
                        );
                    }
                    return offsetx + math.cos(u) * (1 + math.cos(v) * k) * hoverrate;
                },

                y: function (u, v) {
                    if (u < startradian) {
                        return (
                            offsety +
                            math.sin(startradian) * (1 + math.cos(v) * k) * hoverrate
                        );
                    }
                    if (u > endradian) {
                        return (
                            offsety +
                            math.sin(endradian) * (1 + math.cos(v) * k) * hoverrate
                        );
                    }
                    return offsety + math.sin(u) * (1 + math.cos(v) * k) * hoverrate;
                },

                z: function (u, v) {
                    if (u < -math.pi * 0.5) {
                        return math.sin(u);
                    }
                    if (u > math.pi * 2.5) {
                        return math.sin(u) * h * 0.1;
                    }
                    return math.sin(v) > 0 ? 1 * h * 0.1 : -1;
                },
            };
        }

        // 生成模拟 3d 饼图的配置项
        function getpie3d(piedata: any, internaldiameterratio) {
            let series: any = [];
            let sumvalue = 0;
            let startvalue = 0;
            let endvalue = 0;
            let legenddata: any = [];
            let k =
                typeof internaldiameterratio !== "undefined"
                    ? (1 - internaldiameterratio) / (1 + internaldiameterratio)
                    : 1 / 3;
            // 为每一个饼图数据，生成一个 series-surface 配置
            for (let i = 0; i < piedata.length; i++) {
                sumvalue += piedata[i].value;
                let seriesitem: any = {
                    name:
                        typeof piedata[i].name === "undefined"
                            ? `series${i}`
                            : piedata[i].name,
                    type: "surface",
                    parametric: true,
                    wireframe: {
                        show: false,
                    },
                    piedata: piedata[i],
                    piestatus: {
                        selected: false,
                        hovered: false,
                        k: 1 / 10,
                    },
                };
                if (typeof piedata[i].itemstyle != "undefined") {
                    let itemstyle: any = {};
                    typeof piedata[i].itemstyle.color != "undefined" ? (itemstyle.color = piedata[i].itemstyle.color) : null;
                    typeof piedata[i].itemstyle.opacity != "undefined" ? (itemstyle.opacity = piedata[i].itemstyle.opacity) : null;
                    seriesitem.itemstyle = itemstyle;
                }
                series.push(seriesitem);
            }
            for (let i = 0; i < series.length; i++) {
                endvalue = startvalue + series[i].piedata.value;
                series[i].piedata.startratio = startvalue / sumvalue;
                series[i].piedata.endratio = endvalue / sumvalue;
                series[i].parametricequation = getparametricequation(
                    series[i].piedata.startratio,
                    series[i].piedata.endratio,
                    false,
                    false,
                    k,
                    series[i].piedata.value
                );
                startvalue = endvalue;
                legenddata.push(series[i].name);
            }
            return series;
        }

        const series: any = getpie3d(optionsdata, 0.6);
        series.push({
            name: "pie2d",
            type: "pie",
            label: {
                opacity: 1,
                fontsize: 14,
                lineheight: 20,
                textstyle: {
                    fontsize: 14,
                    color: "#fff",
                },
                show: false,
                position: "center",
            },
            labelline: {
                length: 10,
                length2: 10,
                show: false,
            },
            startangle: 2, //起始角度，支持范围[0, 360]。
            clockwise: false, //饼图的扇区是否是顺时针排布。上述这两项配置主要是为了对齐3d的样式
            radius: ["50%", "60%"],
            center: ["62%", "50%"],
            data: optionsdata,
            itemstyle: {
                opacity: 0,
            },
        });
        // 准备待返回的配置项，把准备好的 legenddata、series 传入。
        const option = {
            legend: {
                show: true, // 显示图例
                tooltip: {
                    show: true, // 显示图例的提示信息
                },
                orient: "vertical", // 图例的排列方向
                data: ["it运营管控团队", "业务支撑团队", "计费结算团队", "数据应用运营团队", "paas组件运营团队", '云数安全团队'], // 图例的内容
                top: 20, // 图例距离顶部的距离
                itemgap: 10, // 图例项之间的间距
                itemheight: 20, // 图例项的高度
                itemwidth: 24, // 图例项的宽度
                right: "5%", // 图例距离右边的距离
                textstyle: { // 图例的文本样式
                    color: "#fff", // 文本颜色
                    fontsize: 10, // 文本字体大小
                    rich: {
                        name: {
                            width: 60, // 名称部分的宽度
                            fontsize: 14, // 名称部分字体大小
                            color: "#b0d8df", // 名称部分颜色
                            fontfamily: "source han sans cn", // 名称部分字体
                        },
                        value: {
                            width: 50, // 数值部分的宽度
                            fontsize: 4, // 数值部分字体大小
                            padding: [0, 5, 0, 5], // 数值部分的内边距
                            color: "#fff", // 数值部分颜色
                            fontfamily: "source han sans cn", // 数值部分字体
                        },
                        a: {
                            fontsize: 20, // a部分的字体大小
                            color: "#b0d8df", // a部分颜色
                            fontfamily: "source han sans cn", // a部分字体
                        },
                        rate: {
                            width: 60, // 比率部分的宽度
                            fontsize: 14, // 比率部分字体大小
                            padding: [0, 5, 0, 10], // 比率部分的内边距
                            color: "#579ed2", // 比率部分颜色
                            fontfamily: "source han sans cn", // 比率部分字体
                        },
                    },
                },
                formatter: function (name) { // 格式化图例项的显示内容
                    let total = 0; // 总值
                    let target; // 目标值
                    for (let i = 0; i < optionsdata.length; i++) {
                        total += optionsdata[i].value; // 计算总值
                        if (optionsdata[i].name === name) { // 查找目标值
                            target = optionsdata[i].value;
                        }
                    }
                    let arr = [
                        "{name|" + name + "}", // 名称
                        "{value|" + "}", // 数值（未赋值需补充）
                        "{rate|" + ((target / total) * 100).tofixed(1) + "%}", // 比率
                    ];
                    return arr.join(""); // 返回格式化后的字符串
                },
            },
            animation: true, // 开启动画效果
            tooltip: {
                backgroundcolor: "rgba(64, 180, 176, 0.6)", // 提示框的背景颜色
                bordercolor: "rgba(64, 180, 176, 0.6)", // 提示框的边框颜色
                textstyle: {
                    color: "#fff", // 提示文本颜色
                    fontsize: 24, // 提示文本字体大小
                },
                formatter: (params) => { // 格式化提示框内容
                    if (
                        params.seriesname !== "mouseoutseries" &&
                        params.seriesname !== "pie2d" // 排除特定系列
                    ) {
                        return `${params.seriesname
                            }<br/><span style="display:inline-block;margin-right:5px;border-radius:10px;width:10px;height:10px;background-color:${params.color
                            };"></span>${option.series[params.seriesindex].piedata.value + "万人"
                            }`; // 返回系列名称和数值
                    }
                },
            },
            labelline: {
                show: true, // 显示标签连接线
                linestyle: {
                    color: "#7bc0cb", // 标签连接线颜色
                },
                normal: {
                    show: true, // 正常状态显示
                    length: 10, // 连接线长度
                    length2: 10, // 连接线第二段长度
                },
            },
            label: {
                show: true, // 显示标签
                position: "outside", // 标签位置
                formatter: "{b} \n{c}\n{d}%", // 标签格式
                textstyle: {
                    color: "rgba(176, 216, 223, 1)", // 标签文本颜色
                    fontsize: 24, // 标签字体大小
                },
            },
            xaxis3d: {
                min: -1, // x轴最小值
                max: 1, // x轴最大值
            },
            yaxis3d: {
                min: -1, // y轴最小值
                max: 1, // y轴最大值
            },
            zaxis3d: {
                min: -1, // z轴最小值
                max: 1, // z轴最大值
            },
            grid3d: {
                show: false, // 是否显示3d网格
                boxheight: 1, // 3d盒子的高度
                left: -40, // 3d图形左边距
                top: -10, // 3d图形顶部边距
                width: "50%", // 3d图形宽度
                viewcontrol: {
                    distance: 280, // 视距
                    alpha: 20, // 视角的俯仰角
                    beta: 15, // 视角的旋转角
                    autorotate: true, // 是否自动旋转
                    rotatesensitivity: 1, // 旋转灵敏度
                    zoomsensitivity: 0, // 缩放灵敏度
                    pansensitivity: 0, // 平移灵敏度
                },
            },
            series: series, // 数据系列
        };
        

        mychart.setoption(option);
    }, []);

    return (
        <div classname='left-echarts'>
            <div classname='left-top-nav'>
                团队概况
            </div>
            <div style={{ width: "496px", height: "270px", position: "relative" }}>
                <div ref={chartdom} style={{ width: "100%", height: "100%", zindex: "5" }}></div>
                <div classname="bg"></div>
            </div>
        </div>
    );
};

export default leftecharts;