window.__EC_DOC_option_gl_series_lines3D = {
  "name": {
    "desc": "<p>Series name used for displaying in <a href=\"https://echarts.apache.org/zh/option.html#tooltip\" target=\"_blank\">tooltip</a> and filtering with <a href=\"https://echarts.apache.org/zh/option.html#legend\" target=\"_blank\">legend</a>, or updating data and configuration with <code class=\"codespan\">setOption</code>.</p>\n"
  },
  "coordinateSystem": {
    "desc": "<p>The coordinate used in the series, whose options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;geo3D&#39;</code>\n  Use 3D geographic coordinate, with <a href=\"#series-.geoIndex\">geoIndex</a> to assign the corresponding 3D geographic coordinate components.</li>\n</ul>\n<ul>\n<li><p><code class=\"codespan\">&#39;globe&#39;</code></p>\n<p>  Use 3D globe coordinate, with <a href=\"#series-.globeIndex\">globeIndex</a> to assign the corresponding 3D globe coordinate components.</p>\n</li>\n</ul>\n"
  },
  "geo3DIndex": {
    "desc": "<p>The index of the <a href=\"#geo3D\">geo3D</a> component used by the axis.The first <a href=\"#grid3D\">grid3D</a> component is used by default.</p>\n"
  },
  "globeIndex": {
    "desc": "<p>The index of the <a href=\"#globe\">globe</a> component used by the axis.The first <a href=\"#globe\">globe</a> component is used by default.</p>\n"
  },
  "polyline": {
    "desc": "<p>If draw as a polyline.</p>\n<p>Default to be <code class=\"codespan\">false</code>. Can only draw a two end straight line.</p>\n<p>If it is set true, <a href=\"#series-lines.data.coords\">data.coords</a> can have more than two coords to draw a polyline. It is useful when visualizing GPS track data.</p>\n"
  },
  "effect": {
    "desc": "<p>The setting about the special effects of lines.</p>\n"
  },
  "effect.show": {
    "desc": "<p>Whether to show special effect. It is not displayed by default.</p>\n"
  },
  "effect.period": {
    "desc": "<p>The duration of the special effect, which unit is second.</p>\n"
  },
  "effect.constantSpeed": {
    "desc": "<p>Whether the moving animation of the trail of special effect has a constant speed, which unit is dimensioned in 3D space. The <a href=\"#series-lines.effect.period\">period</a> will be ignored when it is set to a non-null value.</p>\n"
  },
  "effect.trailWidth": {
    "desc": "<p>The width of the trail of special effects. </p>\n"
  },
  "effect.trailLength": {
    "desc": "<p>The length of trail of special effect.  The values from 0 to 1 could be set. Is the percentage of the length of the line.</p>\n"
  },
  "effect.trailColor": {
    "desc": "<p>The color of the trail, which default is the same as the line color.</p>\n"
  },
  "effect.trailOpacity": {
    "desc": "<p>The opacity of the trail, which default is the same as line opacity.</p>\n"
  },
  "lineStyle": {
    "desc": "<p>The line style of the lines.</p>\n"
  },
  "lineStyle.color": {
    "desc": "<p>The color of the line.  Color is taken from <a href=\"#color\">option.color Palette</a> by default. </p>\n<p>In addition to color strings, RGBA values represented by arrays are supported, for example:</p>\n<pre><code class=\"lang-js\">// pure white\n[1, 1, 1, 1]\n</code></pre>\n<p>When using an array representation, each channel can set a value greater than 1 to represent the color value of HDR.</p>\n"
  },
  "lineStyle.opacity": {
    "desc": "<p>The opacity of the line.</p>\n"
  },
  "lineStyle.width": {
    "desc": "<p>The width of the line.</p>\n"
  },
  "data": {
    "desc": "<p>A data array of 3D lines.\nUsually, each item of data can be a set of coordinates containing the start point and end point.</p>\n<p>More than two coordinates can be supported when <a href=\"#series-lines3D.polyline\">polyline</a> is set to <code class=\"codespan\">true</code>.\nas follows:</p>\n<pre><code class=\"lang-js\">data: [\n    [\n        [120, 66, 1], // latitude, longitude and altitude coordinates of the start point\n        [122, 67, 2]  // latitude, longitude and altitude coordinates of the end point\n    ]\n]\n</code></pre>\n<p>Sometimes you need to configure the name of the data item or a separate style. You need to write the latitude and longitude coordinates to the coords property, as follows:</p>\n<pre><code class=\"lang-js\">data: [\n    {\n        coords: [ [120, 66], [122, 67] ],\n        // The value of data\n        value: 10,\n        // The name of data\n        name: &#39;foo&#39;,\n        // The style of line\n        lineStyle: {}\n    }\n]\n</code></pre>\n"
  },
  "data.coords": {
    "desc": "<p>An array of two or more latitude and longitude coordinates. When <a href=\"#series-lines3D.polyline\">polyline</a> is set to <code class=\"codespan\">true</code>,  support more than two coordinates.</p>\n"
  },
  "data.value": {
    "desc": "<p>The value of data.</p>\n"
  },
  "data.lineStyle": {
    "desc": "<p>Style setting for single data (single line).</p>\n"
  },
  "data.lineStyle.color": {
    "desc": "<p>The color of the line. </p>\n<p>In addition to color strings, RGBA values represented by arrays are supported, for example:</p>\n<pre><code class=\"lang-js\">// pure white\n[1, 1, 1, 1]\n</code></pre>\n<p>When using an array representation, each channel can set a value greater than 1 to represent the color value of HDR.</p>\n"
  },
  "data.lineStyle.opacity": {
    "desc": "<p>The opacity of the line.</p>\n"
  },
  "data.lineStyle.width": {
    "desc": "<p>The width of the line.</p>\n"
  },
  "blendMode": {
    "desc": "<p>Sets the type of compositing operation to apply when drawing a new shape. </p>\n<p>Currently supporting <code class=\"codespan\">&#39;source-over&#39;</code>, <code class=\"codespan\">&#39;lighter&#39;</code>. The default is <code class=\"codespan\">&#39;source-over&#39;</code> mode is blended by alpha. The <code class=\"codespan\">&#39;lighter&#39;</code> is overlap mode. In this mode, the area where the number of graphics is concentrated can be highlighted by the overlap.</p>\n"
  },
  "zlevel": {
    "desc": "<p>The layer in which the component is located.</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid the crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n<p><strong>Note:</strong> The layers of the components in echarts-gl need to be separated from the layers of the components in echarts. The same <code class=\"codespan\">zlevel</code> cannot be used for both WebGL and Canvas drawing at the same time.</p>\n"
  },
  "silent": {
    "desc": "<p>Whether the graph doesn`t respond and triggers a mouse event. The default is false, which is to respond to and trigger mouse events.</p>\n"
  }
}