echarts写3d圆环,并解决圆环数据相同时显示异常问题

这篇具有很好参考价值的文章主要介绍了echarts写3d圆环,并解决圆环数据相同时显示异常问题。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

效果图:

echarts 3d圆环,echarts,3d,javascript

用到的插件(安装时版本号必须对应否则无效):

  • “echarts”: “^4.9.0”,

  • “echarts-gl”: “^1.1.2”,

代码分两个文件:

1.mixins.js文件:
/**
 * 绘制3d图
 * @param pieData 总数据
 * @param internalDiameterRatio:透明的空心占比
 * @param distance 视角到主体的距离
 * @param alpha 旋转角度
 * @param pieHeight 立体的高度
 * @param opacity 饼或者环的透明度
 * @param dropSize 饼图下的点的大小
 */
const getPie3D = (
  pieData,
  internalDiameterRatio,
  distance,
  alpha,
  pieHeight,
  opacity = 1,
  dropSize,
) => {
  const series = [];
  let sumValue = 0;
  let startValue = 0;
  let endValue = 0;
  let legendData = [];
  let legendBfb = [];
  const k = 1 - internalDiameterRatio;
  pieData.sort((a, b) => {
    return b.value - a.value;
  });
  // 为每一个饼图数据,生成一个 series-surface 配置
  for (let i = 0; i < pieData.length; i++) {
    sumValue += pieData[i].value;
    const seriesItem = {
      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,
      },
      center: ['10%', '50%'],
    };
    if (typeof pieData[i].itemStyle !== 'undefined') {
      const itemStyle = {};
      itemStyle.color =
        typeof pieData[i].itemStyle.color !== 'undefined' ? pieData[i].itemStyle.color : opacity;
      itemStyle.opacity =
        typeof pieData[i].itemStyle.opacity !== 'undefined'
          ? pieData[i].itemStyle.opacity
          : opacity;
      seriesItem.itemStyle = itemStyle;
    }
    series.push(seriesItem);
  }

  // 使用上一次遍历时,计算出的数据和 sumValue,调用 getParametricEquation 函数,
  // 向每个 series-surface 传入不同的参数方程 series-surface.parametricEquation,也就是实现每一个扇形。
  legendData = [];
  legendBfb = [];
  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;
    const arr =
      series.length &&
      series.map((item) => {
        return item.pieData.value;
      });
    const temp = [];
    arr.forEach((item) => {
      if (!temp.includes(item)) {
        temp.push(item);
      }
    });
    const h = temp.length === 1 ? 5 : series[i].pieData.value;
    series[i].parametricEquation = getParametricEquation(
      series[i].pieData.startRatio,
      series[i].pieData.endRatio,
      false,
      false,
      k,
      h,
    );
    startValue = endValue;
    const bfb = fomatFloat(series[i].pieData.value / sumValue, 4);
    legendData.push({
      name: series[i].name,
      value: bfb,
    });
    legendBfb.push({
      name: series[i].name,
      value: bfb,
    });
  }
  const boxHeight = getHeight3D(series, pieHeight); // 通过pieHeight设定3d饼/环的高度,单位是px
  // 准备待返回的配置项,把准备好的 legendData、series 传入。
  const option = {
    legend: {
      selectedMode: false,
      show: Object.freeze(false),
      data: legendData,
      orient: Object.freeze('horizontal'),
      left: Object.freeze('center'),
      top: Object.freeze('bottom'),
      // 图例文字每项之间的间隔
      itemGap: Object.freeze(15),
      textStyle: {
        color: '#fff',
        fontSize: dropSize,
      },
      icon: Object.freeze('circle'),
      formatter(param) {
        const item = legendBfb.filter((val) => val.name === param)[0];
        return `${item.name}  `;
      },
    },
    labelLine: Object.freeze({
      show: false,
      lineStyle: {
        color: '#fff',
      },
    }),
    label: Object.freeze({
      show: false,
      position: 'outside',
      formatter: '{b} \n{c} {d}%',
    }),
    tooltip: {
      // backgroundColor: Object.freeze('#033b77'),
      // borderColor: Object.freeze('#21f2c4'),
      textStyle: Object.freeze({
        color: '#fff',
        fontSize: 13,
      }),
      formatter: (params) => {
        if (params.seriesName !== 'mouseoutSeries') {
          const endRatioTemp =
            option.series[params.seriesIndex].pieData &&
            option.series[params.seriesIndex].pieData.endRatio;
          const startRatioTemp =
            option.series[params.seriesIndex].pieData &&
            option.series[params.seriesIndex].pieData.startRatio;
          const bfb = ((endRatioTemp - startRatioTemp) * 100).toFixed(2);
          // 最初始的
          // return (
          //   !isNaN(bfb) ? (`${params.seriesName}<br/>` +
          //     `<span style='display:inline-block;margin-right:.3125rem;border-radius:.625rem;width:.625rem;height:.625rem;background-color:${params.color};'></span>` +
          //     `${bfb}%`) : ''
          // );
          return !isNaN(bfb)
            ? `<span style='font-size:${dropSize}px;'>${params.seriesName}</span><br/>` +
                `<span style='display:inline-block;margin-right:.3125rem;border-radius:.625rem;width:.625rem;height:.625rem;background-color:${params.color};'></span>` +
                `${bfb}%`
            : '';
        }
      },
    },
    xAxis3D: {
      min: -1,
      max: 1,
    },
    yAxis3D: {
      min: -1,
      max: 1,
    },
    zAxis3D: {
      min: -1,
      max: 1,
    },
    grid3D: {
      show: false,
      boxHeight, // 圆环的高度
      viewControl: {
        // 3d效果可以放大、旋转等,请自己去查看官方配置
        alpha: 35, // 角度
        distance, // 调整视角到主体的距离,类似调整zoom
        rotateSensitivity: 0, // 设置为0无法旋转
        zoomSensitivity: 0, // 设置为0无法缩放
        panSensitivity: 0, // 设置为0无法平移
        autoRotate: false, // 自动旋转
      },
    },
    series,
  };
  return option;
};

/**
 * 生成扇形的曲面参数方程,用于 series-surface.parametricEquation
 */
const getParametricEquation = (startRatio, endRatio, isSelected, isHovered, k, h) => {
  // 计算
  const midRatio = (startRatio + endRatio) / 2;
  const startRadian = startRatio * Math.PI * 2;
  const endRadian = endRatio * Math.PI * 2;
  const midRadian = midRatio * Math.PI * 2;
  // 如果只有一个扇形,则不实现选中效果。
  if (startRatio === 0 && endRatio === 1) {
    isSelected = false;
  }
  // 通过扇形内径/外径的值,换算出辅助参数 k(默认值 1/3)
  k = typeof k !== 'undefined' ? k : 1 / 3;
  // 计算选中效果分别在 x 轴、y 轴方向上的位移(未选中,则位移均为 0)
  const offsetX = isSelected ? Math.cos(midRadian) * 0.1 : 0;
  const offsetY = isSelected ? Math.sin(midRadian) * 0.1 : 0;
  // 计算高亮效果的放大比例(未高亮,则比例为 1)
  const 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(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(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(u, v) {
      if (u < -Math.PI * 0.5) {
        return Math.sin(u);
      }
      if (u > Math.PI * 2.5) {
        // console.log('if内部h', h);
        // console.log('if内部结果', Math.sin(u) * h * 0.1);
        return Math.sin(u) * h * 0.2;
        // return Math.sin(u) * 13 * 0.1;
      }
      // console.log('if外部h', h);
      // console.log('if外部结果', Math.sin(v) > 0 ? 1 * h * 0.1 : -1);
      return Math.sin(v) > 0 ? 1 * h * 0.2 : -1;
      // return Math.sin(v) > 0 ? 1 * 13 * 0.1 : -1;
    },
  };
};

/**
 * 获取3d丙图的最高扇区的高度
 */
const getHeight3D = (series, height) => {
  const arr =
    series.length &&
    series.map((item) => {
      return item.pieData.value;
    });
  const temp = [];
  arr.forEach((item) => {
    if (!temp.includes(item)) {
      temp.push(item);
    }
  });

  series.sort((a, b) => {
    return b.pieData.value - a.pieData.value;
  });
  const result = temp.length === 1 ? 25 : (height * 25) / series[0].pieData.value;
  return result;
};

/**
 * 格式化浮点数
 */
const fomatFloat = (num, n) => {
  let f = parseFloat(num);
  if (isNaN(f)) {
    return false;
  }
  f = Math.round(num * Math.pow(10, n)) / Math.pow(10, n); // n 幂
  let s = f.toString();
  let rs = s.indexOf('.');
  // 判定如果是整数,增加小数点再补0
  if (rs < 0) {
    rs = s.length;
    s += '.';
  }
  while (s.length <= rs + n) {
    s += '0';
  }
  return s;
};

export { getPie3D, getParametricEquation };
2.pieChart.vue文件:
<template>
  <div class="chart-container">
    <div class="chart" ref="chart"></div>
  </div>
</template>
<script>
import echarts from 'echarts';
// import _ from 'lodash';
import 'echarts-gl';
import { getPie3D, getParametricEquation } from './mixins/index';
const color = ['#2C6DEF', '#AC2424', '#2DB62E', '#DCC436', '#804AE8', '#25C5DA'];
export default {
  name: 'chart',
  props: {
    netDefenseSituList: {
      type: Array,
      default: () => [],
    },
  },
  data() {
    return {
      optionData: [],
      statusChart: null,
      option: {},
    };
  },
  created() {
    this.setLabel();
  },
  mounted() {
    this.initChart();
    window.addEventListener('resize', this.resizeChart);
  },
  watch: {
    netDefenseSituList: {
      deep: true,
      immediate: true,
      handler(val) {
        const tempArr = [];
        val.forEach((item) => {
          tempArr.push({
            name: item.title,
            value: item.defenseNumber,
          });
        });
        this.optionData = tempArr;
      },
    },
  },
  methods: {
    resizeChart() {
      this.changeSize();
    },
    setLabel() {
      const fontFamily = 'sans-serif';
      const fontSize = this.chartFontSize;
      const textStyle = {
        fontSize,
        fontFamily,
      };
      const { pieLength, pieLineHeight } = this.adapterData;
      this.optionData.forEach((item, index) => {
        item.legend = {
          show: false,
        };
        item.itemStyle = {
          color: color[index],
        };
        item.textStyle = { ...textStyle };
        item.label = {
          normal: {
            show: false,
            // color: color[index],
            color: '#ffffff',
            fontSize,
            fontFamily,
            position: Object.freeze('right'),
            offset: [0, 3],
            textStyle: {
              ...textStyle,
              color: '#ffffff',
            },
            formatter: ['{b|{b}}', '{d|{d}%}'].join('\n'), // 用\n来换行
            rich: {
              b: {
                color: '#ffffff',
                fontSize,
                fontFamily,
                lineHeight: 25,
                align: Object.freeze('left'),
              },
              c: {
                color: '#ffffff',
                fontSize,
                fontFamily,
                textShadowColor: Object.freeze('#1c90a6'),
                textShadowOffsetX: 0,
                textShadowOffsetY: 2,
                textShadowBlur: 5,
              },
              d: {
                color: '#ffffff',
                fontSize,
                fontFamily,
                lineHeight: pieLineHeight,
                align: Object.freeze('left'),
              },
            },
          },
        };
        item.labelLine = {
          normal: {
            show: false,
            length: 0,
            length2: Object.freeze(0),
            // smooth: true,
            lineStyle: {
              width: 0,
              // color: color[index],
              color: '#ffffff',
            },
          },
        };
      });
    },
    initChart() {
      const fontFamily = 'sans-serif';
      const fontSize = this.chartFontSize - 4;
      this.statusChart = echarts.init(this.$refs.chart);
      // this.option = getPie3D(this.optionData, 0.75, 180, 30, 6, 1, this.chartFontSizeTwo);
      this.option = getPie3D(this.optionData, 0.75, this.pieView, 30, 6, 1, this.chartFontSizeTwo);
      this.statusChart.setOption(this.option);
      // 是否需要label指引线,如果要就添加一个透明的2d饼状图并调整角度使得labelLine和3d的饼状图对齐,并再次setOption
      this.option.series.push({
        backgroundColor: Object.freeze('transparent'),
        type: Object.freeze('pie'),
        label: Object.freeze({
          opacity: 0,
          color: '#ffffff',
          fontSize,
          fontFamily,
          lineHeight: 0,
        }),
        // startAngle: -40, // 起始角度,支持范围[0, 360]。
        startAngle: -30, // 起始角度,支持范围[0, 360]。
        clockwise: false, // 饼图的扇区是否是顺时针排布。上述这两项配置主要是为了对齐3d的样式
        // radius: Object.freeze(['20%', '60%']),
        // center: Object.freeze(['50%', '50%']),
        radius: Object.freeze(['20%', '45%']),
        center: Object.freeze(['50%', '50%']),
        data: this.optionData,
        itemStyle: Object.freeze({
          opacity: 0, // 这里必须是0,不然2d的图会覆盖在表面
        }),
        // pieStatus: {
        //   // selected: false,
        //   // hovered: false,
        //   // k: 0,
        // },
        // pieData: {
        //   // startRatio: 0,
        // },
      });
      this.option = {
        ...this.option,
        tooltip: {
          textStyle: {
            color: '#ffffff',
            fontSize,
            fontFamily,
          },
        },
        grid: {
          top: '2%',
          left: '8%',
        },
      };
      this.statusChart.setOption(this.option);
      this.bindListen(this.statusChart);
    },
    // 监听鼠标事件,实现饼图选中效果(单选),近似实现高亮(放大)效果。
    // optionName是防止有多个图表进行定向option传递,单个图表可以不传,默认是opiton
    bindListen(myChart, optionName = 'option') {
      // let selectedIndex = '';
      let hoveredIndex = '';
      // 监听 mouseover,近似实现高亮(放大)效果
      // myChart.on('mouseover', (params) => {
      //   // 准备重新渲染扇形所需的参数
      //   let isSelected;
      //   let isHovered;
      //   let startRatio;
      //   let endRatio;
      //   let k;
      //   // 如果触发 mouseover 的扇形当前已高亮,则不做操作
      //   if (hoveredIndex === params.seriesIndex) {
      //     // 否则进行高亮及必要的取消高亮操作
      //   } else {
      //     // 如果当前有高亮的扇形,取消其高亮状态(对 option 更新)
      //     if (hoveredIndex !== '') {
      //       // 从 option.series 中读取重新渲染扇形所需的参数,将是否高亮设置为 false。
      //       isSelected = this[optionName].series[hoveredIndex].pieStatus.selected;
      //       isHovered = false;
      //       startRatio = this[optionName].series[hoveredIndex].pieData.startRatio;
      //       endRatio = this[optionName].series[hoveredIndex].pieData.endRatio;
      //       k = this[optionName].series[hoveredIndex].pieStatus.k;
      //       // 对当前点击的扇形,执行取消高亮操作(对 option 更新)
      //       this[optionName].series[hoveredIndex].parametricEquation = getParametricEquation(
      //         startRatio,
      //         endRatio,
      //         isSelected,
      //         isHovered,
      //         k,
      //         this[optionName].series[hoveredIndex].pieData.value,
      //       );
      //       this[optionName].series[hoveredIndex].pieStatus.hovered = isHovered;
      //       // 将此前记录的上次选中的扇形对应的系列号 seriesIndex 清空
      //       hoveredIndex = '';
      //     }
      //     // 如果触发 mouseover 的扇形不是透明圆环,将其高亮(对 option 更新)
      //     if (params.seriesName !== 'mouseoutSeries') {
      //       isSelected =
      //         this[optionName].series[params.seriesIndex].pieStatus &&
      //         this[optionName].series[params.seriesIndex].pieStatus.selected;
      //       isHovered = true;
      //       startRatio =
      //         this[optionName].series[params.seriesIndex].pieData &&
      //         this[optionName].series[params.seriesIndex].pieData.startRatio;
      //       endRatio =
      //         this[optionName].series[params.seriesIndex].pieData &&
      //         this[optionName].series[params.seriesIndex].pieData.endRatio;
      //       k =
      //         this[optionName].series[params.seriesIndex].pieStatus &&
      //         this[optionName].series[params.seriesIndex].pieStatus.k;
      //       // -------
      //       // 对当前点击的扇形,执行高亮操作(对 option 更新)
      //       this[optionName].series[params.seriesIndex].parametricEquation = getParametricEquation(
      //         startRatio,
      //         endRatio,
      //         isSelected,
      //         isHovered,
      //         k,
      //         _.get(this[optionName], 'series[params.seriesIndex].pieData.value', 0) + 10,
      //       );
      //       this[optionName].series[params.seriesIndex].pieStatus.hovered = isHovered;
      //       // 记录上次高亮的扇形对应的系列号 seriesIndex
      //       hoveredIndex = params.seriesIndex;
      //     }
      //     // 使用更新后的 option,渲染图表
      //     myChart.setOption(this[optionName]);
      //   }
      // });
      // 修正取消高亮失败的 bug
      myChart.on('globalout', () => {
        // 准备重新渲染扇形所需的参数
        let isSelected;
        let isHovered;
        let startRatio;
        let endRatio;
        let k;
        if (hoveredIndex !== '') {
          // 从 option.series 中读取重新渲染扇形所需的参数,将是否高亮设置为 true。
          isSelected = this[optionName].series[hoveredIndex].pieStatus.selected;
          isHovered = false;
          k = this[optionName].series[hoveredIndex].pieStatus.k;
          startRatio = this[optionName].series[hoveredIndex].pieData.startRatio;
          endRatio = this[optionName].series[hoveredIndex].pieData.endRatio;
          // 对当前点击的扇形,执行取消高亮操作(对 option 更新)
          this[optionName].series[hoveredIndex].parametricEquation = getParametricEquation(
            startRatio,
            endRatio,
            isSelected,
            isHovered,
            k,
            this[optionName].series[hoveredIndex].pieData.value,
          );
          this[optionName].series[hoveredIndex].pieStatus.hovered = isHovered;
          // 将此前记录的上次选中的扇形对应的系列号 seriesIndex 清空
          hoveredIndex = '';
        }
        // 使用更新后的 option,渲染图表
        myChart.setOption(this[optionName]);
      });
    },
    // 自适应宽高
    changeSize() {
      this.statusChart.resize();
    },
  },
  beforeDestroy() {
    window.removeEventListener('resize', this.resizeChart);
  },
};
</script>
<style lang="less" scoped>
.chart-container {
  // position: relative;
  /* width: 549px; */
  /* height: 472px; */
  width: 100%;
  height: 100%;
  padding-bottom: 20px;
  flex: 1;
  .chart {
    z-index: 1;
  }
  .chart {
    width: 100%;
    height: 100%;
  }
}
</style>

页面引用:

netDefenseSituList:为传入的数据文章来源地址https://www.toymoban.com/news/detail-768190.html

 <pic-chart :netDefenseSituList="netDefenseSituList" />

到了这里,关于echarts写3d圆环,并解决圆环数据相同时显示异常问题的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Echarts折线图交点呈现为圆点加圆环的效果实现

    series中的symbolSize设置圆点大小,itemStyle中的color设置圆点颜色,外圆环使用边框属性实现即borderWidth、borderColor: 效果:

    2024年02月12日
    浏览(56)
  • []关于解决pytorch训练神经网络时显存一直增长的问题

    @[原创]关于解决pytorch训练神经网络时显存一直增长的问题 在训练自定义loss和自定义网络结构的一个模型的时候,发现模型和数据都比较简单的情况下,在训练过程中居然把24g的显卡拉爆了显存。 然后使用nvidia-smi -l观察显存变化,发现是有规律的显存一直增加,直到OOM。 在

    2024年02月14日
    浏览(45)
  • 解决echarts配置滚动(dataZoom)后导出图片数据不全问题

    先展现一个echarts,并配置dataZoom,每页最多10条数据,超出滚动 效果: 调用echarts中getDataURL获取图表的数据 URL 问题来了:如数据不分页则可以下载全数据,如数据分页了则只能下载出可视区内容,如何解决? 解决思路:echarts最终生成了canvas,canvas的宽高就是当前可视区的宽

    2024年01月19日
    浏览(42)
  • 解决vue3集成echarts数据刷新后图表不刷新问题

    vue3 集成 echarts 最大的坑就是出现了,reactive 的数据 刷新了,但图表缺不会刷新,查了很多资料,试了很多方式都没效果,最后测试出来解决方法很简单: 核心代码: 附上 TSX 整个页面参考

    2024年02月13日
    浏览(53)
  • HighCharts实现3D不同高度圆环图、3D饼图

    最近做可视化比较多,就常用的图表类型做了一下总结。 因为做可视化的图表代码量非常大,所以会把echarts图表单独抽离出来,封装成一个组件,也可以复用,所以这里我直接把封装的组件直接放在这里,是可以直接拿来用的,根据所需稍作修改即可。 这里都是用的vue3,其

    2024年02月12日
    浏览(29)
  • 解决TortoiseGit软件Git Show log时显示Too many files to display的问题

    有时代码提交修改的文件比较多,当查看log时无法显示出来修改的文件列表,如下所示: 将LogTooManyItemsThreshold尽可能配置得大一些。 https://gitlab.com/tortoisegit/tortoisegit/-/issues/3878

    2024年04月12日
    浏览(39)
  • Vue——printjs打印el-table,echarts等打印不全,异常解决

    PrintJs简单使用 PrintJs官网地址:https://printjs.crabbly.com/ 1、可以从GitHub版本下载最新版本的Print.js:https://github.com/crabbly/Print.js/releases 2、npm 安装 更多参考:https://blog.csdn.net/sunxiaoju/article/details/126284860 echarts无法打印解决 修改print.js的getHtml,增加对canvas的处理,将echarts转为图片

    2024年02月06日
    浏览(36)
  • 【算法】【差分数组】解决连续空间改变相同值的问题

    将原数组每个值减去前一个值,得到的新数组是差分数组 d i s [ k ] = a [ k ] − a [ k − 1 ] dis[k] = a[k] - a[k-1] d i s [ k ] = a [ k ] − a [ k − 1 ] 如: 原数组为 [ 1 , 2 , 3 , 5 ] [1,2,3,5] [ 1 , 2 , 3 , 5 ] 得到的差分数组为 [ 1 , 1 , 1 , 2 ] [1,1,1,2] [ 1 , 1 , 1 , 2 ] 通过计算差分数组的前缀和,可以得

    2024年02月08日
    浏览(74)
  • css的rotate3d实现炫酷的圆环转动动画

    2.1 rotate3d rotate3d:rotate3d() CSS 函数定义一个变换,它将元素围绕固定轴移动而不使其变形。运动量由指定的角度定义; 如果为正,运动将为顺时针,如果为负,则为逆时针。 语法: 含义: x 类型,可以是 0 到 1 之间的数值,表示旋转轴 X 坐标方向的矢量。 y 类型,可以是 0

    2024年02月02日
    浏览(46)
  • es elasticsearch 十四 各种机制 评分机制 正序索引 解决跳跃结果问题 解决耗时过长问题 解决相同属性值都到一个地方

    目录 评分机制 机制 查看评分实现如何算出来的explain=true 分析能否被搜索到 Doc value 正排序索引 Query phase Fetch phase Preference 问题 解决跳跃结果问题 Timeout 到达时间直接返回,解决耗时过长问题 Routing 数据准确分配到某地,解决相同属性值都到一个地方 评分机制 机制 TF分词频

    2024年02月08日
    浏览(74)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包