devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

android 图表开源库MPAndroidChart 实现PieChart 圆环颜色渐变效果_android com.github.mikephil.charting.charts.piecha

作者：我家自动化 | 2024-03-17 07:16:22

赞

踩

android com.github.mikephil.charting.charts.piechart 渐变

项目中图表控件用的是MPAndroidChart 开源库，在显示PieChart时想要实现圆环渐变色，在网上查找一番没有找到能实现这个效果的方式，经过一番搜索查找发现只要给PieChartRenderer 这个类的mRenderPaint 设置渐变的shader 即可，所以写一个类继承PieChartRenderer直接直接重写他的drawDataSet这个方法，其实也就是把他原来代码全部拷贝过来，然后做下调整，增加线性渐变，在设置渐变方向的时候需要获取到每个扇形的起始和结束点坐标，然后设置到LinearGradient 里面，这样才能保证渐变效果，同时对于只有一条数据的情况需要单独调整下渐变的起始和结束点，不然就没法产生渐变效果，最终实现的效果如下

  1.  
  2.  
  3. import android.graphics.Canvas;
  4. import android.graphics.LinearGradient;
  5. import android.graphics.Path;
  6. import android.graphics.RectF;
  7. import android.graphics.Shader;
  8.  
  9. import com.github.mikephil.charting.animation.ChartAnimator;
  10. import com.github.mikephil.charting.charts.PieChart;
  11. import com.github.mikephil.charting.data.Entry;
  12. import com.github.mikephil.charting.interfaces.datasets.IPieDataSet;
  13. import com.github.mikephil.charting.renderer.PieChartRenderer;
  14. import com.github.mikephil.charting.utils.MPPointF;
  15. import com.github.mikephil.charting.utils.Utils;
  16. import com.github.mikephil.charting.utils.ViewPortHandler;
  17. import com.socks.library.KLog;
  18.  
  19.  
  20. public class SuddleBluePieChartRenderer extends PieChartRenderer {
  21.     private Path mPathBuffer = new Path();
  22.     private RectF mInnerRectBuffer = new RectF();
  23.     public SuddleBluePieChartRenderer(PieChart chart, ChartAnimator animator, ViewPortHandler viewPortHandler) {
  24.         super(chart, animator, viewPortHandler);
  25.     }
  26.  
  27.  
  28.     @Override
  29.     protected void drawDataSet(Canvas c, IPieDataSet dataSet) {
  30.  
  31.         float angle = 0;
  32.         float rotationAngle = mChart.getRotationAngle();
  33.  
  34.         float phaseX = mAnimator.getPhaseX();
  35.         float phaseY = mAnimator.getPhaseY();
  36.  
  37.         final RectF circleBox = mChart.getCircleBox();
  38.  
  39.         final int entryCount = dataSet.getEntryCount();
  40.         final float[] drawAngles = mChart.getDrawAngles();
  41.         final MPPointF center = mChart.getCenterCircleBox();
  42.         final float radius = mChart.getRadius();
  43.         final boolean drawInnerArc = mChart.isDrawHoleEnabled() && !mChart.isDrawSlicesUnderHoleEnabled();
  44.         final float userInnerRadius = drawInnerArc
  45.                 ? radius * (mChart.getHoleRadius() / 100.f)
  46.                 : 0.f;
  47.         final float roundedRadius = (radius - (radius * mChart.getHoleRadius() / 100f)) / 2f;
  48.         final RectF roundedCircleBox = new RectF();
  49.         final boolean drawRoundedSlices = drawInnerArc && mChart.isDrawRoundedSlicesEnabled();
  50.  
  51.         int visibleAngleCount = 0;
  52.         for (int j = 0; j < entryCount; j++) {
  53.             // draw only if the value is greater than zero
  54.             if ((Math.abs(dataSet.getEntryForIndex(j).getY()) > Utils.FLOAT_EPSILON)) {
  55.                 visibleAngleCount++;
  56.             }
  57.         }
  58.  
  59.         final float sliceSpace = visibleAngleCount <= 1 ? 0.f : getSliceSpace(dataSet);
  60.  
  61.         for (int j = 0; j < entryCount; j++) {
  62.  
  63.  
  64. //            mRenderPaint.setShader(new LinearGradient(mChart.getWidth()/2 , mChart.getWidth()/2 -radius, mChart.getWidth()/2, mChart.getWidth()/2+radius,
  65. //                    mChart.getData().getDataSet().getGradientColor(j).getStartColor(),
  66. //                    mChart.getData().getDataSet().getGradientColor(j).getEndColor(), Shader.TileMode.CLAMP));
  67.  
  68. //            int[] colors = new int[]{mChart.getData().getDataSet().getGradientColor(j).getStartColor(),
  69. //                    mChart.getData().getDataSet().getGradientColor(j).getEndColor()};
  70. //            mRenderPaint.setShader(new SweepGradient(radius,radius,colors,null));
  71.  
  72.             float sliceAngle = drawAngles[j];
  73.             float innerRadius = userInnerRadius;
  74.  
  75.             Entry e = dataSet.getEntryForIndex(j);
  76.  
  77.             // draw only if the value is greater than zero
  78.             if (!(Math.abs(e.getY()) > Utils.FLOAT_EPSILON)) {
  79.                 angle += sliceAngle * phaseX;
  80.                 continue;
  81.             }
  82.  
  83.             // Don't draw if it's highlighted, unless the chart uses rounded slices
  84.             if (mChart.needsHighlight(j) && !drawRoundedSlices) {
  85.                 angle += sliceAngle * phaseX;
  86.                 continue;
  87.             }
  88.  
  89.             final boolean accountForSliceSpacing = sliceSpace > 0.f && sliceAngle <= 180.f;
  90.  
  91.             mRenderPaint.setColor(dataSet.getColor(j));
  92.  
  93.             final float sliceSpaceAngleOuter = visibleAngleCount == 1 ?
  94.                     0.f :
  95.                     sliceSpace / (Utils.FDEG2RAD * radius);
  96.             final float startAngleOuter = rotationAngle + (angle + sliceSpaceAngleOuter / 2.f) * phaseY;
  97.             float sweepAngleOuter = (sliceAngle - sliceSpaceAngleOuter) * phaseY;
  98.             if (sweepAngleOuter < 0.f) {
  99.                 sweepAngleOuter = 0.f;
  100.             }
  101.  
  102.             mPathBuffer.reset();
  103.  
  104.             if (drawRoundedSlices) {
  105.                 float x = center.x + (radius - roundedRadius) * (float) Math.cos(startAngleOuter * Utils.FDEG2RAD);
  106.                 float y = center.y + (radius - roundedRadius) * (float) Math.sin(startAngleOuter * Utils.FDEG2RAD);
  107.                 roundedCircleBox.set(x - roundedRadius, y - roundedRadius, x + roundedRadius, y + roundedRadius);
  108.             }
  109.  
  110.             float arcStartPointX = center.x + radius * (float) Math.cos(startAngleOuter * Utils.FDEG2RAD);
  111.             float arcStartPointY = center.y + radius * (float) Math.sin(startAngleOuter * Utils.FDEG2RAD);
  112.  
  113.             if (sweepAngleOuter >= 360.f && sweepAngleOuter % 360f <= Utils.FLOAT_EPSILON) {
  114.                 // Android is doing "mod 360"
  115.                 mPathBuffer.addCircle(center.x, center.y, radius, Path.Direction.CW);
  116.             } else {
  117.  
  118.                 if (drawRoundedSlices) {
  119.                     mPathBuffer.arcTo(roundedCircleBox, startAngleOuter + 180, -180);
  120.                 }
  121.  
  122.                 mPathBuffer.arcTo(
  123.                         circleBox,
  124.                         startAngleOuter,
  125.                         sweepAngleOuter
  126.                 );
  127.             }
  128.  
  129.             // API < 21 does not receive floats in addArc, but a RectF
  130.             mInnerRectBuffer.set(
  131.                     center.x - innerRadius,
  132.                     center.y - innerRadius,
  133.                     center.x + innerRadius,
  134.                     center.y + innerRadius);
  135.  
  136. //            mRenderPaint.setShader(new LinearGradient(center.x - innerRadius,
  137. //                    center.y - innerRadius,
  138. //                    center.x + innerRadius,
  139. //                    center.y + innerRadius,
  140. //                    mChart.getData().getDataSet().getGradientColor(j).getStartColor(),
  141. //                    mChart.getData().getDataSet().getGradientColor(j).getEndColor(), Shader.TileMode.CLAMP));
  142.  
  143. //            KLog.i(" xp "+mChart.getData().getDataSet().getXValuePosition()+" yp "+mChart.getData().getDataSet().getYValuePosition());
  144.  
  145.             // 获取每个扇形的起始点和结束点坐标
  146. //            float startAngleOuter1 = rotationAngle + (angle + sliceSpaceAngleOuter / 2.f) * phaseY;
  147.             float endAngleOuter = startAngleOuter + sweepAngleOuter;
  148.  
  149.             float startX = center.x + radius * (float) Math.cos(startAngleOuter * Utils.FDEG2RAD);
  150.             float startY = center.y + radius * (float) Math.sin(startAngleOuter * Utils.FDEG2RAD);
  151.  
  152.             float endX = center.x + radius * (float) Math.cos(endAngleOuter * Utils.FDEG2RAD);
  153.             float endY = center.y + radius * (float) Math.sin(endAngleOuter * Utils.FDEG2RAD);
  154.  
  155.             KLog.i("startX "+startX+" startY "+startY +" endX "+endX+" endY "+endY);
  156.             if (entryCount == 1)
  157.             {
  158.                 mRenderPaint.setShader(new LinearGradient(center.x - innerRadius,
  159.                         center.y - innerRadius,
  160.                         center.x + innerRadius,
  161.                         center.y + innerRadius,
  162.                         mChart.getData().getDataSet().getGradientColor(j).getStartColor(),
  163.                         mChart.getData().getDataSet().getGradientColor(j).getEndColor(), Shader.TileMode.CLAMP));
  164.             }
  165.             else
  166.             {
  167.                 mRenderPaint.setShader(new LinearGradient(startX,
  168.                         startY,
  169.                         endX ,
  170.                         endY,
  171.                         mChart.getData().getDataSet().getGradientColor(j).getStartColor(),
  172.                         mChart.getData().getDataSet().getGradientColor(j).getEndColor(), Shader.TileMode.CLAMP));
  173.             }
  174.  
  175.  
  176.  
  177.  
  178.  
  179.             if (drawInnerArc && (innerRadius > 0.f || accountForSliceSpacing)) {
  180.  
  181.                 if (accountForSliceSpacing) {
  182.                     float minSpacedRadius =
  183.                             calculateMinimumRadiusForSpacedSlice(
  184.                                     center, radius,
  185.                                     sliceAngle * phaseY,
  186.                                     arcStartPointX, arcStartPointY,
  187.                                     startAngleOuter,
  188.                                     sweepAngleOuter);
  189.  
  190.                     if (minSpacedRadius < 0.f)
  191.                         minSpacedRadius = -minSpacedRadius;
  192.  
  193.                     innerRadius = Math.max(innerRadius, minSpacedRadius);
  194.                 }
  195.  
  196.                 final float sliceSpaceAngleInner = visibleAngleCount == 1 || innerRadius == 0.f ?
  197.                         0.f :
  198.                         sliceSpace / (Utils.FDEG2RAD * innerRadius);
  199.                 final float startAngleInner = rotationAngle + (angle + sliceSpaceAngleInner / 2.f) * phaseY;
  200.                 float sweepAngleInner = (sliceAngle - sliceSpaceAngleInner) * phaseY;
  201.                 if (sweepAngleInner < 0.f) {
  202.                     sweepAngleInner = 0.f;
  203.                 }
  204.                 final float endAngleInner = startAngleInner + sweepAngleInner;
  205.  
  206.                 if (sweepAngleOuter >= 360.f && sweepAngleOuter % 360f <= Utils.FLOAT_EPSILON) {
  207.                     // Android is doing "mod 360"
  208.                     mPathBuffer.addCircle(center.x, center.y, innerRadius, Path.Direction.CCW);
  209.                 } else {
  210.  
  211.                     if (drawRoundedSlices) {
  212.                         float x = center.x + (radius - roundedRadius) * (float) Math.cos(endAngleInner * Utils.FDEG2RAD);
  213.                         float y = center.y + (radius - roundedRadius) * (float) Math.sin(endAngleInner * Utils.FDEG2RAD);
  214.                         roundedCircleBox.set(x - roundedRadius, y - roundedRadius, x + roundedRadius, y + roundedRadius);
  215.                         mPathBuffer.arcTo(roundedCircleBox, endAngleInner, 180);
  216.                     } else
  217.                         mPathBuffer.lineTo(
  218.                                 center.x + innerRadius * (float) Math.cos(endAngleInner * Utils.FDEG2RAD),
  219.                                 center.y + innerRadius * (float) Math.sin(endAngleInner * Utils.FDEG2RAD));
  220.  
  221.                     mPathBuffer.arcTo(
  222.                             mInnerRectBuffer,
  223.                             endAngleInner,
  224.                             -sweepAngleInner
  225.                     );
  226.                 }
  227.             } else {
  228.  
  229.                 if (sweepAngleOuter % 360f > Utils.FLOAT_EPSILON) {
  230.                     if (accountForSliceSpacing) {
  231.  
  232.                         float angleMiddle = startAngleOuter + sweepAngleOuter / 2.f;
  233.  
  234.                         float sliceSpaceOffset =
  235.                                 calculateMinimumRadiusForSpacedSlice(
  236.                                         center,
  237.                                         radius,
  238.                                         sliceAngle * phaseY,
  239.                                         arcStartPointX,
  240.                                         arcStartPointY,
  241.                                         startAngleOuter,
  242.                                         sweepAngleOuter);
  243.  
  244.                         float arcEndPointX = center.x +
  245.                                 sliceSpaceOffset * (float) Math.cos(angleMiddle * Utils.FDEG2RAD);
  246.                         float arcEndPointY = center.y +
  247.                                 sliceSpaceOffset * (float) Math.sin(angleMiddle * Utils.FDEG2RAD);
  248.  
  249.                         mPathBuffer.lineTo(
  250.                                 arcEndPointX,
  251.                                 arcEndPointY);
  252.  
  253.  
  254.                     } else {
  255.                         mPathBuffer.lineTo(
  256.                                 center.x,
  257.                                 center.y);
  258.                     }
  259.                 }
  260.  
  261.             }
  262.  
  263.             mPathBuffer.close();
  264.  
  265.             mBitmapCanvas.drawPath(mPathBuffer, mRenderPaint);
  266.  
  267.             angle += sliceAngle * phaseX;
  268.         }
  269.         mRenderPaint.setShader(null);
  270.  
  271.         MPPointF.recycleInstance(center);
  272.     }
  273. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/254795?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号