Android自定义Sunburst Chart（太阳图）

最新推荐文章于 2024-03-29 17:05:29 发布
最新推荐文章于 2024-03-29 17:05:29 发布
阅读量555 收藏
点赞数
分类专栏： 安卓 文章标签： 安卓 canvas ui android studio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_43847093/article/details/108011036
版权

功能

一种显示树形结构的图表，内圆是外圆的父节点，一层层显示绘制

效果图

使用示例

package com.eroad.product.tools;

import android.animation.ValueAnimator;
import android.app.Activity;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.Point;
import android.graphics.RectF;
import android.util.AttributeSet;
import android.util.DisplayMetrics;
import android.util.Log;
import android.view.Display;
import android.view.View;
import android.view.animation.AccelerateDecelerateInterpolator;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class SunBurstChart extends View {
    private float density;                                    //屏幕密度
    private float viewWidth;                                //控件宽度
    private float viewHeight;                                //控件高度
    private float pieCenterX, pieCenterY, pieRadius;        //圆心X轴坐标，圆心Y轴坐标，圆半径
    private Paint textPaint, piePaint, linePaint, criclePaint, ringPaint, inTextPaint;//文本画笔，扇形画笔，线画笔,内圆画笔,圆环画笔
    private RectF pieOval;                                    //矩形边界框
    private String TAG = "SunBurstChart";
    private float textSize = 14;        //字体大小
    private float cricle;                //内圆半径
    //扇形的弧度
    private ArrayList<Float> arraydegrees;
    private List<Point> inPoints;//内圆用以记录每个矩形的度数

    //内圆的饼图
    private RectF pieInOval;                                    //内圆矩形边界框
    private float inTotalValue;                                //总数
    //内圆扇形的弧度
    private ArrayList<Float> inArraydegrees;
    private List<Nodes> mDatas;
    private boolean animate = false;
    private int depth = 1;
    private Path textPath;
    private float ringWidth = 3f;//圆环宽度
    private float inTextSize = 12;        //内圆字体大小

    int[] colors = {Color.parseColor("#0288D1"), Color.parseColor("#F8BBD0"), Color.parseColor("#D4E157"), Color.parseColor("#FF6E40")}; //颜色值

    public SunBurstChart(Context context) {
        super(context);
        // TODO Auto-generated constructor stub

    }

    public SunBurstChart(Context context, AttributeSet attrs) {
        super(context, attrs);
        // TODO Auto-generated constructor stub
        //获取屏幕密度
        Display display = ((Activity) context).getWindowManager().getDefaultDisplay();
        DisplayMetrics displayMetrics = new DisplayMetrics();
        display.getMetrics(displayMetrics);
        density = displayMetrics.density;
    }

    public SunBurstChart(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        // TODO Auto-generated constructor stub
    }

    @Override
    protected void onDraw(Canvas canvas) {
        // TODO Auto-generated method stub
        super.onDraw(canvas);
        //获取控件的高度和宽度
        viewWidth = getWidth();
        viewHeight = getHeight();
        this.init();
        drawNormal(canvas);
    }

    private float animatedValue;//圆环动画

    private void initAnimator() {
        ValueAnimator anim = ValueAnimator.ofFloat(0, 360);
        anim.setDuration(5000);
        anim.setInterpolator(new AccelerateDecelerateInterpolator());
        anim.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {

            @Override
            public void onAnimationUpdate(ValueAnimator valueAnimator) {
                animatedValue = (float) valueAnimator.getAnimatedValue();
                invalidate();
            }
        });
        anim.start();
    }

    public void startDraw() {
        if (mDatas.size() > 0 && animate) {
            initAnimator();
        } else {
            postInvalidate();
        }
    }

    /**
     * 没有任何动画的圆
     *
     * @param canvas
     */
    public void drawNormal(Canvas canvas) {

        float start = 0.0f;
        if (mDatas == null) {
            return;
        }
        drawSunBurstChart(canvas);
    }

    Random random = new Random();

    private void drawSunBurstChart(Canvas canvas) {
        float start = 0.0f;
        int level = 2;
        int lastIndex = 0;
        for (int i = 0; i < mDatas.size(); i++) {
            Nodes parentNode = mDatas.get(i);
            double value = parentNode.getValue();
            String title = parentNode.getName();
            int index = random.nextInt(colors.length - 1);
            if (index == lastIndex) {
                index = random.nextInt(colors.length - 1);
            }
            int color = colors[index];

            float sweep = (float) (value / inTotalValue * 360);//计算度数
            inArraydegrees.add(sweep);


            drawChild(start, canvas, sweep, parentNode.getChildNodes(), level);
            drawInCircleAndLine(i, canvas, start, sweep, value, title, color);
            ringPaint.setStrokeWidth(ringWidth); //设置圆环的宽度
            canvas.drawCircle(pieCenterX, pieCenterY, cricle, ringPaint); //画出圆环

            inPoints.get(i).x = (int) start;
            inPoints.get(i).y = (int) (start) + (int) sweep;
            start += sweep;
            lastIndex = index;
        }
    }

    private void drawChild(float start, Canvas canvas, double angle, List<Nodes> childNodes, int level) {
        double childTotalValue = 0;
        for (int i = 0; i < childNodes.size(); i++) {
            Nodes child = childNodes.get(i);
            double value = child.getValue();
            childTotalValue += value;
        }
        for (int i = 0; i < childNodes.size(); i++) {
            Nodes child = childNodes.get(i);
            double value = child.getValue();
            String title = child.getName();
            float sweep = (float) (value / childTotalValue * angle);//计算度数
            if (child.hasChild()) {
                float tempstart = start;
                drawChild(tempstart, canvas, sweep, child.getChildNodes(), level + 1);
            }

            int color = colors[random.nextInt(colors.length - 1)];
            arraydegrees.add(sweep);
            piePaint.setColor(color);//设置颜色
            pieOval = new RectF(pieCenterX - cricle * level, pieCenterY - cricle * level, pieCenterX + cricle * level, pieCenterY + cricle * level);
            if (Math.min(sweep, animatedValue - start) >= 0 && animate) {
                canvas.drawArc(pieOval, start, Math.min(sweep - 1, animatedValue - start), true, piePaint);//画扇形
            } else {
                canvas.drawArc(pieOval, start, sweep, true, piePaint);//画扇形
                canvas.drawArc(pieOval, start, sweep, true,
                        ringPaint);
            }

            float radius = cricle * level - cricle / 2f;
            int middleAngle = (int) (start + sweep / 2);
            float textPointX = (float) (pieOval.centerX() + radius * Math.cos(Math.toRadians(middleAngle)));
            float textPointY = (float) (pieOval.centerY() + radius * Math.sin(Math.toRadians(middleAngle)));
            float textPointEndX = (float) (pieInOval.centerX() + cricle * (level - 1) * Math.cos(Math.toRadians(middleAngle)));
            float textPointEndY = (float) (pieInOval.centerY() + cricle * (level - 1) * Math.sin(Math.toRadians(middleAngle)));
            inTextPaint.setTextAlign(Paint.Align.LEFT);
            textPath.reset();
            textPath.moveTo(textPointX, textPointY);
            textPath.lineTo(textPointEndX, textPointEndY);
            canvas.drawTextOnPath(title, textPath, 0, 0, inTextPaint);
            start += sweep;
        }
    }

    /**
     * 内圆正常画圆和画线
     *
     * @param i
     * @param canvas
     * @param start
     * @param sweep
     */
    public void drawInCircleAndLine(int i, Canvas canvas, float start, float sweep, double value, String title, int color) {
        criclePaint.setColor(color);//设置颜色
        if (animate) {
            canvas.drawArc(pieInOval, start, Math.min(sweep, animatedValue - start), true, criclePaint);//画扇形
        } else {
            canvas.drawArc(pieInOval, start, sweep, true, criclePaint);//画扇形
            canvas.drawArc(pieInOval, start, sweep, true, ringPaint);//画边框

        }

        // 绘制圆环上扇形的文字
        int middleAngle = (int) (start + sweep / 2);

        float radius = (cricle) / 3f;
        float textPointX = (float) (pieInOval.centerX() + radius * Math.cos(Math.toRadians(middleAngle)));
        float textPointY = (float) (pieInOval.centerY() + radius * Math.sin(Math.toRadians(middleAngle)));

        float textPointEndX = (float) (pieInOval.centerX() + cricle * Math.cos(Math.toRadians(middleAngle)));
        float textPointEndY = (float) (pieInOval.centerY() + cricle * Math.sin(Math.toRadians(middleAngle)));
        inTextPaint.setTextAlign(Paint.Align.LEFT);
        textPath.reset();
        textPath.moveTo(textPointX, textPointY);
        textPath.lineTo(textPointEndX, textPointEndY);
        canvas.drawPath(textPath, linePaint);
        canvas.drawTextOnPath(title, textPath, 0, 0, inTextPaint);
    }

    //初始化画笔和画刷
    public void init() {
        float min = Math.min(viewWidth, viewHeight);//获取屏幕中高宽中的最小值，用以确认圆心位置
        pieCenterX = viewWidth / 2;
        pieCenterY = viewHeight / 2;
        pieRadius = 2 * min / 5;//获得饼图的半径
        cricle = pieRadius / depth;//内圆的半径
        textSize = 12 * density;//获取字体的大小
        //得到饼图的矩形
        pieOval = new RectF(pieCenterX - cricle, pieCenterY - cricle, pieCenterX + cricle, pieCenterY + cricle);
        //初始化文字的画笔
        textPaint = new Paint();
        textPaint.setAntiAlias(true);
        textPaint.setStyle(Paint.Style.FILL);
        textPaint.setTextSize(textSize);
        textPaint.setColor(Color.parseColor("#939393"));// 颜色
        //初始化饼图的画笔
        piePaint = new Paint();
        piePaint.setAntiAlias(true);
        piePaint.setStyle(Paint.Style.FILL);
        //初始化线的画笔
        linePaint = new Paint();
        linePaint.setAntiAlias(true);
        linePaint.setStyle(Paint.Style.FILL);
        linePaint.setStrokeWidth(1);
        linePaint.setColor(Color.parseColor("#939393"));// 颜色
        //初始化内圆的画笔
        criclePaint = new Paint();
        criclePaint.setAntiAlias(true);
        criclePaint.setStyle(Paint.Style.FILL);
        criclePaint.setColor(Color.parseColor("#ffffff"));
        pieInOval = new RectF(pieCenterX - cricle, pieCenterY - cricle, pieCenterX + cricle, pieCenterY + cricle);

        ringPaint = new Paint();//圆环画笔

        ringPaint.setColor(Color.parseColor("#ffffff")); //设置圆环的颜色
        ringPaint.setStyle(Paint.Style.STROKE); //设置空心
        ringPaint.setAntiAlias(true);  //消除锯齿

        inTextPaint = new Paint();//初始化内圆的字体画笔
        inTextPaint.setAntiAlias(true);
        inTextPaint.setStyle(Paint.Style.FILL);
        inTextPaint.setTextSize(inTextSize);
        inTextPaint.setColor(Color.parseColor("#ffffff"));// 颜色
        arraydegrees = new ArrayList<Float>();
        inArraydegrees = new ArrayList<Float>();
        //饼图放大部分的矩形
        textPath = new Path();


    }

    /**
     * 设置数据源
     *
     * @param nodes
     */
    public void setDatas(List<Nodes> nodes) {
        mDatas = nodes;
        inPoints = new ArrayList<>();
        inPoints = new ArrayList<>();
        for (Nodes node : nodes) {
            inTotalValue += node.getValue();
            Point point = new Point();
            inPoints.add(point);
            countNodeDepth(node.getChildNodes());
        }
        Log.i(TAG, "setDatas: " + depth);
        postInvalidate();//刷新
    }

    int depth1 = 2;

    public int countNodeDepth(List<Nodes> nodes) {
        for (Nodes node : nodes) {
            if (node.hasChild()) {
                depth1++;
                countNodeDepth(node.getChildNodes());
            } else {
                depth = Math.max(depth1, depth);
                depth1 = 2;
                continue;
            }
        }

        return depth1;
    }
}

数据结构

package com.eroad.product.tools;

import java.util.List;

/**
 * 节点实体类
 * @author Administrator
 *
 */
public class Nodes {

    private String id;

    //父节点
    private String pid;

    private String name;
    private double value;

    List<Nodes> childNodes;
    private boolean hasChild;

    public Nodes(String id, String pid, String name, double value) {
        this.id = id;
        this.pid = pid;
        this.name = name;
        this.value = value;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getPid() {
        return pid;
    }

    public void setPid(String pid) {
        this.pid = pid;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List<Nodes> getChildNodes() {
        return childNodes;
    }

    public void setChildNodes(List<Nodes> childNodes) {
        this.childNodes = childNodes;
    }

    public double getValue() {
        return value;
    }

    public void setValue(double value) {
        this.value = value;
    }

    public boolean hasChild() {
        return !(childNodes == null || childNodes.size() == 0);
    }
}

测试代码

package com.example.linecharttest.tab;

import com.eroad.product.tools.Nodes;
import com.eroad.product.tools.SunBurstChart;
import com.example.linecharttest.R;
import android.app.Activity;
import android.os.Bundle;

import java.util.ArrayList;
import java.util.List;

/**
 * 可点击的饼状图
 * @author wanjuanjuan
 *
 */
public class TestActivity extends Activity{

	private SunBurstChart ringview;
	private String TAG = "TestActivity"; //TAG

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		// TODO Auto-generated method stub
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_ring);
		ringview = (SunBurstChart) findViewById(R.id.ring);

		List<Nodes> parentNodes = new ArrayList<Nodes>();
		parentNodes.add(new Nodes("1","1","udp",2112));
		parentNodes.add(new Nodes("2","2","tcp",2000));
		parentNodes.add(new Nodes("3","3","其他",2000));
		parentNodes.add(new Nodes("4","4","更多",1000));

		for (int i= 0;i<parentNodes.size();i++){
			Nodes parentNode = parentNodes.get(i);
			List<Nodes> childNodes = new ArrayList<Nodes>();
			if(parentNode.getId().equals("1")){
				childNodes.add(new Nodes("5","1","餐饮",250));
				childNodes.add(new Nodes("6","1","娱乐",100));
				childNodes.add(new Nodes("7","1","学习",120));
			}
			if(parentNode.getId().equals("2")){
				childNodes.add(new Nodes("9","2","餐饮",200));
				childNodes.add(new Nodes("10","2","娱乐",100));
			}

			if(parentNode.getId().equals("3")){
				childNodes.add(new Nodes("11","3","餐饮",300));
				childNodes.add(new Nodes("12","3","学习",120));
			}

			if(parentNode.getId().equals("4")){
				childNodes.add(new Nodes("13","4","餐饮",100));
				childNodes.add(new Nodes("14","4","娱乐",100));
				childNodes.add(new Nodes("15","4","人际关系",160));
			}
			parentNode.setChildNodes(childNodes);
		}

		for (int i= 0;i<parentNodes.size();i++){
			Nodes parentNode = parentNodes.get(i);
			List<Nodes> childNodes = parentNode.getChildNodes();
			for (int j= 0;j<childNodes.size();j++){
				Nodes childNode = childNodes.get(j);
				List<Nodes> childchildNodes = new ArrayList<Nodes>();
				String id = j*10+"";
				childchildNodes.add(new Nodes(id, childNode.getId(), "餐饮", 200));
				childchildNodes.add(new Nodes(id, childNode.getId(), "娱乐", 100));
				childNode.setChildNodes(childchildNodes);
			}
		}

		for (int i= 0;i<parentNodes.size();i++){
			Nodes parentNode = parentNodes.get(i);
			List<Nodes> childNodes = parentNode.getChildNodes();
			for (int j= 0;j<childNodes.size();j++){
				List<Nodes> childchildNodes = childNodes.get(j).getChildNodes();
				for (int k= 0;k<childchildNodes.size();k++){
					Nodes childchildNode = childchildNodes.get(k);
					List<Nodes> childchildchildNodes = new ArrayList<Nodes>();
					String id = k*10+"";
					childchildchildNodes.add(new Nodes(id, childchildNode.getId(), "餐饮", 20));
					childchildchildNodes.add(new Nodes(id, childchildNode.getId(), "娱乐", 10));
					childchildchildNodes.add(new Nodes(id, childchildNode.getId(), "学习", 12));
					childchildNode.setChildNodes(childchildchildNodes);
				}

			}
		}
		ringview.setDatas(parentNodes);
		ringview.startDraw();
	}

}

正在开发的功能

动画，手势放大，显示优化（现在还有点丑）

太阳图Sunburst chart构建多层饼图
qq_40523298的博客
09-26 582
基本上，太阳图是一种多层饼图。由于能够在一个图表中表达多层数据，这是显示多元分类数据或分层数据的良好选择。，这是一个强大的Python库，用于创建数据可视化。顺便说一下，这可以通过使用颜色标度来区分值或创建一个可以进行筛选的交互式太阳图来解决。使用太阳图的一个限制是，如果每个级别中有太多的类别，注释的密度会受到限制。生成的数据集包含了购物顾客的信息：地点、产品、付款方式、性别和年龄段。在相同级别上，每个项目的面积表示其与其他项目的百分比比较。可以使用random库生成每个分类变量，如下所示的代码。
Android custom view--实时太阳轨迹
突破吧！次元壁
04-14 652
代码实例 假装这里有个动图 大概有一个半⚪，表示从日出到日落这段时间，根据当前时间把☀绘制到合适的地方。但是⚪不好看，最后换成椭圆了。 attr.xml <?xml version="1.0" encoding="utf-8"?> <resources> <declare-styleable name="SunTrack"> <!-- 背景椭圆短轴和长轴长 --> <attr name="oval_width" form
Sunburst_Chart
05-10
Kibana 4.1.0快照 Kibana是Elasticsearch的开源（ ），基于浏览器的分析和搜索仪表板。 Kibana非常易于设置和开始使用。 就像Elasticsearch一样，Kibana力求易于上手，同时又要灵活，强大。 要求 Elasticsearch 1.4.4或更高版本 Kibana二进制包 安装 下载： : 在Unix上运行bin/kibana ，在Windows上运行bin/kibana bin\kibana.bat 。 造访 快速开始 您已经开始跑步了！ 极好的！ Kibana现在在端口5601上运行，因此将浏览器指向 。 您到达的第一个屏幕将要求您配置索引模式。 索引模式向Kibana描述了如何访问您的数据。 我们猜测您正在使用日志数据，并且希望（因为它很棒）希望您正在使用Logstash。 默认情况下，我们填写logstash-*作为您的索引模式
Android OpenGL ES 开发教程(19)：绘制迷你太阳系
mapdigit
05-30 210
前面介绍了3D坐标系统和3D坐标变换以及在OpenGL ES中坐标变换的过程，并与相机拍照片的过程做类比，以便更好的理解这OpenGL中构造3D模型的一部步骤： 本例提供绘制一个迷你太阳系系统作为前面知识的总结，这个迷你太阳系，有一个红色的太阳，一个蓝色的地图和一个白色的月亮构成： 太阳居中，逆时针自转。 地球绕太阳顺时针公转，本身不自转。 月亮绕地球顺时针公转，自身逆时针自转。 为简...
Echarts中太阳图（Sunburst）的实例
weixin_34166472的博客
07-12 559
Echarts中太阳图（Sunburst）的实例 目前在项目中要实现一个Echars中的太阳图，但是Echars中的太阳图的数据格式是一个树形结构，如下代码格式如下： var mapData = [ { name: '会员属性', itemStyle: { color: '#777' }, children: [ ...
sunburst-chart：用于可视化层次结构数据的sunburst交互式图表Web组件
02-05
朝阳图 用于表示层次结构数据的交互式森伯斯特图，其中树的每个数据节点由多层环中的环形段表示。 单击圆弧可将视图聚焦在关联的子树上，从而可以逐步浏览数据。 单击图表中心将缩小一级，而单击画布会将缩放级别重置为根视图。 该图表还通过将每个节点的圆弧动画化到其新位置来响应数据更改。 默认情况下，圆弧区域与其数据值成线性比例，从而导致外层厚度以二次方的方式减小。 但是，可以使用radiusScaleExponent方法自定义。 为了提高性能，将小于给定阈值（ minSliceAngle ）的弧从DOM中排除，从而允许在保持平滑交互的同时表示大型数据集。 有关随机生成的大型数据结构，请参见。
如何在ECharts的太阳图(sunburst chart)中实现根据数据值动态控制标签(label)的显示和隐藏？
最新发布
12-17
在ECharts的太阳图(sunburst chart)中，实现根据数据值动态控制标签的显示和隐藏通常需要结合`formatter`函数以及条件判断。`formatter`允许你在渲染图表元素（如标签）时进行自定义操作。 首先，在配置太阳图的...
如何在ECharts中为旭日图（Sunburst Chart）添加图例？
11-05
在ECharts中，旭日图（也称为太阳图或树状图）通常用于展示层级关系的数据。要给旭日图添加图例，首先你需要创建一个ECharts实例，并配置旭日图的基本参数，然后设置`legend`属性来管理图例。 下面是一个简单的步骤...
sunburst-chart：实现层次数据可视化的交互式图表组件
5.自定义比例尺: 如果默认的比例关系不满足特定的可视化需求，sunburst-chart提供radiusScaleExponent方法允许开发者自定义这种比例关系。通过这种方法，可以调整圆弧大小的计算公式，使得图表更加符合特定的业务...
旭日图（sunburst chart）绘制：R语言 & excel
weixin_30553777的博客
05-03 3705
旭日图（sunburst chart）也叫太阳图，一种圆环镶接图，每一个圆环就代表了同一级别的比例数据，离原点越近的圆环级别越高，最内层的圆表示层次结构的顶级。除了圆环外，旭日图还有若干从原点放射出去的‘射线’，这些‘射线’展示出了不同级别数据间的脉络关系。旭日图从圆心出发，层层向外推进，可以清晰的反应事件的路径走向，多用于路径分析。 R语言中sunburstR包可以实现旭日图的绘制，insta...
举个栗子！Tableau 技巧（170）：用旭日图 Sunburst Chart 呈现多层数据
weixin_45588393的博客
07-05 1920
旭日图又称太阳图，是一种饼图（或环形图）基础上的升级图表。旭日图既能像饼图一样展示数据各自的占比，还能直观的表达数据的层级和从属关系，呈现数据的构成情况。 旭日图中，每一层图表代表同一级别的数据占比。图表从内到外，对应的数据级别便从高到低，并且相邻两层是内外包含关系。 很多数据粉因为颜值关注到旭日图，希望它让数据分析更美观。其实，旭日图不仅仅是颜值担当，它在实际业务分析场景中，也是一种非常实用的分析图表。 通过旭日图可以了解数据构成、还可以快速洞察业务。如何在 Tableau 中实现呢？今天来分享方法吧.
android 画日出日落圆弧曲线
12-18 1350
private PointF mPointF1;     private PointF mControl;     private PointF touchPoint;     private float startAngle = 180;     private float sweepAngle = 60;     private float radius = 10
android自定义view绘制日出日落根据当前时间段更新进度
weixin_63691008的博客
03-29 282
android自定义view绘制日出日落根据当前时间段更新进度
Android为TV端助力:自定义view之太阳
weixin_30556959的博客
05-17 124
先看效果图 package com.hhzt.iptv.lvb_w8.view;import android.content.Context;import android.graphics.Canvas;import android.graphics.Color;import android.graphics.Paint;import android.graphics.PixelFormat...
android自定义起止时间的时间刻度尺,Android 自定义View篇（六）实现时钟表盘效果...
weixin_34031238的博客
05-25 896
前言Android 自定义 View 是高级进阶不可或缺的内容，日常工作中，经常会遇到产品、UI 设计出花里胡哨的界面。当系统自带的控件不能满足开发需求时，就只能自己动手撸一个效果。本文就带自定义 View 初学者手动撸一个效果，通过自定义 View 实现钟表功能，每行代码都有注释，保证易懂，看不懂你留言打我！！！实现效果1、先看效果图在这里插入图片描述2、下载地址3、步骤分析实现以上效果，主要分...
自定义View之实现日出日落太阳动效
热门推荐
zoujian的博客
09-06 2万+
以前也很羡慕网上大神随手写写就是一个很漂亮的自定义控件，所以我下决心也要学着去写，刚好最近复习了Android View的绘制流程知识，看来看去就是那些个知识点，没点产出总感觉很迷。现在个人呢用的是华为荣耀8手机，碰巧在看自带的天气APP时，滑到最下面看到那个动效图：日出时间和日落时间上边是一个半圆，白天任意的时刻（在日出和日落时间之间）都有对应一个太阳从日出时刻沿着半圆弧做动画特效，个人第一感觉
可视化之sunburst
思过留痕
04-21 3705
图表简介 旭日图（Sunburst Chart）是一种现代饼图，它超越传统的饼图和环图，能表达清晰的层级和归属关系，以父子层次结构来显示数据构成情况。旭日图中，离远点越近表示级别越高，相邻两层中，是内层包含外层的关系。 图表用法 旭日图可以更细分溯源分析数据，真正了解数据的具体构成。 可视化 devtools::install_github("timelyportfolio/...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值