ZRender源码分析6:Shape对象详解之路径

开始

说到这里,就不得不提SVG的路径操作了,因为ZRender完全的模拟了SVG原生的path元素的用法,很是强大。 关于SVG的Path,请看这里: Path (英文版) 或者 【MDN】SVG教程(5) 路径 [译] (中文版), 很明显的是canvas中的路径没有SVG的用着舒服,那到底ZRender是如何实现的呢,让我给你娓娓道来(不过要想继续进行下去,上面的SVG的PATH必须了解。)。

示例

打开API,shape.path,可以看到,path的配置有MLHVCSQTZ等字母组成的字符串,svg的path也支持小写,也有一个A命令,难道ZRender没有实现? 错,实现了,只是在API上没有写明而已,支持大小写,支持A(圆弧)命令!为了证明我所说,来个示例:

require(
[
    ‘../src/zrender‘, ‘../src/shape/Path‘
], function( zrender, PathShape )
{

	var box = document.getElementById(‘box‘);
	var zr = zrender.init(box);

	zr.addShape(new PathShape(
	{
		style:
		{
			x: 0,
			y: 0,
			path: ‘M80 80 A 45 45, 0, 0, 0, 125 125 L 125 80 Z‘,
			color: ‘#F60‘,
			textPosition: ‘inside‘,
			textColor: ‘red‘,
			strokeColor: ‘black‘
		},
		draggable: true
	}));

	zr.addShape(new PathShape(
	{
		style:
		{
			x: 0,
			y: 0,
			path: ‘M230 80 A 45 45, 0, 1, 0, 275 125 L 275 80 Z‘,
			color: ‘#F60‘,
			textPosition: ‘inside‘,
			textColor: ‘red‘,
			strokeColor: ‘black‘
		},
		draggable: true
	}));

	zr.render();
});

得到如下结果:


再用SVG来一个相同配置的:

<svg version="1.1" baseProfile="full" xmlns="http://www.w3.org/2000/svg">
    <path d="M80 80
        A 45 45, 0, 0, 0, 125 125
        L 125 80 Z" fill="#F60"/>
    <path d="M230 80
        A 45 45, 0, 1, 0, 275 125
        L 275 80 Z" fill="#F60"/>
</svg>

好吧,得到的结果一模一样,我就不贴图了。不多说了,这就是移植,我喜欢。

_parsePathData

打开zrender/shape/Path,buildPath先调用的就是_parsePathData,作用为:解析path字符串为数组命令,也就是个解析器嘛。

 _parsePathData : function(data) {
     if (!data) {
         return [];
     }

     // command string
     var cs = data;

     // command chars
     var cc = [
         ‘m‘, ‘M‘, ‘l‘, ‘L‘, ‘v‘, ‘V‘, ‘h‘, ‘H‘, ‘z‘, ‘Z‘,
         ‘c‘, ‘C‘, ‘q‘, ‘Q‘, ‘t‘, ‘T‘, ‘s‘, ‘S‘, ‘a‘, ‘A‘
     ];

     cs = cs.replace(/-/g, ‘ -‘);// M 100 100 L 100 200 L 100-200 Z -> M 100 100 L 100 200 L 100 -200 Z
     cs = cs.replace(/  /g, ‘ ‘);// M 100 100 L 100 200 L 100 -200 -> M 100 100 L 100 200 L 100  -200 -> M 100 100 L 100 200 L 100 -200
     cs = cs.replace(/ /g, ‘,‘);// M 100 100 L 100 200 L 100 -200 -> M,100,100,L,100,200,L,100,-200
     cs = cs.replace(/,,/g, ‘,‘);//如果出现两个逗号,换成一个逗号 -> M,100,100,L,100,200,L,100,-200

     //cs = cs.replace(/-/g, ‘ -‘).replace(/  /g, ‘ ‘).replace(/ /g, ‘,‘).replace(/,,/g, ‘,‘); 这样写,会不会很帅气,(-

     var n;
     // create pipes so that we can split the data
     for (n = 0; n < cc.length; n++) {
         cs = cs.replace(new RegExp(cc[n], ‘g‘), ‘|‘ + cc[n]);
     }

     // |M,100,100,|L,100,200,|L,100,-200

     // create array
     var arr = cs.split(‘|‘); // [‘‘,‘M,100,100,‘,‘L,100,200,‘,‘L,100,-200‘]
     var ca = [];
     // init context point
     var cpx = 0; //cpx和cpy是循环里的全局都在使用,小写命令是累计计算,大写命令是复制计算。
     var cpy = 0;
     for (n = 1; n < arr.length; n++) { // 从1开始,因为第一个元素肯定为空
         var str = arr[n]; // M,100,100,
         var c = str.charAt(0); // M
         str = str.slice(1); //,100,100,
         str = str.replace(new RegExp(‘e,-‘, ‘g‘), ‘e-‘);

         var p = str.split(‘,‘);// [‘‘,‘100‘,‘100‘,‘‘]
         if (p.length > 0 && p[0] === ‘‘) {
             p.shift();
         }
         // [‘100‘,‘100‘,‘‘]

         for (var i = 0; i < p.length; i++) {
             p[i] = parseFloat(p[i]);
         }

         // [100,100,NaN]

         while (p.length > 0) {
             if (isNaN(p[0])) {
                 break;
             }
             var cmd = null;
             var points = [];

             var ctlPtx;
             var ctlPty;
             var prevCmd;

             var rx;
             var ry;
             var psi;
             var fa;
             var fs;

             var x1 = cpx;
             var y1 = cpy;

             // convert l, H, h, V, and v to L
             switch (c) {
             case ‘l‘:
                 cpx += p.shift();
                 cpy += p.shift();
                 cmd = ‘L‘;
                 points.push(cpx, cpy);
                 break;
             case ‘L‘:
                 cpx = p.shift();
                 cpy = p.shift();
                 points.push(cpx, cpy);
                 break;
             //在l的时候,是直接相加的,而L的时候,是直接赋值的 ,这就说明大小写是不一样的
             // L 表示lineTo
             case ‘m‘:
                 cpx += p.shift();
                 cpy += p.shift();
                 cmd = ‘M‘;
                 points.push(cpx, cpy);
                 c = ‘l‘;
                 break;
             case ‘M‘:
                 cpx = p.shift();
                 cpy = p.shift();
                 cmd = ‘M‘;
                 points.push(cpx, cpy);
                 c = ‘L‘;
                 break;
// M 表示moveTo
             case ‘h‘:
                 cpx += p.shift();
                 cmd = ‘L‘;
                 points.push(cpx, cpy);
                 break;
             case ‘H‘:
                 cpx = p.shift();
                 cmd = ‘L‘;
                 points.push(cpx, cpy);
                 break;
             // H 表示水平lineTo,只改变X值
             case ‘v‘:
                 cpy += p.shift();
                 cmd = ‘L‘;
                 points.push(cpx, cpy);
                 break;
             case ‘V‘:
                 cpy = p.shift();
                 cmd = ‘L‘;
                 points.push(cpx, cpy);
                 break;
             // H 表示垂直lineTo,只改变Y值
             case ‘C‘:
                 points.push(p.shift(), p.shift(), p.shift(), p.shift());
                 cpx = p.shift();
                 cpy = p.shift();
                 points.push(cpx, cpy);
                 break;
             case ‘c‘:
                 points.push(
                     cpx + p.shift(), cpy + p.shift(),
                     cpx + p.shift(), cpy + p.shift()
                 );
                 cpx += p.shift();
                 cpy += p.shift();
                 cmd = ‘C‘;
                 points.push(cpx, cpy);
                 break;
             // C表示二次贝塞尔曲线
             case ‘S‘:
                 ctlPtx = cpx;
                 ctlPty = cpy;
                 prevCmd = ca[ca.length - 1];
                 if (prevCmd.command === ‘C‘) {
                     ctlPtx = cpx + (cpx - prevCmd.points[2]);
                     ctlPty = cpy + (cpy - prevCmd.points[3]);
                 }
                 points.push(ctlPtx, ctlPty, p.shift(), p.shift());
                 cpx = p.shift();
                 cpy = p.shift();
                 cmd = ‘C‘;
                 points.push(cpx, cpy);
                 break;
             case ‘s‘:
                 ctlPtx = cpx, ctlPty = cpy;
                 prevCmd = ca[ca.length - 1];
                 if (prevCmd.command === ‘C‘) {
                     ctlPtx = cpx + (cpx - prevCmd.points[2]);
                     ctlPty = cpy + (cpy - prevCmd.points[3]);
                 }
                 points.push(
                     ctlPtx, ctlPty,
                     cpx + p.shift(), cpy + p.shift()
                 );
                 cpx += p.shift();
                 cpy += p.shift();
                 cmd = ‘C‘;
                 points.push(cpx, cpy);
                 break;
             // C表示光滑二次贝塞尔曲线
             case ‘Q‘:
                 points.push(p.shift(), p.shift());
                 cpx = p.shift();
                 cpy = p.shift();
                 points.push(cpx, cpy);
                 break;
             case ‘q‘:
                 points.push(cpx + p.shift(), cpy + p.shift());
                 cpx += p.shift();
                 cpy += p.shift();
                 cmd = ‘Q‘;
                 points.push(cpx, cpy);
                 break;
             // Q表示三次贝塞尔曲线
             case ‘T‘:
                 ctlPtx = cpx, ctlPty = cpy;
                 prevCmd = ca[ca.length - 1];
                 if (prevCmd.command === ‘Q‘) {
                     ctlPtx = cpx + (cpx - prevCmd.points[0]);
                     ctlPty = cpy + (cpy - prevCmd.points[1]);
                 }
                 cpx = p.shift();
                 cpy = p.shift();
                 cmd = ‘Q‘;
                 points.push(ctlPtx, ctlPty, cpx, cpy);
                 break;
             case ‘t‘:
                 ctlPtx = cpx, ctlPty = cpy;
                 prevCmd = ca[ca.length - 1];
                 if (prevCmd.command === ‘Q‘) {
                     ctlPtx = cpx + (cpx - prevCmd.points[0]);
                     ctlPty = cpy + (cpy - prevCmd.points[1]);
                 }
                 cpx += p.shift();
                 cpy += p.shift();
                 cmd = ‘Q‘;
                 points.push(ctlPtx, ctlPty, cpx, cpy);
                 break;
             // Q表示光滑三次贝塞尔曲线
             case ‘A‘:
                 rx = p.shift(); //椭圆的x轴半径
                 ry = p.shift(); //椭圆的y轴半径
                 psi = p.shift();//椭圆的旋转角度
                 fa = p.shift();//角度大小  0表示小角度,1表示大弧度
                 fs = p.shift();//弧线方向  0表示从起点到终点沿逆时针画弧,1表示从起点到终点沿顺时针画弧

                 x1 = cpx, y1 = cpy; //开始的点
                 cpx = p.shift(), cpy = p.shift(); //结束的点
                 cmd = ‘A‘;
                 points = this._convertPoint(
                     x1, y1, cpx, cpy, fa, fs, rx, ry, psi
                 );
                 break;
             case ‘a‘:
                 rx = p.shift();
                 ry = p.shift();
                 psi = p.shift();
                 fa = p.shift();
                 fs = p.shift();

                 x1 = cpx, y1 = cpy;
                 cpx += p.shift();
                 cpy += p.shift();
                 cmd = ‘A‘;
                 points = this._convertPoint(
                     x1, y1, cpx, cpy, fa, fs, rx, ry, psi
                 );
                 break;
// A是啥玩意?
             }

             ca.push({
                 command : cmd || c,
                 points : points
             });
         }

         //如果是z,z不去分大小写,直接push进入,points为空数组
         if (c === ‘z‘ || c === ‘Z‘) {
             ca.push({
                 command : ‘z‘,
                 points : []
             });
         }
     }

     return ca;
 }
  • 如果没有data,直接返回空数组
  • 将传入的data赋值给cs,将cs进行一系列的replace(将-换成 -,将两个空格换成一个空格,将一个空格换成逗号,将两个逗号换成一个逗号),这些,都是为了兼容SVG的规法和各种不规范的写法
  • 将cs用竖线加命令字符分隔开,便于下一步进行再次分隔
  • 再用竖线将字符串变成数组,声明ca(最后所返回的值),声明cpx和cpy(绘制路径的起点,相对于下面的循环,是一个全局性质的变量)
  • 遍历arr,其中c是命令符,经过处理,最后的点坐标,被赋值到p变量上
  • 开始while循环,真正的往ca中push值,进入switch,如果是命令是大写的cpx直接被赋值为p中的点,如果是小写的,会在原来的cpx和cpy的基础上进行累加。(具体用法可以参见那篇SVG的文章)
  • 这些命令的意思在注释中已经写明,唯一需要说的是A(圆弧),这个比较复杂,需要细细体会,我就不分析了,不过也可以看这里,如果作者有回应的话。 https://github.com/ecomfe/zrender/issues/98
  • 最后返回的ca是一个数组,看下图:

创建路径 buildPath

buildPath : function(ctx, style) {
    var path = style.path;

    var pathArray = this.pathArray || this._parsePathData(path);

    // 平移坐标
    var x = style.x || 0;
    var y = style.y || 0;

    var p;
    // 记录边界点,用于判断inside
    var pointList = style.pointList = [];
    var singlePointList = [];
    for (var i = 0, l = pathArray.length; i < l; i++) {
        if (pathArray[i].command.toUpperCase() == ‘M‘) { // 如果是M,说明又画了一个新的区域,就把原来的singlePointList塞入到最终结果中,再把singlePointList清空
            singlePointList.length > 0
            && pointList.push(singlePointList);
            singlePointList = [];
        }
        p = pathArray[i].points;
        for (var j = 0, k = p.length; j < k; j += 2) { //把所有的point点塞入singlePointList
            singlePointList.push([p[j] + x, p[j+1] + y]);
        }
    }
    singlePointList.length > 0 && pointList.push(singlePointList); //如果存在点,塞入最终结果里

    var c;
    for (var i = 0, l = pathArray.length; i < l; i++) {
        c = pathArray[i].command;
        p = pathArray[i].points;
        // 平移变换
        for (var j = 0, k = p.length; j < k; j++) { //style.x和style.y是一个参考点
            if (j % 2 === 0) {
                p[j] += x;
            } else {
                p[j] += y;
            }
        }
        switch (c) {
            case ‘L‘:
                ctx.lineTo(p[0], p[1]);
                break;
            case ‘M‘:
                ctx.moveTo(p[0], p[1]);
                break;
            case ‘C‘:
                ctx.bezierCurveTo(p[0], p[1], p[2], p[3], p[4], p[5]);
                break;
            case ‘Q‘:
                ctx.quadraticCurveTo(p[0], p[1], p[2], p[3]);
                break;
            // 这几个做法就比较明显了,调用了原生CanvasAPI,但是A呢,对了,在SVG中,是弧形,
            // 文档中也不写,作者好低调,赞!
            case ‘A‘:
                var cx = p[0];
                var cy = p[1];
                var rx = p[2];
                var ry = p[3];
                var theta = p[4];
                var dTheta = p[5];
                var psi = p[6];
                var fs = p[7];
                var r = (rx > ry) ? rx : ry;
                var scaleX = (rx > ry) ? 1 : rx / ry;
                var scaleY = (rx > ry) ? ry / rx : 1;

                ctx.translate(cx, cy);
                ctx.rotate(psi);
                ctx.scale(scaleX, scaleY);
                ctx.arc(0, 0, r, theta, theta + dTheta, 1 - fs);
                ctx.scale(1 / scaleX, 1 / scaleY);
                ctx.rotate(-psi);
                ctx.translate(-cx, -cy);
                break;
            case ‘z‘:
                ctx.closePath();
                break;
        }
    }

    return;
},
  • xy是一个绘制路径的参考点,如果用户没有指定,这里默认为0 0
  • 记录边界点,用于判断inside,这里对M的判断主要是处理一个命令画多个区域的问题。而判断inside的作用主要是在Base类里drawText的时候用到
  • 开始遍历pathArray(即上面说的ca),style.x/style.y是一个参考点,所有的坐标都会加上这个参考点,即为平移变换。
  • 进入switch进行真正的canvas原生API绘制路径,最后碰到z,进行closePath
  • A我就不说了,没找到这个算法的相关资料,欢迎大家指导。

热区 getRect

getRect : function(style) {
    if (style.__rect) {
        return style.__rect;
    }

    var lineWidth;
    if (style.brushType == ‘stroke‘ || style.brushType == ‘fill‘) {
        lineWidth = style.lineWidth || 1;
    }
    else {
        lineWidth = 0;
    }

    var minX = Number.MAX_VALUE;
    var maxX = Number.MIN_VALUE;

    var minY = Number.MAX_VALUE;
    var maxY = Number.MIN_VALUE;

    // 平移坐标
    var x = style.x || 0;
    var y = style.y || 0;

    var pathArray = this.pathArray || this._parsePathData(style.path);
    for (var i = 0; i < pathArray.length; i++) {
        var p = pathArray[i].points;

        for (var j = 0; j < p.length; j++) {
            if (j % 2 === 0) { // 0,2,4,6,8....为x值
                if (p[j] + x < minX) {
                    minX = p[j] + x;
                }
                if (p[j] + x > maxX) {
                    maxX = p[j] + x;
                }
            }
            else { // 1,3,5,7,9...为y值
                if (p[j] + y < minY) {
                    minY = p[j] + y;
                }
                if (p[j] + y > maxY) {
                    maxY = p[j] + y;
                }
            }
        }
    }

    var rect;
    if (minX === Number.MAX_VALUE
        || maxX === Number.MIN_VALUE
        || minY === Number.MAX_VALUE
        || maxY === Number.MIN_VALUE
    ) {
        rect = {
            x : 0,
            y : 0,
            width : 0,
            height : 0
        };
    }
    else {
        rect = {
            x : Math.round(minX - lineWidth / 2),
            y : Math.round(minY - lineWidth / 2),
            width : maxX - minX + lineWidth,
            height : maxY - minY + lineWidth
        };
    }
    style.__rect = rect;
    return rect;
}
  • 关于Number.MAX_VALUE和Number.MIN_VALUE,请看这里:JavaScript Number 对象
  • 获得pathArray(即为上面说的ca),遍历之
  • 加上参考点x/y后分别跟最大值最小值作比较,最后得出靠谱的minX,minY,maxX,maxY,木有什么惊喜
  • 如果minX,minY,maxX,maxY原封未动,那就是pathArray出了问题(没有取到或者什么的),返回一个都是0的对象
  • 如果正常返回x,y,width,height,关于lineWidth的问题,前一篇有解释。
时间: 2024-10-11 04:37:19

ZRender源码分析6:Shape对象详解之路径的相关文章

android源码分析 android toast使用详解 toast自定义

在安卓开发过程中,toast使我们经常使用的一个类,当我们需要向用户传达一些信息,但是不需要和用户交互时,该方式就是一种十分恰当的途径. 我们习惯了这样使用toast:Toast.makeText(Context context, String info, int duration).show();该方法是 系统为我们提供的一个方便的创建toast对象的静态方法,其内部依然是调用toast的相关方法完成.下面 就从其源码对该类的实现做一个分析 在toast类中,最重要的用于显示该toast的sh

MapReduce阶段源码分析以及shuffle过程详解

MapReducer工作流程图: 1. MapReduce阶段源码分析 1)客户端提交源码分析 解释:   - 判断是否打印日志   - 判断是否使用新的API,检查连接   - 在检查连接时,检查输入输出路径,计算切片,将jar.配置文件复制到HDFS   - 计算切片时,计算最小切片数(默认为1,可自定义)和最大切片数(默认是long的最大值,可以自定义)   - 查看给定的是否是文件,如果是否目录计算目录下所有文件的切片   - 通过block大小和最小切片数.最大切片数计算出切片大小  

memcached源码分析-----memcached启动参数详解以及关键配置的默认值

转载请注明出处: http://blog.csdn.net/luotuo44/article/details/42672913 本文开启本系列博文的代码分析.本系列博文研究是memcached版本是1.4.21. 本文将给出memcached启动时各个参数的详细解释以及一些关键配置的默认值.以便在分析memcached源码的时候好随时查看.当然也方便使用memcached时可以随时查看各个参数的含义.<如何阅读memcached源码>说到memcached有很多全局变量(也就是关键配置),这些

Vue.js 源码分析(十) ref属性详解

用法 ref 被用来给元素或子组件注册引用信息.引用信息将会注册在父组件的 $refs 对象上.如果在普通的 DOM 元素上使用,引用指向的就是 DOM 元素:如果用在子组件上,引用就指向组件实例,例如: <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Document</title> <scrip

Laravel源码分析--Laravel生命周期详解

一.XDEBUG调试 这里我们需要用到php的 xdebug 拓展,所以需要小伙伴们自己去装一下,因为我这里用的是docker,所以就简单介绍下在docker中使用xdebug的注意点. 1.在phpstorm中的 Perferences >> Languages & Framework >> PHP >> debug >> DBGp Proxy 中的Host填写的是宿主机的IP地址.可以在命令行中使用ifconfig / ipconfig查看你的本

spring源码分析之spring-web http详解

spring-web是spring webmvc的基础,它的功能如下: 1. 封装http协议中client端/server端的request请求和response响应及格式的转换,如json,rss,xml等. 2. 远程调用包括jaxws.caucho.httpinvoker 3. web相关的accept/bind/client/context/filter/jsf/method/multipart 先从http协议中的封装来看: 先了解一下http的基础:(来自:http://blog.

spring源码分析之spring-jdbc模块详解

0 概述 Spring将替我们完成所有使用JDBC API进行开发的单调乏味的.底层细节处理工作.下表描述了哪些是spring帮助我们做好的,哪些是我们要做的. Action  Spring  You Define connection parameters.    X Open the connection.  X   Specify the SQL statement.    X Declare parameters and provide parameter values   X Prep

spring源码分析之spring-jms模块详解

0 概述 spring提供了一个jms集成框架,这个框架如spring 集成jdbc api一样,简化了jms api的使用. jms可以简单的分成两个功能区,消息的生产和消息的消费.JmsTemplate类用来生成消息和同步接受消息.和其它java ee的消息驱动样式一样,对异步消息,spring也提供了许多消息监听容器用来创建消息驱动的POJO(MDPs).spring同时也提供了创建消息监听器的声明方式. org.springframework.jms.core 提供了使用JMS的核心功能

Hadoop1.x源码分析一:Configuration 详解

1.Hadoop配置文件的形式 Hadoop的配置文件是以XML的形式,跟元素是configuration,一般只包含子元素property.每一个property元素就是一个配置项,配置文件不支持分层或分级.每个配置项一般包括配置属性的名称name.值value和一个关于配置项的描述description;元素final和java中的关键字final类似,意味着这个配置项是"固定不变的".final一般不出现,但在合并资源的时候,可以防止配置项的值被覆盖. 在Configuratio