前端都是手写ECharts ?

布满荆棘的人生 2023-01-15 08:15 251阅读 0赞

一、自定义的必要性

  1.  **绘制**的底层是强大的,我们所用的各端语言只是在现代UI追求的步伐中和用户喜好的交互中求同存异，抽取封装出自成个性风格的UI控件,当然面对万亿级别的客户各个平台的UI库出也不可能满足所有的客户需求,当然一门语言的可制定性也意味着其强大,几乎每个平台都提供了接口让开发者创造其UI的可能性,更可能的能满足客户需求。`ECharts`作为前端强大的图表K线等绘制工具可以说应有竟有,无比风骚。但用户和产品的需求永远是一个库满足不了的。当然作为技术人员自定义绘制也应该是需要掌握的技术。我们前端移动端作为产品的排面就应该让其独具特色,别具一格。所以自定义从我们的`技术岗位`、`技术本身`、`亿万用户不同需求`...出发，"自定义**很必要**"。

二、ECharts

  1.  ECharts使用过的伙伴们都知道极其的丰富和花里胡哨了。对于库的使用没啥写的吧？我们今天的目的是学会自己分析和写出ECharts的效果,而不是使用Echarts库,虽然我没咋么写过前端,有API咋们就能一步步往下走。如下:

折线图424fac5d25ad5d21429e87cceb772447.png

K线图

ca0691e9208eb9f02ecca352af437406.png image.png

K线图

76b406ffeb74e80a4cf2bd275c8886e2.png image.png

….当然还有很多。

三、画布的认识

  1.  不同于Android以及Flutter等。Canvas在HTML5中并不是实质的画布。**<canvas>** 元素本身并没有绘制能力（它仅仅是图形的容器） - 您必须使用脚本来完成实际的绘图任务。`getContext() 方法可返回一个对象`，该对象提供了用于在画布上绘图的方法和属性。HTML5中可以通过Canvas标签获取getContext("2d") 对象,它提供了很多绘制的属性和方法，可用于在画布上绘制文本、线条、矩形、圆形等等。

1、画布的创建

第一我们通过getElementById来获取Canvas容器标签,然后通过canvas.getContext(“2d”)来获取绘制对象。

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  8. <canvas id="canvas"/>
  10. <script>
  11.     //getElementById() 来访问 canvas 元素
  12.     const canvas = document.getElementById("canvas");
  13.     const context = canvas.getContext("2d");
  16.     context.fillStyle= 'rgb(222,155,155)';
  17.     context.fillRect(0,0,canvas.width,canvas.height);
  18. </script>
  19. </body>
  20. </html>

2、设置画布的宽高和背景色

通过canvas的width和height属性来设置画布的大小。通过fillStyle属性设置绘制区域的颜色。fillRect来设置绘制区域大小为坐标点为左上角固定宽高的距形。

canvas.width设置画布的宽
canvas.height设置画布的高
context.fillStyle设置填充颜色
context.fillRect设置距形


















属性 作用
fillStyle 设置填充的样式,颜色、渐变等
fillRect() 定义被填充的矩形位置和大小 
  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  8. <canvas id="canvas"/>
  10. <script>
  11.     //getElementById() 来访问 canvas 元素
  12.     const canvas = document.getElementById("canvas");
  13.      //设置画布的宽高
  14.     canvas.width=400;
  15.     canvas.height=200;
  16.     //获取绘制的对象
  17.     const context = canvas.getContext("2d");
  18.     //设置填充的颜色是颜色渐变等
  19.     context.fillStyle= 'rgb(222,155,155)';
  20.     //填充区域为矩形,来定义位置和大小
  21.     context.fillRect(0,0,canvas.width,canvas.height);
  22. </script>
  23. </body>
  24. </html>

38796c1a8811accdb3e986586cca188f.png image.png

设置画布的宽高为width=1000;height=500;
效果如下:

  1.  //画布宽高
  2.  canvas.width=1000;
  3.  canvas.height=5000;
  4.  ...
  5.  context.fillStyle= 'rgb(222,155,155)';

3d75be97be672601ab9de658c3985d49.png image.png

3、设置渐变色

渐变色一直是UI中极其多见的效果。不仅增添美感,更是高大上道路上的比不可少的秘诀。接下来咋们来体验一下前端的渐变。

线性渐变

createLinearGradient(x0: number, y0: number, x1: number, y1: number)

(x0,y0) 链接 (x1,y1)方向上进行渐变。如下(0,0)到(canvas.width,0)是水平方向上渐变。

addColorStop(offset: number, color: string): void;

用来设置渐变色起始的比例位置。
我们来看看效果 

  1. const gradient = context.createLinearGradient(0, 0, canvas.width,0);
  2.     gradient.addColorStop(0  ,"rgb(100,200,155)")
  3.     gradient.addColorStop(0.5,"rgb(200,120,155)")
  4.     gradient.addColorStop(1.0,"rgb(200,220,255)")
  5.     context.fillStyle = gradient

2ed240300d6da6e19c09d22abf16ac21.png image.png

如下(0,0)到(canvas.width,canvas.height)是对角线方向上渐变我们来看看效果

40b6b59b5c354749af3d13501be0e59b.png image.png

任意方向上线性渐变
  1. const gradient = context.createLinearGradient(0, 0, canvas.width,canvas.height);

4a64bf6488af74870f31324d98f55cc2.png image.png

总结渐变色方向的确定通过(x0,y0)和(x1,y1)连线方向即可。通过addColorStop来进行比例设置渐变色值所起始范围。

径向渐变

createRadialGradient(x0: number, y0: number, r0: number, x1: number, y1: number, r1: number)

r0和r1半径比较那个大，那么就从那个到半径小的方向进行渐变,而不是从里到外或者从外到里。

  1.     //region 4.径向渐变色
  2.     const canvas = document.getElementById("canvas");
  3.     //设置画布的宽高
  4.     canvas.width=1000;
  5.     canvas.height=500;
  7.     //绘制的对象获取
  8.     const context = canvas.getContext("2d");
  9.     //Radial（径向）
  10.     //createRadialGradient(x0: number, y0: number, r0: number, x1: number, y1: number, r1: number)
  11.     const gradient = context.createRadialGradient(canvas.width / 2, canvas.height / 2, 50, canvas.width / 2, canvas.height / 2, 20);
  12.     gradient.addColorStop(0  ,"rgb(100,200,155)")
  13.     gradient.addColorStop(0.8,"rgb(200,120,155)")
  14.     gradient.addColorStop(1.0,"rgb(00,120,105)")
  16.     context.fillStyle = gradient
  17.     //设置填充的区域为巨形 fillRect(x: number, y: number, w: number, h: number)
  18.     context.fillRect(0,0,canvas.width,canvas.height);
  19.     //endregion

半径50到20渐变-由外到内过程如下

7de69a58f8bc3d70f095c360edfad71b.png image.png

半径20到50渐变-由内到外过程如下

aad55028fb2c520fa16ecae09013fc77.png image.png

渐变就到这里…案例中会充分的使用渐变的。由于时间问题单独渐变案例就不写了。

三、画布的变换

  1.  画布通过translate、rotate、scale、skew等进行画布的变换,可以让我们绘制过程事半功倍,犹鱼得水。默认情况画布的坐标系是左上角,我们可以在坐标(0,0)绘制到(100,100)且连线。如下代码和效果:

context.beginPath()表示开始一段新的路径,下次填充只会修改此段路径内容
context.moveTo(x, y)路径的起始点
context.lineTo(x, y)链接到下一个点
context.strokeStyle = gradient 设置未闭合路径的颜色
context.stroke() 路径为线 

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>canvas_change</title>
  6. </head>
  7. <body>
  8. <canvas id="canvas"/>
  9. </body>
  10. <script>
  11.     //region 1.变换traslate
  12.     const canvas = document.getElementById("canvas");
  13.     //设置画布的宽高
  14.     canvas.width = 100;
  15.     canvas.height = 100;
  16.     //绘制的对象获取
  17.     const context = canvas.getContext("2d");
  19.     //此段路径绘制开始
  20.     context.beginPath()
  21.     context.moveTo(0, 0)
  22.     context.lineTo(100, 100)
  24.     //设置线的颜色为渐变色
  25.     const gradient = context.createLinearGradient(
  26.         0,
  27.         0, canvas.width, canvas.height);
  28.     gradient.addColorStop(0, "rgb(100,200,155)")
  29.     gradient.addColorStop(0.8, "rgb(200,120,155)")
  30.     gradient.addColorStop(1.0, "rgb(00,120,105)")
  31.     context.strokeStyle = gradient
  33.     //画不是闭合区域 fill是闭合区域
  34.     context.stroke()
  36. </script>
  37. </html>

d0fc1a86827d292084ec649a2a769bc1.png image.png

画布translate[平移]

我们常见的ECharts等图表都可以看到有坐标系,而我们的坐标系默认是左上角。大部分常见的坐标系都不是在左上角的。如果以左上角为圆点绘制起来也许比较费劲。最希望的是以(0,0)为我们想要的相对位置，这样处理很多事变的简单。

折线图312a22f98409849322115cd1b7e2c918.png

上面我们学会了绘制线条。那我们绘制出默认的坐标系,且在默认的圆心左上角绘制一个半径为50的圆圈。

  1. <script>
  2.     //region 1.变换traslate
  3.     const canvas = document.getElementById("canvas");
  4.     //设置画布的宽高
  5.     canvas.width = 400;
  6.     canvas.height = 200;
  7.     //绘制的对象获取
  8.     const context = canvas.getContext("2d");
  10.     //设置线的颜色为渐变色
  11.     const gradient = context.createLinearGradient(
  12.         0,
  13.         0, canvas.width, canvas.height);
  14.     gradient.addColorStop(0, "rgb(100,200,155)")
  15.     gradient.addColorStop(0.8, "rgb(200,120,155)")
  16.     gradient.addColorStop(1.0, "rgb(00,120,105)")
  17.     context.strokeStyle = gradient
  21.     //绘制X轴开始
  22.     context.beginPath()
  23.     context.moveTo(0, 0)
  24.     context.lineTo(canvas.width, 0)
  25.     context.closePath()
  26.     //画不是闭合区域 fill是闭合区域
  27.     context.stroke()
  29.     //绘制Y轴
  30.     context.beginPath()
  31.     context.moveTo(0, 0)
  32.     context.lineTo(0, canvas.height)
  33.     context.closePath()
  34.     //画不是闭合区域 fill是闭合区域
  35.     context.stroke()
  37.     context.beginPath()
  38.     //绘制在圆心绘制圆圈
  39.     context.arc(0, 0, 50, 0, Math.PI * 2, true);
  40.     context.closePath()
  41.     //画不是闭合区域 fill是闭合区域
  42.     context.fillStyle = gradient
  43.     context.fill()
  45. </script>

d7fbba1c2b5e5dc5f89a615ba94ce446.png image.png

接下来我想将坐标远点放到画布中间,绘制之前加平移变换。我们可以看出绘制过程中圆的坐标轴是以画布中心为圆点绘制坐标轴和圆的,当然你可以任意的平移。

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>canvas_change</title>
  6. </head>
  7. <body>
  8. <canvas id="canvas"/>
  9. </body>
  10. <script>
  11.     //region 1.变换traslate
  12.     const canvas = document.getElementById("canvas");
  13.     //设置画布的宽高
  14.     canvas.width = 400;
  15.     canvas.height = 200;
  16.     //绘制的对象获取
  17.     const context = canvas.getContext("2d");
  19.     //设置线的颜色为渐变色
  20.     const gradient = context.createLinearGradient(
  21.         0,
  22.         0, canvas.width, canvas.height);
  23.     gradient.addColorStop(0, "rgb(100,200,155)")
  24.     gradient.addColorStop(0.8, "rgb(200,120,155)")
  25.     gradient.addColorStop(1.0, "rgb(00,120,105)")
  26.     context.fillStyle = "rgba(100,200,155,0.2)"
  27.     context.fillRect(0, 0, canvas.width, canvas.height);
  28.     context.strokeStyle = gradient
  30.     //平移画布
  31.     context.translate(canvas.width/2,canvas.height/2)
  33.     //绘制X轴开始
  34.     context.beginPath()
  35.     context.moveTo(0, 0)
  36.     context.lineTo(canvas.width, 0)
  37.     context.closePath()
  38.     //画不是闭合区域 fill是闭合区域
  39.     context.stroke()
  41.     //绘制Y轴
  42.     context.beginPath()
  43.     context.moveTo(0, 0)
  44.     context.lineTo(0, canvas.height)
  45.     context.closePath()
  46.     //画不是闭合区域 fill是闭合区域
  47.     context.stroke()
  49.     context.beginPath()
  50.     //绘制在圆心绘制圆圈
  51.     context.arc(0, 0, 50, 0, Math.PI * 2, true);
  52.     context.closePath()
  53.     //画不是闭合区域 fill是闭合区域
  54.     context.fillStyle = "rgb(200,120,155)"
  55.     context.fill()
  57. </script>
  58. </html>

d98f4f52175b8147f7a0d9f68e6ed4cf.png image.png

画布rotate【旋转】

首先我们猜想一下画布的旋转,然后去证明是否正确。首先绘制一个线,然后旋转画布10度,再次绘制同样的线。绘图前后对比如下:

  1. //旋转画布
  2. context.rotate(Math.PI/180*10)

0d4b02a160cd45fb8961254bc9f9bf3b.png image.png

画布scale【缩放】

画布Canvas通过scale(float sx, float sy)可以将绘制坐标系转换为我们希望的坐标系。例如默认坐标系是如下:eff7c92805d43ea246a1e6ef78442bf3.png

我心目中的坐标系并不是这样的而是这样那样的如下:

6b9367cefa68cfc8105529d43692ee0b.png

接下来我们想要得到一个如下2一样的坐标系。

d0dc43f68736101ee5abcdf50d0d4473.png

沿x轴镜像，就相当于canvas.scale(1, -1),沿y轴镜像，就相当于canvas.scale(-1, 1),沿原点镜像，就相当于canvas.scale(-1, -1)

分析图二坐标系可以看到圆点在左下角。y轴向上为正方向,x轴向右为正方向,和默认的坐标系左上角对比，只是y轴方向相反。这时候我们就可以利用canvas.scale(1,-1)镜像变换,再通过平移向下即可。
沿x轴镜像scale(1,-1)
向下平移canvas.height即可—-这里注意了因为坐标系被scale(1,-1)之后坐标系向上为正,向下平移需要-canvas.height代码部分

  1. <script>
  2.     //region 1.变换rote
  3.     const canvas = document.getElementById("canvas");
  4.     //设置画布的宽高
  5.     canvas.width = 400;
  6.     canvas.height = 200;
  7.     //绘制的对象获取
  8.     const context = canvas.getContext("2d");
  10.     //设置线的颜色为渐变色
  11.     const gradient = context.createLinearGradient(
  12.         0,
  13.         0, canvas.width, canvas.height);
  14.     gradient.addColorStop(0, "rgb(100,200,155)")
  15.     gradient.addColorStop(0.8, "rgb(200,120,155)")
  16.     gradient.addColorStop(1.0, "rgb(00,120,105)")
  17.     context.fillStyle = "rgba(100,200,155,0.2)"
  18.     context.fillRect(0, 0, canvas.width, canvas.height);
  19.     context.strokeStyle = gradient
  21.     //沿x轴镜像变换必须明白最重要的一点,这时候y坐标系向下为正，经过下面scale(1,-1)y轴坐标系乡下为负。
  22.     context.scale(1,-1)
  23.     //向下平移，注意这时候乡下是负方向哦
  24.     context.translate(0,-canvas.height)
  26.     //绘制X轴开始
  27.     context.beginPath()
  28.     context.moveTo(0, 0)
  29.     context.lineTo(canvas.width, 0)
  30.     context.closePath()
  31.     //画不是闭合区域 fill是闭合区域
  32.     context.stroke()
  34.     //绘制Y轴
  35.     context.beginPath()
  36.     context.moveTo(0, 0)
  37.     context.lineTo(0, canvas.height)
  38.     context.closePath()
  39.     //画不是闭合区域 fill是闭合区域
  40.     context.stroke()
  42.     context.beginPath()
  43.     //绘制线
  44.     context.moveTo(0,0);
  45.     context.lineTo(100,100);
  46.     context.closePath()
  47.     //画不是闭合区域 fill是闭合区域
  48.     context.strokeStyle = "rgb(200,120,155)"
  49.     context.stroke()
  51. </script>

dff26afc9959a581e5e4ab17e852057f.png image.png

好了,到这里我们学会了坐标系的变换,我相信大家应该觉得这么简单的东西,就这样么？当然了坐标变换有着极大的便利性和简化功能，我们逐步深入，画布的变换定会让你事半功倍,游刃有余。

四、手写ECharts案例

1、折线图

如下是ECharts官方第一个案例:都是文字和各种线圆组成,但是其中有很多跟我们的坐标变换有着千丝万缕的关系，咋们来一步步分析画布变换的重要性。a5795bcf34c2c7b47fe2d99d0f456013.png

分析绘制过程

1.变换坐标系—为操作带来方便
2.绘制平行X轴的线条
3.绘制文字
4.绘制折线和圆

1.变换坐标系—为操作带来方便 

  1.  我们分析上图,基本是左下角为坐标圆心进行整个折线图的绘制。但我们坐标系默认是左上角,所以接下来变换坐标系圆点到左下角即可,上面案例中我们看到距离底部和坐标有一定的距离用来绘制文字我们设置距离下面50左边40。
  3.  //region 1.变换rote
  4.     const marginBootom = 50;
  5.     const marginLeft = 40;
  6.     const canvas = document.getElementById("canvas");
  7.     //设置画布的宽高
  8.     canvas.width = 400;
  9.     canvas.height = 200;
  10.     //绘制的对象获取
  11.     const context = canvas.getContext("2d");
  12.     //渐变
  13.     context.strokeStyle = "rgb(0,0,0,1)"
  14.     context.lineWidth=0.2
  16.     //沿x轴镜像对称变换画布
  17.     context.scale(1, -1)
  18.     //向下平移画布-marginBootom的高度
  19.     context.translate(marginLeft, -canvas.height+marginBootom)

此时的坐标系是这样的，为了演示和观察方便我这里贴一下坐标系。接下来我们开始后面的绘制过程。

6db75131b0101c2a470d331f278defca.png image.png

2.绘制平行X轴的线条
这个平行X轴的线条我们难道需要计算每条线的起点和终点么？这么麻烦？当然来画布的变换很好的解决了这个问题。我们的画布是有状态的每次的状态都可以进行保存也可以返回之前的状态。如下:我们绘制了最底下的一条线。

c9852e814e9a6ef6a6c192a3fd90f620.png image.png

那我们可以每次变换坐标系向Y轴方向向上平移固定高度再绘制这条线线。多次绘制就形成了平行X轴的多条线段。

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Line</title>
  6. </head>
  7. <body>
  8. <canvas id="canvas"/>
  9. <script>
  10.     //region 1.变换rote
  11.     const marginBootom = 50;
  12.     const marginLeft = 40;
  13.     const canvas = document.getElementById("canvas");
  14.     //设置画布的宽高
  15.     canvas.width = 400;
  16.     canvas.height = 300;
  17.     //绘制的对象获取
  18.     const context = canvas.getContext("2d");
  19.     //渐变
  20.     context.strokeStyle = "rgb(0,0,0,1)"
  21.     context.lineWidth=0.08
  23.     //沿x轴镜像对称变换画布
  24.     context.scale(1, -1)
  25.     //向下平移画布-marginBootom的高度
  26.     context.translate(marginLeft, -canvas.height+marginBootom)
  28.     //保存好当前画布的状态。因为我们的圆心在左下角，我们还需要返回到这个远点进行其他操作。
  29.     context.save()
  30.     const heightOfOne=30
  32.     //绘制X轴开始
  33.     for(let i=0; i<7; i++){
  34.         context.beginPath()
  35.         context.moveTo(0, 0)
  36.         context.lineTo(canvas.width, 0)
  37.         context.closePath()
  38.         //画不是闭合区域 fill是闭合区域
  39.         context.stroke()
  40.         //每次绘制完之后继续往上平移
  41.         context.translate(0,heightOfOne)
  42.     }
  43.     context.restore()
  45. </script>
  46. </body>
  47. </html>

3078d10121049ae1e5466e287c04050e.png image.png

3.绘制刻度
同样的方法我们将X轴分为7等分，没以等分我们都要绘制一个刻度。代码如下

12dd10e9c3829be0b447065ea342eb98.png image.png

  1.  //绘制刻度开始
  2.     context.save()
  3.     context.lineWidth=0.2
  4.     for(let i=0; i<8; i++){
  5.         context.beginPath()
  6.         context.moveTo(0, 0)
  7.         context.lineTo(0, -5)
  8.         context.closePath()
  9.         //画不是闭合区域 fill是闭合区域
  10.         context.stroke()
  11.         //每次绘制完之后继续往上平移
  12.         context.translate(widthOfOn,0)
  13.     }
  14.     context.restore()

401cb663bc29238f2a7a50397315cbee.png image.png

绘制X轴下面文字

如果非常精确,这里可能涉及到文字的测量。当然了我们需要精确,由于时间问题我这里也就不细细说明文字绘制测量的详细API。代码中有解释。

context.fillText(“文字”,x,y);表示在（x,y）位置绘制文字

5fc44c5d164500f02f7764d5a3ed52bb.png image.png

  1.    //x轴绘制文字数组
  2.     const xText = new Array("Mon", "Tue", "Wed","Thu","Fir","Sat","Sun");
  3.     for(let i=0; i<xText.length; i++){
  4.         //画不是闭合区域 fill是闭合区域
  5.         context.stroke()
  6.         //每次绘制完之后继续往上平移
  7.         if(i===0){
  8.             //分析之后第一次移动了单位长度的一半。后面的每次都平移一个刻度长度,坐标圆心就平移到了每个刻度的中间。y轴向下平移了5个像素。这样就和X轴不会重合。
  9.             context.translate(widthOfOn/2,-5)
  10.         }else{
  11.             context.translate(widthOfOn,0)
  12.         }
  13.         context.fillText(xText[i],0,0);
  14.     }
  15.     context.restore()

7ee2fdea836a68d2abb573bc4c08987d.png image.png

到这里我们发现字体是沿着X轴镜像变换的。因为默认右下方是正方向，我们经过变换右上方为正方向。所以这里绘制之前我们需要将坐标系还原即可。

  1.  //x轴绘制文字数组
  2.     context.save()
  3.     const xText = new Array("Mon", "Tue", "Wed","Thu","Fir","Sat","Sun");
  4.     //这里沿着X轴镜像对称变换。那么Y轴向下为正，X没变向右为正。
  5.     context.scale(1,-1)
  6.     for(let i=0; i<xText.length; i++){
  7.         //画不是闭合区域 fill是闭合区域
  8.         context.stroke()
  9.         //每次绘制完之后继续往上平移
  10.         if(i===0){
  11.             //分析之后第一次移动了单位长度的一半。后面的每次都平移一个刻度长度,坐标圆心就平移到了每个刻度的中间。y轴向下平移了5个像素。这样就和X轴不会重合。
  12.             context.translate(widthOfOn/2,15)
  14.         }else{
  15.             context.translate(widthOfOn,0)
  16.         }
  17.         context.fillText(xText[i],0,0);
  18.     }
  19.     //还原到远点为左下角状态。
  20.     context.restore()

5a285a0dcdd184be18cc076a89b80088.png image.png

绘制Y轴左边的文字
还需要我BB么….

279bc22f60eeefa10bc24c0ffc08a653.png image.png

  1.     //保存左下角为坐标圆点状态。
  2.     context.save()
  3.     context.scale(1,-1)
  4.     context.translate(-20,0)
  5.     context.font = "7pt Calibri";
  6.     //Y轴左边绘制文字
  7.     for(let i=0; i<7; i++){
  8.         //画不是闭合区域 fill是闭合区域
  9.         context.stroke()
  10.         //每次绘制完之后继续往上平移
  11.         context.fillText((50*i).toString(),0,0);
  12.         context.translate(0,-heightOfOne)
  14.     }
  15.     context.restore()

63d88f1fe137fec82a588e0919912718.png image.png

字体看上图都绘制完成,但是对比原图我们的文字并不在每个刻度的正中间。如上图蓝色指向。如下图上面是我们绘制的。下面是案例的对比之下我们绘制的文字中间位置不是单位刻度中间位置。我们只需要计算出文字的宽度即可。然后绘制的文字X减去位子宽度的一半即可。好好想想很简单的把？9a2e9dfd2e658525f422eda3670b8180.png

context.measureText(“文本”);测量文字
context.fillText(xText[i],-textWidth.width/2,0);

  1.     //x轴绘制文字数组
  2.     context.save()
  3.     const xText = new Array("Mon", "Tue", "Wed","Thu","Fir","Sat","Sun");
  4.     //这里沿着X轴镜像对称变换。那么Y轴向下为正，X没变向右为正。
  5.     context.scale(1,-1)
  6.     context.font = "7pt Calibri";
  7.     for(let i=0; i<xText.length; i++){
  8.         //画不是闭合区域 fill是闭合区域
  9.         context.stroke()
  10.         //每次绘制完之后继续往上平移
  11.         if(i===0){
  12.             //分析之后第一次移动了单位长度的一半。后面的每次都平移一个刻度长度,坐标圆心就平移到了每个刻度的中间。y轴向下平移了5个像素。这样就和X轴不会重合。
  13.             context.translate(widthOfOn/2,15)
  15.         }else{
  16.             context.translate(widthOfOn,0)
  17.         }
  18.         const textWidth = context.measureText(xText[i]);
  19.         context.fillText(xText[i],-textWidth.width/2,0);
  20.     }
  21.     //还原到远点为左下角状态。
  22.     context.restore()

271ad5a3c391c967fec063339d4e64d8.png同样的Y轴文字自己感受一波？就不啰嗦了。

2fa11e80b214dd4e0e0e03ef576b61e8.png image.png

4.绘制折线和圆
所有的绘制有个小问题,不管那一端需要将我们实际的数据映射到我们的坐标系中。这个就简单的计算而已，这里提一下,例如我们的坐标系内部是按照画布的宽度来计算的，也就是像素,当时我们实际的数据可能是任意的数据。所以我们需要按照数据来进行映射到我们的坐标系。案例中的折线数据就是如此:

定义类进行坐标的储存，第一次使用前端的对象怪怪的…..

  1. const Point = {
  2.     createNew: function (x,y) {
  3.         const point = {};
  4.         point.x = x;
  5.         point.y = y;
  6.         return point;
  7.     }
  8. };
  10. <!DOCTYPE html>
  11. <html lang="en">
  12. <head>
  13.     <meta charset="UTF-8">
  14.     <title>Line</title>
  15.     <script type="text/javascript" src="js/canvas..js"></script>
  16. </head>
  18. <body>
  19. <canvas id="canvas"></canvas>
  20. <script>
  21.     //region 1.变换rote
  22.     const marginBootom = 50;
  23.     const marginLeft = 40;
  24.     const canvas = document.getElementById("canvas");
  25.     //设置画布的宽高
  26.     canvas.width = 500;
  27.     canvas.height = 300;
  28.     //绘制的对象获取
  29.     const context = canvas.getContext("2d");
  30.     //渐变
  31.     context.strokeStyle = "rgb(0,0,0,1)"
  32.     context.lineWidth = 0.09
  34.     //沿x轴镜像对称变换画布
  35.     context.scale(1, -1)
  36.     //向下平移画布-marginBootom的高度
  37.     context.translate(marginLeft, -canvas.height + marginBootom)
  39.     //绘制X轴和刻度
  40.     drawX(context)
  41.     //绘制文字
  42.     drawText(context)
  43.     //绘制折线和圆
  44.     drawLine(context)
  45.     //绘制圆
  46.     drawCircle(context)
  47. </script>
  49. </body>
  50. </html>

canvas.js文件

  1. //绘制折线
  2. function drawLine(context) {
  3.     //绘制折线段
  4.     const widthOfOn = (canvas.width - marginLeft) / 7
  5.     const danweiHeight=35/50;//每个数字占用的实际像素高度
  6.     const point01 = Point.createNew(widthOfOn/2,150*danweiHeight);
  7.     const point02 = Point.createNew(widthOfOn/2+widthOfOn,250*danweiHeight);
  8.     const point03 = Point.createNew(widthOfOn/2+widthOfOn*2,225*danweiHeight);
  9.     const point04 = Point.createNew(widthOfOn/2+widthOfOn*3,211*danweiHeight);
  10.     const point05 = Point.createNew(widthOfOn/2+widthOfOn*4,140*danweiHeight);
  11.     const point06 = Point.createNew(widthOfOn/2+widthOfOn*5,148*danweiHeight);
  12.     const point07 = Point.createNew(widthOfOn/2+widthOfOn*6,260*danweiHeight);
  15.     const points = [point01, point02, point03, point04, point05, point06, point07];
  16.     context.save();
  18.     context.beginPath();
  19.     for (let index = 0; index < points.length; index++) {
  20.         context.lineTo(points[index].x,points[index].y);
  21.     }
  22.     context.strokeStyle="rgb(93,111,194)"
  23.     context.lineWidth=1
  24.     context.shadowBlur = 5;
  25.     context.stroke();
  26.     context.closePath();
  27.     context.restore();
  28. }
  29. //绘制圆圈
  30. function drawCircle(context) {
  31.     const widthOfOn = (canvas.width - marginLeft) / 7
  32.     const danweiHeight=35/50;//每个数字占用的实际像素高度
  33.     const point01 = Point.createNew(widthOfOn/2,150*danweiHeight);
  34.     const point02 = Point.createNew(widthOfOn/2+widthOfOn,250*danweiHeight);
  35.     const point03 = Point.createNew(widthOfOn/2+widthOfOn*2,225*danweiHeight);
  36.     const point04 = Point.createNew(widthOfOn/2+widthOfOn*3,211*danweiHeight);
  37.     const point05 = Point.createNew(widthOfOn/2+widthOfOn*4,140*danweiHeight);
  38.     const point06 = Point.createNew(widthOfOn/2+widthOfOn*5,148*danweiHeight);
  39.     const point07 = Point.createNew(widthOfOn/2+widthOfOn*6,260*danweiHeight);
  42.     const points = [point01, point02, point03, point04, point05, point06, point07];
  43.     context.save();
  44.     context.beginPath();
  45.     for (let index = 0; index < points.length; index++) {
  46.         context.beginPath();
  47.         context.arc(points[index].x,points[index].y,3, 0, Math.PI * 2, true);
  48.         context.closePath();
  49.         context.fillStyle = 'rgb(100,255,255)';
  50.         context.shadowBlur = 5;
  51.         context.shadowColor = 'rgb(100,255,255)';
  52.         context.fill()
  53.     }
  54.     canvas.restore();
  55. }

290cc2c90e2ff9a92d2340ee0adf3747.png image.png

到这里,如果你一步步走下来对于不明白的百度搜索看API我相信只要你自己练习至少三个每个使用一下画布的变换,那么自定义你就已经达到不错的水平,当然对于各种骚操作,我们可以进一步学习贝塞尔曲线等和动画加手势等。

平滑的折线图

  1.  今天第一次接触HTML5的自定义,其实各端的自定义都是底层渲染绘制基础上的API封装,一个好的平台或者语言都会有完善的API,H5再我看来之所以有ECharts这样的库可以所很完善了API,所以这个章节我很有信心。
  • 曲线开发中时常出现在自定义图标里面,学会曲线绘制能让你的软件更具创造性和无穷的魅力。

一、曲线认识与理解

  • 由于之前Android写过一些概论和理解,所以这里就贴一下android的代码和理解，时间问题就这里可以看基本的理解即可

    曲线常见的API
    1.一阶曲线
    2.二阶曲线
    3.三阶曲线

我们在初中高中学习中学习了各种直线,圆,椭圆,正玄…曲线等对应的坐标系方程吧,接下来我们回顾一下我们的直线和曲线等方程。

  • 第一步我们还是定义一个类新建坐标系,屏幕可旋转横屏显示

    package com.example.android_draw.view

    import android.content.Context
    import android.graphics.Canvas
    import android.util.AttributeSet
    import android.view.View

    /*

    • ┌─────────────────────────────────────────────────────────────┐
    • │┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐│
    • ││Esc│!1 │@2 │#3 │$4 │%5 │^6 │&7 │*8 │(9 │)0 │_- │+= │|\ │`~ ││
    • │├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┤│
    • ││ Tab │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │{[ │}] │ BS ││
    • │├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤│
    • ││ Ctrl │ A │ S │ D │ F │ G │ H │ J │ K │ L │: ;│” ‘│ Enter ││
    • │├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────┬───┤│
    • ││ Shift │ Z │ X │ C │ V │ B │ N │ M │< ,│> .│? /│Shift │Fn ││
    • │└─────┬──┴┬──┴──┬┴───┴───┴───┴───┴───┴──┬┴───┴┬──┴┬─────┴───┘│
    • │ │Fn │ Alt │ Space │ Alt │Win│ HHKB │
    • │ └───┴─────┴───────────────────────┴─────┴───┘ │
    • └─────────────────────────────────────────────────────────────┘
    • 版权：渤海新能 版权所有
      *
    • @author feiWang
    • 版本：1.5
    • 创建日期：2/8/21
    • 描述：Android_Draw
    • E-mail : 1276998208@qq.com
    • CSDN:https://blog.csdn.net/m0_37667770/article

    • GitHub:https://github.com/luhenchang
      */
      class LHC_Cubic_View @JvmOverloads constructor(
      context: Context?,
      attrs: AttributeSet? = null,
      defStyleAttr: Int = 0
      ) : View(context, attrs, defStyleAttr) {

      init {

      }

      override fun onDraw(canvas: Canvas?) {

      1.  super.onDraw(canvas)

      }

    }

为了方便观察和绘制进行了网格和坐标轴的绘制。我相信学过上一篇文章的对于画布的变换操作已经熟练掌握了,网格坐标轴的代码我就不再讲解,看图。

d868978e25be1a1088fe7d57bb7acb7c.png

1.方程式映射到坐标系

记得我们初中学过Y(x)=ax+b的直线方程吧。我们来看看这个方程映射到坐标系中的图像。首先定义一个函数 y=2x-80获取一段点集合,为了看效果我们x偶数时候绘制,然后绘制点即可。代码如下:

  1.     private var number=0..420
  2.     //直线方程y=2x-80
  3.     private fun drawzxLine(canvas: Canvas) {
  4.         pointList= ArrayList()
  5.         //绘制方程式y=10x+20
  6.         val gPaint = getPaint()
  7.         number.forEach { t ->
  8.             val point=PointF()
  9.             if (t%2==0) {//x轴偶数点进行绘制
  10.                 point.x = t.toFloat()
  11.                 point.y = 2f * t - 80
  12.                 pointList.add(point)
  13.                 canvas.drawPoint(point.x, point.y, gPaint)
  14.             }
  15.         }
  16.     }

05b9f04fb40bd1204a26a1d9e4469862.png

1.同样圆的方程,椭圆的方程等都可以这样进行映射到坐标系。
2.ca7680f41fb4d8b5732932f2d2ac2420.png 所表示的曲线是以O(a，b)为圆心，以r为半径的圆。
3.例如:(x-10)2+(y-10)2=1602我们进行映射到坐标系内。

  • 解方程应该没问题吧。我们来变换为我们熟悉的方程式:

(x-10)2+(y-10)2=1602
1.移项 (y-10)2=1602-(x-10)2
2.开方 转换为函数Math方程式如下:
开方之后有正负值需要注意

  1. y=sqrt(160.0.pow(2.0).toFloat() - ((point.x - 10).toDouble()).pow(2.0)).toFloat() + 10
  2. y=-sqrt(160.0.pow(2.0).toFloat() - ((pointDown.x - 10).toDouble()).pow(2.0)).toFloat() + 10
  1.  //绘制圆圈
  2.         number.forEach { t ->
  3.             val point = PointF()
  4.             val pointDown = PointF()
  6.             //(x-10)2+（y-10）2=1602
  7.             point.x = t.toFloat()
  8.             pointDown.x = t.toFloat()
  9.             //y计算应该不用我说吧。
  10.             point.y =
  11.                 sqrt(160.0.pow(2.0).toFloat() - ((point.x - 10).toDouble()).pow(2.0)).toFloat() + 10
  12.             pointDown.y = -sqrt(
  13.                 160.0.pow(2.0).toFloat() - ((pointDown.x - 10).toDouble()).pow(2.0)
  14.             ).toFloat() + 10
  15.             canvas.drawPoint(point.x, point.y, gPaint)
  16.             canvas.drawPoint(pointDown.x, pointDown.y, gPaint)
  18.         }

e355d1a3be6349415c6e3efe948956f3.png

2.贝塞尔曲线

通过上面我们发现凡是函数都可以和坐标系绘制进行一一映射,当然了贝塞尔曲线也是有方程式的。有如下:

线性贝塞尔曲线

  • 给定点P0、P1，线性贝塞尔曲线只是一条两点之间的直线。这条线由下式给出： 3c3d5565a805fd0cb1360afde58c804d.png

05c7b812db2193ee3ed7310e7a1f48e6.gif

二次方贝塞尔曲线

  • 二次方贝塞尔曲线的路径由给定点P0、P1、P2的函数B（t）追踪： 8863601b2ef0123bf951d7f857145633.pngf6c01f38d3a29baccaebf1e61c1b93b4.gif

三次方贝塞尔曲线

P0、P1、P2、P3四个点在平面或在三维空间中定义了三次方贝塞尔曲线。曲线起始于P0走向P1，并从P2的方向来到P3。一般不会经过P1或P2；公式如下：

06e622549246c4c613947622c0469102.png bfe31f3a360bb77e2ecda0239b68c5f1.gif

当然在Android端的Native层已经封装好了方法,二次方贝塞尔曲线和三次方贝塞尔曲线,已知函数当然可以进行封装。

  1. 在Android端提供了二阶和三阶
  2.  `二次方贝塞尔曲线`：
  3.     public void quadTo(float x1, float y1, float x2, float y2)
  4.     public void rQuadTo(float dx1, float dy1, float dx2, float dy2) 
  5.  `三次方贝塞尔曲线`：
  6.     public void cubicTo(float x1, float y1, float x2, float y2,float x3, float y3)
  7.     public void rCubicTo(float x1, float y1, float x2, float y2,float x3, float y3)

接下来我们绘制一个二阶曲线，控制点可以随着手势的移动和下按进行对应的屏幕移动,对于手势坐标系和屏幕坐标系的映射转换上节折线里面说很明白了,这里不多做解释。

  • quadTo(float x1, float y1, float x2, float y2)

    1. //记录移动的canvas画布坐标,不是手势坐标，由手势坐标转换为canvas坐标进行刷新
    2. private var moveX: Float = 160f
    3. private var moveY: Float = 160f

    private fun drawQuz(canvas: Canvas) {

    1.     controllRect = Rect(
    2.         (moveX - 30f).toInt(),
    3.         (moveY + 30f).toInt(),
    4.         (moveX + 30).toInt(),
    5.         (moveY - 30f).toInt()
    6.     )
    7.     val quePath = Path()
    8.     canvas.drawCircle(0f, 0f, 10f, getPaintCir(Paint.Style.FILL))
    9.     canvas.drawCircle(320f, 0f, 10f, getPaintCir(Paint.Style.FILL))
    10.     //第一个点和控制点的连线到最后一个点链线。为了方便观察
    11.     val lineLeft = Path()
    12.     lineLeft.moveTo(0f, 0f)
    13.     lineLeft.lineTo(moveX, moveY)
    14.     lineLeft.lineTo(320f, 0f)
    15.     canvas.drawPath(lineLeft, getPaint(Paint.Style.STROKE))
    16.     //第一个p0处画一个圆。第二个p1处画一个控制点圆,最后画一个。
    17.     canvas.drawCircle(moveX, moveY, 10f, getPaintCir(Paint.Style.FILL))
    18.     quePath.quadTo(moveX, moveY, 320f, 0f)
    19.     canvas.drawPath(quePath, getPaint(Paint.Style.STROKE))
    20. }
    22. override fun onTouchEvent(event: MotionEvent): Boolean {
    23.     when (event.action) {
    24.         ACTION_DOWN,
    25.         ACTION_MOVE -> {
    26.             //在控制点附近范围内部,进行移动
    27.             Log.e("x=", "onTouchEvent: (x,y)"+(event.x - width / 2).toInt()+":"+(-(event.y - height / 2)).toInt())
    28.             //将手势坐标转换为屏幕坐标
    29.             moveX = event.x - width / 2
    30.             moveY = -(event.y - height / 2)
    31.             invalidate()
    32.         }
    33.     }
    34.     return true
    35. }

38419a04b293e418d296a7ca7f636a13.gif

上图可以拖动控制点,在起点和结尾之间的曲线随着控制点发生了变形。控制点靠近那一侧弧度的凸起就偏向那一侧,初步的认识这一个规律即可,而练习中不断的去调节控制点达到我们的需求。但是在上图中我们回发现弧度不够圆圈,在三阶函数里面可以很好的调节弧度。接下来我们来看看三阶函数

三阶曲线

  • public void cubicTo(float x1, float y1, float x2, float y2,float x3, float y3) 同样我们在坐标系内绘制三阶曲线。为了很好的看到效果我们这次进行来精细的控制,我们可以拖动任意我们想要拖动的控制点进行观察我们的三阶曲线。在上章节折线中对于手势配合Rect的contains方法可以进行局部的点击,当然了拖动也是没问题的。如下图:我们只需要在控制点附近进行绘制距形包裹住控制点,手势滑动时时刷新控制点和对应的距形即可。

efde93fa417eaac08009db25340c4c91.png

到这里我想我们应该大概的明白二阶和三阶曲线对于弧度的大致方向控制了吧。你以为这样就结束了么。接下来下来开始正式的进入曲线应用。

9e120390aed08a5eb0c22ac2e346e688.png image.png

曲线图分析

4.三阶曲线的拯救4a46a451041c8ba59cfc3f000ce0bdca.png

当<如上图1.求出中点坐标x轴下部分控制点x+40px,上部分x-40px，y轴也可以调整来搞搞平滑度下部分控制点y-40x,上部分y+40。
1.获取中点的坐标（中、中）= ((+)/2、(+)/2)
2.到中之间的坐标=((+中)/2、(+中)/2)
3.中到之间的坐标=((中+)/2、(中+)/2)

当>如上图2.求出中点坐标x轴上部分+40px,下部分x-40px，y轴也可以调整，y轴也可以调整来搞搞平滑度上部分控制点y+40x,下部分y-40。
1.获取中点的坐标（中、中）= ((+)/2、(+)/2)
2.到中之间的坐标=((+中)/2、(+中)/2)
3.中到之间的坐标=((中+)/2、(中+)/2) 

  1. /**
  2.  * 绘制曲线
  3.  * @param context
  4.  */
  5. function drawQuaraticLine(context) {
  6.     //绘制折线段
  7.     const widthOfOn = (canvas.width - marginLeft) / 7
  8.     const danweiHeight=35/50;//每个数字占用的实际像素高度
  9.     const point01 = Point.createNew(widthOfOn/2,150*danweiHeight);
  10.     const point02 = Point.createNew(widthOfOn/2+widthOfOn,250*danweiHeight);
  11.     const point03 = Point.createNew(widthOfOn/2+widthOfOn*2,225*danweiHeight);
  12.     const point04 = Point.createNew(widthOfOn/2+widthOfOn*3,211*danweiHeight);
  13.     const point05 = Point.createNew(widthOfOn/2+widthOfOn*4,140*danweiHeight);
  14.     const point06 = Point.createNew(widthOfOn/2+widthOfOn*5,148*danweiHeight);
  15.     const point07 = Point.createNew(widthOfOn/2+widthOfOn*6,260*danweiHeight);
  18.     const dataList = [point01, point02, point03, point04, point05, point06, point07];
  19.     context.save();
  20.     context.beginPath();
  21.     context.lineTo(point01.x,point01.y)
  22.     //500=grid_width-40 每个单位的长度的=像素长度
  23.     const danweiX = widthOfOn;
  24.     const grid_width=widthOfOn;
  25.     const xMoveDistance=20
  26.     const yMoveDistance=30
  27.     for (let index = 0;index < dataList.length-1;index++) {
  28.         if (dataList[index] === dataList[index + 1]) {
  29.             context.lineTo(danweiX*(index+1),0)
  30.         } else if(dataList[index] < dataList[index + 1]){//y1<y2情况
  31.             const centerX=(grid_width * index + grid_width * (1 + index)) / 2
  32.             const centerY=(dataList[index].y + dataList[index + 1].y) / 2
  33.             const controX0=(grid_width * index+centerX)/2
  34.             const controY0=(dataList[index].y+centerY)/2
  35.             const controX1=(centerX+ grid_width * (1 + index))/2
  36.             const controY1=(centerY+dataList[index+1].y)/2
  37.             context.bezierCurveTo(controX0+xMoveDistance,controY0-yMoveDistance,controX1-xMoveDistance,controY1+yMoveDistance,grid_width * (1 + index),dataList[index + 1].y)
  38.         }else{
  39.             const centerX=(grid_width * index + grid_width * (1 + index)) / 2
  40.             const centerY=(dataList[index].y + dataList[index + 1].y) / 2
  41.             const controX0=(grid_width * index+centerX)/2
  42.             const controY0=(dataList[index].y+centerY)/2
  43.             const controX1=(centerX+ grid_width * (1 + index))/2
  44.             const controY1=(centerY+dataList[index+1].y)/2
  45.             context.bezierCurveTo(controX0+xMoveDistance,controY0+yMoveDistance,controX1-xMoveDistance,controY1-yMoveDistance,grid_width * (1 + index),dataList[index + 1].y)
  46.         }
  47.     }
  48.     context.strokeStyle="rgb(93,111,194)"
  49.     context.lineWidth=2
  50.     context.shadowBlur = 5;
  51.     context.stroke();
  52.     context.closePath();
  53.     context.restore();
  54. }

由于时间问题对于参数没有进行详细的调整,当然了X轴之间的间隙太小，所以看着比较尴尬。如果你有时间自己可以参看我之前的android自定义曲线博客来一波ded555e79b972b158830f6a6ea579ae5.png

3、填充的折线图

我们之前搞定了折线和曲线,但下面这种填充如何搞定？如何进行更骚的操作？我们接下来进行探究。

da1cbf6ac750f569862fc74488dcb903.png image.png

我们在之前的基础上进行，我们可以在之前的基础上进行绘制一个封闭的多边形进行填充即可。

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.   <meta charset="UTF-8">
  5.   <title>Line</title>
  6.   <script type="text/javascript" src="js/canvas..js"></script>
  7.   <script type="text/javascript" src="js/canvas_fill.js"></script>
  8. </head>
  10. <body>
  11. <canvas id="canvas"></canvas>
  12. <script>
  13.   //region 1.变换rote
  14.   const marginBootom = 50;
  15.   const marginLeft = 40;
  16.   const canvas = document.getElementById("canvas");
  17.   //设置画布的宽高
  18.   canvas.width = 500;
  19.   canvas.height = 300;
  20.   //绘制的对象获取
  21.   const context = canvas.getContext("2d");
  22.   //渐变
  23.   context.strokeStyle = "rgb(0,0,0,1)"
  24.   context.lineWidth = 0.09
  26.   //沿x轴镜像对称变换画布
  27.   context.scale(1, -1)
  28.   //向下平移画布-marginBootom的高度
  29.   context.translate(marginLeft, -canvas.height + marginBootom)
  31.   //绘制X轴和刻度
  32.   drawX(context)
  33.   //绘制文字
  34.   drawText(context)
  35.   //绘制折线和圆
  36.   drawFillLine(context)
  37.   //绘制圆
  38.   drawCircle(context)
  43. </script>
  45. </body>
  46. </html>

填充部分代码

  1. function drawFillLine(context) {
  2.     //绘制折线段
  3.     const widthOfOn = (canvas.width - marginLeft) / 7
  4.     const danweiHeight=35/50;//每个数字占用的实际像素高度
  5.     const point00 = Point.createNew(0,150*danweiHeight);
  6.     const point01 = Point.createNew(widthOfOn/2,150*danweiHeight);
  7.     const point02 = Point.createNew(widthOfOn/2+widthOfOn,250*danweiHeight);
  8.     const point03 = Point.createNew(widthOfOn/2+widthOfOn*2,225*danweiHeight);
  9.     const point04 = Point.createNew(widthOfOn/2+widthOfOn*3,211*danweiHeight);
  10.     const point05 = Point.createNew(widthOfOn/2+widthOfOn*4,140*danweiHeight);
  11.     const point06 = Point.createNew(widthOfOn/2+widthOfOn*5,148*danweiHeight);
  12.     const point07 = Point.createNew(widthOfOn/2+widthOfOn*6,260*danweiHeight);
  15.     const points = [point00,point01, point02, point03, point04, point05, point06, point07];
  16.     context.save();
  17.     context.beginPath();
  18.     for (let index = 0; index < points.length; index++) {
  19.         context.lineTo(points[index].x,points[index].y);
  20.     }
  21.     context.strokeStyle="rgb(93,111,194)"
  22.     context.lineWidth=1
  23.     context.shadowBlur = 5;
  24.     context.stroke();
  25.     context.closePath();
  27.     context.beginPath();
  28.     //绘制闭环多边形
  29.     context.moveTo(0,0)
  30.     for (let index = 0; index < points.length; index++) {
  31.         context.lineTo(points[index].x,points[index].y);
  32.     }
  33.     context.lineTo(points[points.length-1].x,0);
  34.     context.lineTo(0,0);
  35.     context.closePath();
  36.     context.fillStyle="rgba(93,111,194,0.5)"
  37.     context.lineWidth=3
  38.     context.shadowBlur = 5;
  39.     context.fill();
  40.     context.restore();
  43. }

渐变色的使用让其更具有特点和魅力。当然了我不是一个标准的设计师,美不在于我们,在于设计，一个好的设计应该不会像我一样配色这么丑吧？

e21bdcd5c27b4acb7a0bf344eaf50c00.png image.png 733c9f5e0eb93acb2f77d32eedca7b25.png image.png b2661eb3f4e4959993346eb19c3b1659.png image.png

3、多条折线图

如下多条折线图,我们搞定了一条还搞不定多条么？只需要同样的操作，只是数据集合不一样罢了。

4c20a46f40413f93a1615c0f76b3245c.png image.png

由于时间问题，我们直接在之前的基础上进行操作

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.   <meta charset="UTF-8">
  5.   <title>Line</title>
  6.   <script type="text/javascript" src="js/canvas..js"></script>
  7.   <script type="text/javascript" src="js/canvas_fill.js"></script>
  8. </head>
  10. <body>
  11. <canvas id="canvas"></canvas>
  12. <script>
  13.   //region 1.变换rote
  14.   const marginBootom = 50;
  15.   const marginLeft = 40;
  16.   const canvas = document.getElementById("canvas");
  17.   //设置画布的宽高
  18.   canvas.width = 500;
  19.   canvas.height = 300;
  20.   //绘制的对象获取
  21.   const context = canvas.getContext("2d");
  22.   //渐变
  23.   context.strokeStyle = "rgb(0,0,0,1)"
  24.   context.lineWidth = 0.09
  26.   //沿x轴镜像对称变换画布
  27.   context.scale(1, -1)
  28.   //向下平移画布-marginBootom的高度
  29.   context.translate(marginLeft, -canvas.height + marginBootom)
  31.   //绘制X轴和刻度
  32.   drawX(context)
  33.   //绘制文字
  34.   drawText(context)
  36.   function drawMoreLine(context) {
  37.     //绘制折线段
  38.     const widthOfOn = (canvas.width - marginLeft) / 7
  39.     const danweiHeight=35/50;//每个数字占用的实际像素高度
  40.     const point01 = Point.createNew(widthOfOn/2,            200*danweiHeight);
  41.     const point02 = Point.createNew(widthOfOn/2+widthOfOn,  250*danweiHeight);
  42.     const point03 = Point.createNew(widthOfOn/2+widthOfOn*2,225*danweiHeight);
  43.     const point04 = Point.createNew(widthOfOn/2+widthOfOn*3,211*danweiHeight);
  44.     const point05 = Point.createNew(widthOfOn/2+widthOfOn*4,140*danweiHeight);
  45.     const point06 = Point.createNew(widthOfOn/2+widthOfOn*5,148*danweiHeight);
  46.     const point07 = Point.createNew(widthOfOn/2+widthOfOn*6,260*danweiHeight);
  49.     const point011 = Point.createNew(widthOfOn/2,            150*danweiHeight);
  50.     const point012 = Point.createNew(widthOfOn/2+widthOfOn,  200*danweiHeight);
  51.     const point013 = Point.createNew(widthOfOn/2+widthOfOn*2,125*danweiHeight);
  52.     const point014 = Point.createNew(widthOfOn/2+widthOfOn*3,181*danweiHeight);
  53.     const point015 = Point.createNew(widthOfOn/2+widthOfOn*4,90*danweiHeight);
  54.     const point016 = Point.createNew(widthOfOn/2+widthOfOn*5,98*danweiHeight);
  55.     const point017 = Point.createNew(widthOfOn/2+widthOfOn*6,210*danweiHeight);
  58.     const point021 = Point.createNew(widthOfOn/2,            60*danweiHeight);
  59.     const point022 = Point.createNew(widthOfOn/2+widthOfOn,  65*danweiHeight);
  60.     const point023 = Point.createNew(widthOfOn/2+widthOfOn*2,61*danweiHeight);
  61.     const point024 = Point.createNew(widthOfOn/2+widthOfOn*3,70*danweiHeight);
  62.     const point025 = Point.createNew(widthOfOn/2+widthOfOn*4,78*danweiHeight);
  63.     const point026 = Point.createNew(widthOfOn/2+widthOfOn*5,68*danweiHeight);
  64.     const point027 = Point.createNew(widthOfOn/2+widthOfOn*6,72*danweiHeight);
  67.     const points = [point01, point02, point03, point04, point05, point06, point07];
  68.     const point1s = [point011, point012, point013, point014, point015, point016, point017];
  69.     const point2s = [point021, point022, point023, point024, point025, point026, point027];
  71.     context.save();
  72.     context.beginPath();
  73.     for (let index = 0; index < points.length; index++) {
  74.       context.lineTo(points[index].x,points[index].y);
  75.     }
  76.     context.strokeStyle="rgb(93,111,194)"
  77.     context.lineWidth=1
  78.     context.shadowBlur = 5;
  79.     context.stroke();
  80.     context.closePath();
  85.     context.beginPath();
  86.     for (let index = 0; index < point1s.length; index++) {
  87.       context.lineTo(point1s[index].x,point1s[index].y);
  88.     }
  89.     context.strokeStyle="rgb(193,111,194)"
  90.     context.lineWidth=1
  91.     context.shadowBlur = 5;
  92.     context.stroke();
  93.     context.closePath();
  95.     context.beginPath();
  96.     for (let index = 0; index < point2s.length; index++) {
  97.       context.lineTo(point2s[index].x,point2s[index].y);
  98.     }
  99.     context.strokeStyle="rgb(293,111,294)"
  100.     context.lineWidth=1
  101.     context.shadowBlur = 5;
  102.     context.stroke();
  103.     context.closePath();
  106.     context.beginPath();
  107.     for (let index = 0; index < point2s.length; index++) {
  108.       context.lineTo(point2s[index].x,point2s[index].y-15);
  109.     }
  110.     context.strokeStyle="rgb(293,211,194)"
  111.     context.lineWidth=1
  112.     context.shadowBlur = 5;
  113.     context.stroke();
  114.     context.closePath();
  116.     context.beginPath();
  117.     for (let index = 0; index < point2s.length; index++) {
  118.       context.lineTo(point2s[index].x,point2s[index].y-35);
  119.     }
  120.     context.strokeStyle="rgb(93,211,294)"
  121.     context.lineWidth=1
  122.     context.shadowBlur = 5;
  123.     context.stroke();
  124.     context.closePath();
  125.     for (let index = 0; index < points.length; index++) {
  126.       context.beginPath();
  127.       context.arc(points[index].x,points[index].y, 3, 0, Math.PI * 2, true);
  128.       context.closePath();
  129.       context.fillStyle = 'rgb(100,255,255)';
  130.       context.shadowBlur = 10;
  131.       context.shadowColor = 'rgb(100,255,255)';
  132.       context.fill()
  133.     }
  135.     //第一个上面的圆
  136.     for (let index = 0; index < points.length; index++) {
  137.       context.beginPath();
  138.       context.arc(points[index].x,points[index].y, 3, 0, Math.PI * 2, true);
  139.       context.closePath();
  140.       context.fillStyle = "rgb(93,111,194)";
  141.       context.shadowBlur = 10;
  142.       context.shadowColor = "rgb(93,111,194)";
  143.       context.fill()
  144.     }
  145.     //第二条线上面的圆
  146.     for (let index = 0; index < point1s.length; index++) {
  147.       context.beginPath();
  148.       context.arc(point1s[index].x,point1s[index].y, 3, 0, Math.PI * 2, true);
  149.       context.closePath();
  150.       context.fillStyle = "rgb(193,111,194)"
  151.       context.shadowBlur = 10;
  152.       context.shadowColor ="rgb(193,111,194)"
  153.       context.fill()
  154.     }
  155.     //第三条线的圆
  156.     for (let index = 0; index < point2s.length; index++) {
  157.       context.beginPath();
  158.       context.arc(point2s[index].x,point2s[index].y, 3, 0, Math.PI * 2, true);
  159.       context.closePath();
  160.       context.fillStyle = "rgb(293,111,294)"
  161.       context.shadowBlur = 10;
  162.       context.shadowColor ="rgb(293,111,294)"
  163.       context.fill()
  164.     }
  165.     //四...圆
  166.     for (let index = 0; index < point2s.length; index++) {
  167.       context.beginPath();
  168.       context.arc(point2s[index].x,point2s[index].y-15, 3, 0, Math.PI * 2, true);
  169.       context.closePath();
  170.       context.fillStyle = "rgb(293,211,194)"
  171.       context.shadowBlur = 1;
  172.       context.shadowColor ="rgb(293,211,194)"
  173.       context.fill()
  174.     }
  175.     //第五条线上面的圆圈
  176.     for (let index = 0; index < point2s.length; index++) {
  177.       context.beginPath();
  178.       context.arc(point2s[index].x,point2s[index].y-35, 3, 0, Math.PI * 2, true);
  179.       context.closePath();
  180.       context.fillStyle = "rgb(93,211,294)"
  181.       context.shadowBlur = 1;
  182.       context.shadowColor ="rgb(93,211,294)"
  183.       context.fill()
  184.     }
  186.     context.restore();
  187.   }
  189.   //绘制填充折线和圆
  190.   drawMoreLine(context)
  191. </script>
  193. </body>
  194. </html>

53d11ec37d0fb46abd5d509be6e8b82b.png image.png

4、多条折线填充图

  1.  由于时间问题这个就最后一个案例吧。后面的更好的特效案例请期待我的小册,一直在进步写作的路上，希望尽快和大家见面。

分析
闭合区域的叠加而已

6e24ca65b3fe2fecac9d7bf061359052.png image.png

  1. //第一条线闭合区域
  2.     context.beginPath();
  3.     context.moveTo(0,0)
  4.     for (let index = 0; index < points.length; index++) {
  5.       context.lineTo(points[index].x,points[index].y);
  6.     }
  7.     context.lineTo(points[points.length-1].x,0);
  8.     context.closePath();
  10.     context.fillStyle="rgba(93,111,194,0.5)"
  11.     context.lineWidth=11
  12.     context.shadowBlur = 5;
  13.     context.fill();
  14.     context.closePath();

deb93e9b7280326934d25d11c0f7d991.png image.png

差几个文字

  1. //第一条线闭合区域
  2.     context.beginPath();
  3.     context.moveTo(0,0)
  4.     for (let index = 0; index < points.length; index++) {
  5.       context.lineTo(points[index].x,points[index].y);
  6.       //这里由于文字反转所以需要变换坐标系。且为了方便操作每次都将坐标圆点移动到顶点跟家方便的操作
  7.       context.save()
  8.       context.translate(points[index].x,points[index].y)
  9.       context.scale(1,-1)
  10.       context.fillText(points[index].y+"",0,-10)
  11.       //记得文字绘制完成还原坐标系，因为后面还要绘制线，不影响坐标系圆点是左下叫为圆形即可。
  12.       context.restore()
  13.     }
  14.     context.lineTo(points[points.length-1].x,0);
  15.     context.closePath();

43eb7fc4cb5a9172abe63e86c8597f24.png image.png

5、柱状图案例

群里有提到写柱状图的，下午一看前端大佬们人真的多，写了这篇水文居然这么多人点赞，于是我迫不及待的补上这个柱状图哈哈。非常感谢前端大佬们。第一次写js内容有问题地方多多指出多多见谅。

b64aef759c93629bd2a7eb389493956c.png image.png

1、绘制X轴和刻度。看代码注释

  1. let marginLeft=80
  2. let marginBootom=100
  3. function translateCanvas(context) {
  4.     //画布变换到左下角。
  5.     context.translate(marginLeft,canvas.height-marginBootom)
  6.     context.scale(1,-1)
  7. }
  8. //绘制X线和刻度等
  9. function drawXLine(context) {
  10.     //绘制X轴
  11.     context.beginPath();
  12.     //起始点
  13.     context.moveTo(0,0)
  14.     //X轴结束点
  15.     context.lineTo(canvas.width-marginLeft*2,0)
  16.     context.closePath();
  17.     context.strokeStyle = 'rgb(0,0,0)';
  18.     context.shadowBlur = 2;
  19.     context.lineWidth=0.1
  20.     context.shadowColor = 'rgb(100,255,255)';
  21.     context.stroke()
  24.     //绘制平行线
  25.     context.save()
  26.     //计算每一份单位宽度
  27.     let heightOne=(canvas.height-marginBootom*2)/7
  28.     for (let index=0; index<8; index++){
  29.         context.beginPath();
  30.         context.moveTo(0,0)
  31.         context.lineTo(canvas.width-marginLeft*2,0)
  32.         context.closePath();
  33.         context.strokeStyle = 'rgb(0,0,0)';
  34.         context.shadowBlur = 2;
  35.         context.lineWidth=0.1
  36.         context.shadowColor = 'rgb(100,255,255)';
  37.         context.stroke()
  38.         context.translate(0,heightOne)
  39.     }
  40.     context.restore()
  43.     //绘制刻度
  44.     context.save()
  45.     //计算每一份单位宽度
  46.     let widthOne=(canvas.width-marginLeft*2)/20
  47.     for (let index=0; index<21; index++){
  48.         context.beginPath();
  49.         context.moveTo(0,0)
  50.         context.lineTo(0,-5)
  51.         context.closePath();
  52.         context.strokeStyle = 'rgb(0,0,0)';
  53.         context.lineWidth=0.1
  54.         context.stroke()
  55.         context.translate(widthOne,0)
  56.     }
  57.     context.closePath()
  58.     context.restore()
  59. }

效果如下:

50b3f72a83ace605e321a2ea59d0af02.png image.png

2、绘制X轴下面的文字。看代码注释

这里有多一点绘制文字通过measureText进行测量即可如何讲一个文字绘制到刻度中间呢?

4edf80d0773860ea9fc036e97d5e6925.png image.png

  1. let xText=["北京","天津","河北","山西","四川","广东","上海","深圳","江苏","河南","山西",
  2.     "陕西","甘肃","内蒙","天塌","运城","哈尔滨","日本","台湾","香港"]
  3. //绘制底部文字
  4. function drawXDownText(context){
  5.     //绘制刻度
  6.     context.save()
  7.     context.scale(1,-1)
  8.     context.beginPath();
  9.     //计算每一份单位宽度
  10.     let widthOne=(canvas.width-marginLeft*2)/20
  11.     for (let index=0; index<xText.length; index++){
  12.         const textWidth = context.measureText(xText[index]);
  13.         //计算文字的文字，自己画图看看很简单就是相对位置剪来剪去
  14.         context.strokeStyle = 'rgb(111,11,111)';
  15.         context.fillText(xText[index],widthOne/2-textWidth.width/2,textWidth.emHeightAscent)
  16.         context.stroke()
  17.         context.translate(widthOne,0)
  18.     }
  19.     context.restore()
  22.     //绘制Y轴左边的文字
  23.     context.save()
  24.     //这里很重要,为了字体不反转
  25.     context.scale(1, -1)
  26.     context.translate(-30, 0)
  27.     context.font = "7pt Calibri";
  28.     let heightOne=(canvas.height-marginBootom*2)/7
  29.     //Y轴左边绘制文字
  30.     for (let i = 0; i < 8; i++) {
  31.         //画不是闭合区域 fill是闭合区域
  32.         context.stroke()
  33.         //测量文字
  34.         const textHeight = context.measureText((3000 * i).toString());
  35.         //设置文字绘制的位置
  36.         context.fillText((3000 * i).toString(), 0, textHeight.emHeightAscent / 2);
  37.         //每次绘制完之后继续往上平移
  38.         context.translate(0, -heightOne)
  39.     }
  40.     context.restore()
  43. }

ffe8960b57e842060e975a2439af2c83.png image.png

3、绘制巨型和造数据

⭐️⭐️⭐️⭐️⭐️⭐️这里比较重要的一点，评论区也提到了，如何将实际的数据于坐标系结合。例如我们实际的数据来自于后台都是几千几万。而我们的坐标系高度紧紧500px。其实简单的运算也就是一个单位的数字占实际像素多高danwei=500/最大值(例如2000)即可。那12000*danwei就是12000应该在实际画布中的位置。

  1. let datas=[[100,2800,9000],[150,2900,600],[300,12000,400],[500,13333,4000],[1300,2000,122],[111,3333,1111],[1111,2111,1111],[111,1611,222],[444,4444,333],[222,11111,2222],[2222,2235,11],[111,1345,1111],[1111,11111,2234],[1122,12223,12],[121,1665,111],[234,334,21]
  2.     ,[112,12134,1211],[1212,12111,134],[124,2021,112],[1222,20345,1212],[1412,17771,1111],[111,12222,1111],[1123,121333,1111],[11112,11212,111],]
  3. //绘制巨型等条状物
  4. function drawRect(context) {
  5.     //绘制刻度
  6.     context.save()
  7.     context.beginPath();
  8.     //计算每一份单位宽度
  9.     let widthOne=(canvas.width-marginLeft*2)/20
  10.     let widthOneRect=widthOne/3
  11.     let heightOne=(canvas.height-marginBootom*2)/7
  12.     let danwei=heightOne/3000
  13.     for (let index=0; index<xText.length; index++){
  14.         //计算文字的文字，自己画图看看很简单就是相对位置剪来剪去
  15.         context.fillStyle = 'rgb(189,119,119)';
  16.         context.fill()
  17.         //第一个条纹
  18.         context.fillRect(0,0,widthOneRect-1,datas[index][0]*danwei)
  19.         context.fillStyle = 'rgb(19,172,172)';
  20.         //第二个条纹
  21.         context.fillRect(widthOneRect,0,widthOneRect-1,datas[index][1]*danwei)
  22.         context.fillStyle = 'rgb(111,73,142)';
  23.         //第三个条纹
  24.         context.fillRect(widthOneRect*2,0,widthOneRect-1,datas[index][2]*danwei)
  25.         context.translate(widthOne,0)
  26.     }
  27.     context.restore()
  28. }

0a5d7d3bb73f189aaecce1f06a50a405.png image.png

后面有时间会多补上其他的…..

5、雷达系列图

  1.  如果上面你都按照我敲下来,我想自定义对你来说不再是难事,下面我们通过案例来看看自定义简单的API加初中简单的数学计算能给我们带来什么呢?![3edb2f4fe761653179ce26e142e39c57.png][]

绘制之前的分析

坐标变换到屏幕中心带来的方便
绘制多条骨架线段
如何实际数据映射到屏幕中
连线填充完成

1、坐标变换

如上图,如果圆点在屏幕中心会带来很方便的操作。直接上代码….不清楚看上面的坐标变换部分

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>雷达图</title>
  6. </head>
  7. <body>
  8. <canvas id="canvas" style="background: black"></canvas>
  9. </body>
  10. <script>
  11.     const canvas = document.getElementById("canvas");
  12.     canvas.width = 831;
  13.     canvas.height = 706;
  14.     //绘制的对象获取
  15.     const context = canvas.getContext("2d")
  16.     context.translate(canvas.width/2,canvas.height/2)
  17.     context.scale(1,-1)
  18.     //绘制圆
  19.     context.arc(0,0,50,0,Math.PI*2,true)
  20.     context.strokeStyle="rgb(189,142,16)"
  21.     context.stroke()
  23. </script>
  24. </html>

445a9c5952e8568a72e417c5b9b89e92.png image.png

2、绘制多条骨架线段

我们看到总共有三条骨架直线将屏幕分为六等分,我们可以简单的求出三条线段的方程式吧？初中的数学我相信你能明白。

Yx=-tan30*x

Yx= tan30*x

d63cb2c7e59675846a2f4ba981d15268.png image.png

  1.  let y1= Math.tan(Math.PI/180*30)*(-300)
  2.     let y2= Math.tan(Math.PI/180*30)*300
  3.     context.moveTo(-300,y1)
  4.     context.lineTo(300,y2)
  5.     context.closePath();
  6.     context.strokeStyle="rgb(189,142,16)"
  7.     context.stroke()

8eb17de891239cb7c098712485b045f5.png image.png

补全了

  1.  context.beginPath();
  3.     //左边一条骨架线段
  4.     let y1= Math.tan(Math.PI/180*30)*(-300)
  5.     let y2= Math.tan(Math.PI/180*30)*300
  6.     context.moveTo(-300,y1)
  7.     context.lineTo(300,y2)
  8.     context.strokeStyle="rgb(189,142,16)"
  9.     context.stroke()
  11.     //中间骨架线
  12.     context.moveTo(0,300)
  13.     context.lineTo(0,-300)
  16.     //右边一条骨架线段
  17.     let y11= -Math.tan(Math.PI/180*30)*(-300)
  18.     let y22= -Math.tan(Math.PI/180*30)*300
  19.     context.moveTo(-300,y11)
  20.     context.lineTo(300,y22)
  21.     context.strokeStyle="rgb(189,142,16)"
  22.     context.stroke()
  23.     context.closePath();

9b0c35ac0241f445cddb020186c5ea69.png image.png

发散的圆

  1.   for (let i = 0; i < 6; i++) {
  2.         context.beginPath();
  3.         //绘制圆
  4.         context.arc(0,0,50*(i+1),0,Math.PI*2,true);
  5.         context.strokeStyle="rgb(189,142,16)";
  6.         context.stroke();
  7.         context.closePath();
  8.     }

195629a6da8d49206ec2667b90167ba2.png image.png

3、如何实际数据映射到屏幕中

同样我们圆的半径可以看做是各个骨架坐标轴的长度,而我们实际数据是长度数据而已如何将长度数字映射到各个不规则的骨架坐标轴上呢？当然还是离不开简单的数学。例如我们一个数字250如下图两个白色虚线相交地方。我们实际的250代表的是圆点到焦点部分的长度。但是我们需要在坐标系中定位那就需要求出(x,y)在坐标系中的虚拟坐标。同样的简单的初中数学,不难得出（x,y）=(lengthcson30,lenghtsin30),如果你细心分析每个骨架坐标轴上的所有坐标都满足（x,y）=(lengthcson30,lenghtsin30)。接下来我们上代码看效果

da3e803839fcc6f193de2b8dd952f1ba.png image.png

  1.  //绘制网线填充
  2.     const datas = [[70, 100, 20, 5, 21, 99],[100, 120,50, 75, 121, 99],[117,211,259,232,190,200],[217,240,259,282,190,120]];
  3.     for (let i = 0; i < datas.length; i++) {
  4.         for (let index=0;index<datas[i].length;index++){
  5.             context.beginPath()
  6.             //右上角开始顺时针开始绘制
  7.             context.lineTo(datas[i][0]*Math.cos(Math.PI/180*30),datas[i][0]*Math.sin(Math.PI/180*30))
  8.             context.lineTo(datas[i][1]*Math.cos(Math.PI/180*30),-datas[i][1]*Math.sin(Math.PI/180*30))
  9.             context.lineTo(0,-datas[i][2])
  10.             context.lineTo(-datas[i][3]*Math.cos(Math.PI/180*30),-datas[i][3]*Math.sin(Math.PI/180*30))
  11.             context.lineTo(-datas[i][4]*Math.cos(Math.PI/180*30),datas[i][4]*Math.sin(Math.PI/180*30))
  12.             context.lineTo(0,datas[i][5])
  13.             context.fillStyle="rgba(189,142,16,0.09)"
  14.             context.fill()
  15.             context.closePath();
  16.         }
  17.     }
  18.     //绘制网线边缘线条
  19.     for (let i = 0; i < datas.length; i++) {
  20.         for (let index=0;index<datas[i].length;index++){
  21.             context.beginPath()
  22.             //右上角开始顺时针开始绘制
  23.             context.lineTo(datas[i][0]*Math.cos(Math.PI/180*30),datas[i][0]*Math.sin(Math.PI/180*30))
  24.             context.lineTo(datas[i][1]*Math.cos(Math.PI/180*30),-datas[i][1]*Math.sin(Math.PI/180*30))
  25.             context.lineTo(0,-datas[i][2])
  26.             context.lineTo(-datas[i][3]*Math.cos(Math.PI/180*30),-datas[i][3]*Math.sin(Math.PI/180*30))
  27.             context.lineTo(-datas[i][4]*Math.cos(Math.PI/180*30),datas[i][4]*Math.sin(Math.PI/180*30))
  28.             context.lineTo(0,datas[i][5])
  29.             context.strokeStyle="rgb(189,142,16)"
  30.             context.stroke()
  31.             context.closePath();
  32.         }
  33.     }

d4fa687fefa3a917347ad452b90866ec.png image.png

掘金文字限制,会另起篇章!!!!!

五、总结

  1.   对于我一个基本没使用过HTML5和JS移动端人员来说一天的功夫就能够完成这些内容。对于前端的大佬们来说简单不过来,当然了奇怪的是我也问过很多前端开发人员,对于自定义也是一知半解,不够深入，当我问起图表，ECharts总是频频出口，可能有些公司的UI不是太严格，开发基本在Echarts里面寻找类似图表或者设计人员直接基于ECharts进行选择设计,可能是种种原因国内的UI基本趋向于同一,技术在变革,UI设计也应该别具一格，有所特色。当然了我们最好有自定义的能力岂不更好？当你遇到不常见的设计你可以随心所欲，那是一件多么美好的事情。

我想下面这些图表,无非巨型、弧度、等加画布变换、填充渐变、文字绘制吧？是时候展示你的技术了9e70963cfbe1ddd1cf6b3929a2bed764.png

8d26c8c3bd41442eb0cb6f6549d39297.png image.png

当然了ECharts里面有很多自定义的内容。如果你认真手敲了这篇文字，你就应该对于自定义内容胸有成竹。至于好的操作当然离不开手势和动画，后面我们来开始手势加动画来逐渐过渡到K线，没错就是K线。

cb47a335ed7315ecde9532875051eb42.gif

k线图

最后

如果你觉得这篇内容对你挺有启发，我想邀请你帮我三个小忙：

  1. 点个「在看」，让更多的人也能看到这篇内容（喜欢不点在看，都是耍流氓 -_-）
  2. 欢迎加我微信「huab119」拉你进技术群，长期交流学习…

  3. 关注公众号「前端劝退师」，持续为你推送精选好文，也可以加我为好友，随时聊骚。

    4a593d69be305a100f3020cc3d7c73c4.png

70bcb0261af0895efae51672119d1851.png

点个在看支持我吧，转发就更好了

发表评论

表情：
评论列表 （有 0 条评论，251人围观）

还没有评论，来说两句吧...

相关阅读

    相关 前端都是手写ECharts ?

    一、自定义的必要性      绘制的底层是强大的,我们所用的各端语言只是在现代UI追求的步伐中和用户喜好的交互中求同存异，抽取封装出自成个性风格的UI控件,当然面对万亿级

    布满荆棘的人生布满荆棘的人生/ 0 赞/ 252 阅读