| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| |
| import * as vec2 from 'zrender/src/core/vector'; |
| import {getSymbolSize, getNodeGlobalScale} from './graphHelper'; |
| import GraphSeriesModel, { GraphEdgeItemOption } from './GraphSeries'; |
| import Graph from '../../data/Graph'; |
| import List from '../../data/List'; |
| import * as zrUtil from 'zrender/src/core/util'; |
| import {getCurvenessForEdge} from '../helper/multipleGraphEdgeHelper'; |
| |
| const PI = Math.PI; |
| |
| const _symbolRadiansHalf: number[] = []; |
| |
| /** |
| * `basedOn` can be: |
| * 'value': |
| * This layout is not accurate and have same bad case. For example, |
| * if the min value is very smaller than the max value, the nodes |
| * with the min value probably overlap even though there is enough |
| * space to layout them. So we only use this approach in the as the |
| * init layout of the force layout. |
| * FIXME |
| * Probably we do not need this method any more but use |
| * `basedOn: 'symbolSize'` in force layout if |
| * delay its init operations to GraphView. |
| * 'symbolSize': |
| * This approach work only if all of the symbol size calculated. |
| * That is, the progressive rendering is not applied to graph. |
| * FIXME |
| * If progressive rendering is applied to graph some day, |
| * probably we have to use `basedOn: 'value'`. |
| */ |
| export function circularLayout( |
| seriesModel: GraphSeriesModel, |
| basedOn: 'value' | 'symbolSize' |
| ) { |
| const coordSys = seriesModel.coordinateSystem; |
| if (coordSys && coordSys.type !== 'view') { |
| return; |
| } |
| |
| const rect = coordSys.getBoundingRect(); |
| |
| const nodeData = seriesModel.getData(); |
| const graph = nodeData.graph; |
| |
| const cx = rect.width / 2 + rect.x; |
| const cy = rect.height / 2 + rect.y; |
| const r = Math.min(rect.width, rect.height) / 2; |
| const count = nodeData.count(); |
| |
| nodeData.setLayout({ |
| cx: cx, |
| cy: cy |
| }); |
| |
| if (!count) { |
| return; |
| } |
| |
| _layoutNodesBasedOn[basedOn](seriesModel, graph, nodeData, r, cx, cy, count); |
| |
| graph.eachEdge(function (edge, index) { |
| let curveness = zrUtil.retrieve3( |
| edge.getModel<GraphEdgeItemOption>().get(['lineStyle', 'curveness']), |
| getCurvenessForEdge(edge, seriesModel, index), |
| 0 |
| ); |
| const p1 = vec2.clone(edge.node1.getLayout()); |
| const p2 = vec2.clone(edge.node2.getLayout()); |
| let cp1; |
| const x12 = (p1[0] + p2[0]) / 2; |
| const y12 = (p1[1] + p2[1]) / 2; |
| if (+curveness) { |
| curveness *= 3; |
| cp1 = [ |
| cx * curveness + x12 * (1 - curveness), |
| cy * curveness + y12 * (1 - curveness) |
| ]; |
| } |
| edge.setLayout([p1, p2, cp1]); |
| }); |
| } |
| |
| interface LayoutNode { |
| ( |
| seriesModel: GraphSeriesModel, |
| graph: Graph, |
| nodeData: List, |
| r: number, |
| cx: number, |
| cy: number, |
| count: number |
| ): void |
| } |
| |
| const _layoutNodesBasedOn: Record<'value' | 'symbolSize', LayoutNode> = { |
| |
| value(seriesModel, graph, nodeData, r, cx, cy, count) { |
| let angle = 0; |
| const sum = nodeData.getSum('value'); |
| const unitAngle = Math.PI * 2 / (sum || count); |
| |
| graph.eachNode(function (node) { |
| const value = node.getValue('value') as number; |
| const radianHalf = unitAngle * (sum ? value : 1) / 2; |
| |
| angle += radianHalf; |
| node.setLayout([ |
| r * Math.cos(angle) + cx, |
| r * Math.sin(angle) + cy |
| ]); |
| angle += radianHalf; |
| }); |
| }, |
| |
| symbolSize(seriesModel, graph, nodeData, r, cx, cy, count) { |
| let sumRadian = 0; |
| _symbolRadiansHalf.length = count; |
| |
| const nodeScale = getNodeGlobalScale(seriesModel); |
| |
| graph.eachNode(function (node) { |
| let symbolSize = getSymbolSize(node); |
| |
| // Normally this case will not happen, but we still add |
| // some the defensive code (2px is an arbitrary value). |
| isNaN(symbolSize) && (symbolSize = 2); |
| symbolSize < 0 && (symbolSize = 0); |
| |
| symbolSize *= nodeScale; |
| |
| let symbolRadianHalf = Math.asin(symbolSize / 2 / r); |
| // when `symbolSize / 2` is bigger than `r`. |
| isNaN(symbolRadianHalf) && (symbolRadianHalf = PI / 2); |
| _symbolRadiansHalf[node.dataIndex] = symbolRadianHalf; |
| sumRadian += symbolRadianHalf * 2; |
| }); |
| |
| const halfRemainRadian = (2 * PI - sumRadian) / count / 2; |
| |
| let angle = 0; |
| graph.eachNode(function (node) { |
| const radianHalf = halfRemainRadian + _symbolRadiansHalf[node.dataIndex]; |
| |
| angle += radianHalf; |
| node.setLayout([ |
| r * Math.cos(angle) + cx, |
| r * Math.sin(angle) + cy |
| ]); |
| angle += radianHalf; |
| }); |
| } |
| }; |