public static void DrawLineStyle(VertexHelper vh, LineStyle.Type lineType, float lineWidth, Vector3 startPos, Vector3 endPos, Color32 color, Color32 toColor) { switch (lineType) { case LineStyle.Type.Dashed: UGL.DrawDashLine(vh, startPos, endPos, lineWidth, color, toColor); break; case LineStyle.Type.Dotted: UGL.DrawDotLine(vh, startPos, endPos, lineWidth, color, toColor); break; case LineStyle.Type.Solid: UGL.DrawLine(vh, startPos, endPos, lineWidth, color, toColor); break; case LineStyle.Type.DashDot: UGL.DrawDashDotLine(vh, startPos, endPos, lineWidth, color); break; case LineStyle.Type.DashDotDot: UGL.DrawDashDotDotLine(vh, startPos, endPos, lineWidth, color); break; } }
private void DrawLineStyle(VertexHelper vh, Serie serie) { if (serie.gaugeType != GaugeType.Pointer) { return; } if (!serie.gaugeAxis.show || !serie.gaugeAxis.splitLine.show) { return; } if (serie.splitNumber <= 0) { return; } var splitLine = serie.gaugeAxis.splitLine; var totalAngle = serie.endAngle - serie.startAngle; var diffAngle = totalAngle / serie.splitNumber; var lineWidth = serie.gaugeAxis.axisLine.GetWidth(chart.theme.gauge.lineWidth); var splitLineWidth = splitLine.GetWidth(chart.theme.gauge.splitLineWidth); var splitLineLength = splitLine.GetLength(chart.theme.gauge.splitLineLength); var outsideRadius = serie.runtimeInsideRadius + lineWidth; var insideRadius = outsideRadius - splitLineLength; for (int i = 0; i < serie.splitNumber + 1; i++) { var angle = serie.startAngle + i * diffAngle; var lineColor = serie.gaugeAxis.GetSplitLineColor(chart.theme.gauge.splitLineColor, serie.index, angle); var p1 = ChartHelper.GetPosition(serie.runtimeCenterPos, angle, insideRadius); var p2 = ChartHelper.GetPosition(serie.runtimeCenterPos, angle, outsideRadius); UGL.DrawLine(vh, p1, p2, splitLineWidth, lineColor); } }
void Awake() { chart = gameObject.GetComponent <LineChart>(); if (chart == null) { return; } chart.onDraw = delegate(VertexHelper vh) { }; // or chart.onDrawBeforeSerie = delegate(VertexHelper vh, Serie serie) { }; // or chart.onDrawAfterSerie = delegate(VertexHelper vh, Serie serie) { if (serie.index != 0) { return; } var dataPoints = serie.context.dataPoints; if (dataPoints.Count > 0) { var pos = dataPoints[3]; var grid = chart.GetChartComponent <GridCoord>(); var zeroPos = new Vector3(grid.context.x, grid.context.y); var startPos = new Vector3(pos.x, zeroPos.y); var endPos = new Vector3(pos.x, zeroPos.y + grid.context.height); UGL.DrawLine(vh, startPos, endPos, chart.theme.serie.lineWidth, Color.blue); UGL.DrawCricle(vh, pos, 5, Color.blue); } }; // or chart.onDrawTop = delegate(VertexHelper vh) { }; }
private void DrawPolarLine(VertexHelper vh, Serie serie) { var m_Polar = GetPolar(serie.polarIndex); if (m_Polar == null) { return; } var m_AngleAxis = GetAngleAxis(m_Polar.index); var m_RadiusAxis = GetRadiusAxis(m_Polar.index); if (m_AngleAxis == null || m_RadiusAxis == null) { return; } var startAngle = m_AngleAxis.runtimeStartAngle; var radius = m_Polar.runtimeRadius; var datas = serie.data; if (datas.Count <= 0) { return; } float dataChangeDuration = serie.animation.GetUpdateAnimationDuration(); float min = m_RadiusAxis.GetCurrMinValue(dataChangeDuration); float max = m_RadiusAxis.GetCurrMaxValue(dataChangeDuration); var firstSerieData = datas[0]; var startPos = GetPolarPos(m_Polar, m_AngleAxis, firstSerieData, min, max, radius); var nextPos = Vector3.zero; var lineColor = SerieHelper.GetLineColor(serie, m_Theme, serie.index, serie.highlighted); var lineWidth = serie.lineStyle.GetWidth(m_Theme.serie.lineWidth); float currDetailProgress = 0; float totalDetailProgress = datas.Count; serie.animation.InitProgress(serie.dataPoints.Count, currDetailProgress, totalDetailProgress); serie.animation.SetDataFinish(0); for (int i = 1; i < datas.Count; i++) { if (serie.animation.CheckDetailBreak(i)) { break; } var serieData = datas[i]; nextPos = GetPolarPos(m_Polar, m_AngleAxis, datas[i], min, max, radius); UGL.DrawLine(vh, startPos, nextPos, lineWidth, lineColor); startPos = nextPos; } if (!serie.animation.IsFinish()) { serie.animation.CheckProgress(totalDetailProgress); serie.animation.CheckSymbol(serie.symbol.GetSize(null, m_Theme.serie.lineSymbolSize)); m_IsPlayingAnimation = true; RefreshChart(); } }
private void DrawRadiusAxis(VertexHelper vh, RadiusAxis radiusAxis) { var polar = chart.GetChartComponent <PolarCoord>(radiusAxis.polarIndex); if (polar == null) { return; } var angleAxis = ComponentHelper.GetAngleAxis(chart.components, polar.index); if (angleAxis == null) { return; } var startAngle = angleAxis.context.startAngle; var radius = polar.context.radius; var cenPos = polar.context.center; var size = AxisHelper.GetScaleNumber(radiusAxis, radius, null); var totalWidth = 0f; var dire = ChartHelper.GetDire(startAngle, true).normalized; var tickWidth = radiusAxis.axisTick.GetWidth(chart.theme.axis.tickWidth); var tickLength = radiusAxis.axisTick.GetLength(chart.theme.axis.tickLength); var tickVetor = ChartHelper.GetVertialDire(dire) * tickLength; for (int i = 0; i <= size; i++) { var scaleWidth = AxisHelper.GetScaleWidth(radiusAxis, radius, i); var pos = ChartHelper.GetPos(cenPos, totalWidth + tickWidth, startAngle, true); if (radiusAxis.show && radiusAxis.splitLine.show) { var outsideRaidus = totalWidth + radiusAxis.splitLine.GetWidth(chart.theme.axis.splitLineWidth) * 2; var splitLineColor = radiusAxis.splitLine.GetColor(chart.theme.axis.splitLineColor); UGL.DrawDoughnut(vh, cenPos, totalWidth, outsideRaidus, splitLineColor, Color.clear); } if (radiusAxis.show && radiusAxis.axisTick.show) { if ((i == 0 && radiusAxis.axisTick.showStartTick) || (i == size && radiusAxis.axisTick.showEndTick) || (i > 0 && i < size)) { UGL.DrawLine(vh, pos, pos + tickVetor, tickWidth, chart.theme.axis.lineColor); } } totalWidth += scaleWidth; } if (radiusAxis.show && radiusAxis.axisLine.show) { var lineStartPos = polar.context.center - dire * tickWidth; var lineEndPos = polar.context.center + dire * (radius + tickWidth); var lineWidth = radiusAxis.axisLine.GetWidth(chart.theme.axis.lineWidth); UGL.DrawLine(vh, lineStartPos, lineEndPos, lineWidth, chart.theme.axis.lineColor); } }
public void DrawClipLine(VertexHelper vh, Vector3 p1, Vector3 p2, float size, Color32 color, bool clip, GridCoord grid) { if (!IsInChart(p1) || !IsInChart(p2)) { return; } if (!clip || (clip && (grid.Contains(p1) || grid.Contains(p2)))) { UGL.DrawLine(vh, p1, p2, size, color); } }
private void DrawPosList(VertexHelper vh, List <Vector3> posList) { if (mirrorY) { for (int i = posList.Count - 1; i >= 0; i--) { var pos = posList[i]; posList[i] = new Vector3(pos.x, -pos.y); } } UGL.DrawLine(vh, posList, 1f, Color.red, false); posList.Clear(); }
private void DrawRadiusAxis(VertexHelper vh) { foreach (var radiusAxis in m_RadiusAxes) { var polar = GetPolar(radiusAxis.polarIndex); if (polar == null) { continue; } var angleAxis = GetAngleAxis(polar.index); if (angleAxis == null) { continue; } var startAngle = angleAxis.runtimeStartAngle; var radius = polar.runtimeRadius; var cenPos = polar.runtimeCenterPos; var size = AxisHelper.GetScaleNumber(radiusAxis, radius, null); var totalWidth = 0f; var dire = ChartHelper.GetDire(startAngle, true).normalized; var tickWidth = radiusAxis.axisTick.GetLength(m_Theme.radiusAxis.tickWidth); var tickLength = radiusAxis.axisTick.GetLength(m_Theme.radiusAxis.tickLength); var tickVetor = ChartHelper.GetVertialDire(dire) * tickLength; for (int i = 0; i < size - 1; i++) { var scaleWidth = AxisHelper.GetScaleWidth(radiusAxis, radius, i); var pos = ChartHelper.GetPos(cenPos, totalWidth, startAngle, true); if (radiusAxis.show && radiusAxis.splitLine.show) { var outsideRaidus = totalWidth + radiusAxis.splitLine.GetWidth(m_Theme.radiusAxis.splitLineWidth) * 2; var splitLineColor = radiusAxis.splitLine.GetColor(m_Theme.radiusAxis.splitLineColor); UGL.DrawDoughnut(vh, cenPos, totalWidth, outsideRaidus, splitLineColor, Color.clear); } if (radiusAxis.show && radiusAxis.axisTick.show) { UGL.DrawLine(vh, pos, pos + tickVetor, tickWidth, m_Theme.axis.lineColor); } totalWidth += scaleWidth; } if (radiusAxis.show && radiusAxis.axisLine.show) { var lineStartPos = polar.runtimeCenterPos - dire * tickWidth; var lineEndPos = polar.runtimeCenterPos + dire * (radius + tickWidth); var lineWidth = radiusAxis.axisLine.GetWidth(m_Theme.polar.lineWidth); UGL.DrawLine(vh, lineStartPos, lineEndPos, lineWidth, m_Theme.axis.lineColor); } } }
private void DrawAngleAxis(VertexHelper vh, AngleAxis angleAxis) { var polar = chart.GetChartComponent <PolarCoord>(angleAxis.polarIndex); var radius = polar.context.radius; var cenPos = polar.context.center; var total = 360; var size = AxisHelper.GetScaleNumber(angleAxis, total, null); var currAngle = angleAxis.context.startAngle; var tickWidth = angleAxis.axisTick.GetWidth(chart.theme.axis.tickWidth); var tickLength = angleAxis.axisTick.GetLength(chart.theme.axis.tickLength); var tickColor = angleAxis.axisTick.GetColor(chart.theme.axis.lineColor); var lineColor = angleAxis.axisLine.GetColor(chart.theme.axis.lineColor); var splitLineColor = angleAxis.splitLine.GetColor(chart.theme.axis.splitLineColor); for (int i = 1; i < size; i++) { var scaleWidth = AxisHelper.GetScaleWidth(angleAxis, total, i); var pos = ChartHelper.GetPos(cenPos, radius, currAngle, true); if (angleAxis.show && angleAxis.splitLine.show) { var lineWidth = angleAxis.splitLine.GetWidth(chart.theme.axis.splitLineWidth); UGL.DrawLine(vh, cenPos, pos, lineWidth, splitLineColor); } if (angleAxis.show && angleAxis.axisTick.show) { if ((i == 1 && angleAxis.axisTick.showStartTick) || (i == size - 1 && angleAxis.axisTick.showEndTick) || (i > 1 && i < size - 1)) { var tickY = radius + tickLength; var tickPos = ChartHelper.GetPos(cenPos, tickY, currAngle, true); UGL.DrawLine(vh, pos, tickPos, tickWidth, tickColor); } } currAngle += scaleWidth; } if (angleAxis.show && angleAxis.axisLine.show) { var lineWidth = angleAxis.axisLine.GetWidth(chart.theme.axis.lineWidth); var outsideRaidus = radius + lineWidth * 2; UGL.DrawDoughnut(vh, cenPos, radius, outsideRaidus, lineColor, Color.clear); } }
private void DrawCricleRadar(VertexHelper vh, Radar radar) { if (!radar.splitLine.show && !radar.splitArea.show) { return; } float insideRadius = 0, outsideRadius = 0; float block = radar.runtimeRadius / radar.splitNumber; int indicatorNum = radar.indicatorList.Count; Vector3 p = radar.runtimeCenterPos; Vector3 p1; float angle = 2 * Mathf.PI / indicatorNum; var lineColor = radar.axisLine.GetColor(chart.theme.radar.lineColor); var lineWidth = radar.splitLine.GetWidth(chart.theme.radar.splitLineWidth); for (int i = 0; i < radar.splitNumber; i++) { var color = radar.splitArea.GetColor(i, chart.theme.radiusAxis); outsideRadius = insideRadius + block; if (radar.splitArea.show) { UGL.DrawDoughnut(vh, p, insideRadius, outsideRadius, color, Color.clear, 0, 360, chart.settings.cicleSmoothness); } if (radar.splitLine.show) { UGL.DrawEmptyCricle(vh, p, outsideRadius, lineWidth, lineColor, Color.clear, chart.settings.cicleSmoothness); } insideRadius = outsideRadius; } for (int j = 0; j <= indicatorNum; j++) { float currAngle = j * angle; p1 = new Vector3(p.x + outsideRadius * Mathf.Sin(currAngle), p.y + outsideRadius * Mathf.Cos(currAngle)); if (radar.splitLine.show) { UGL.DrawLine(vh, p, p1, lineWidth / 2, lineColor); } } }
void Awake() { chart = gameObject.GetComponent <LineChart>(); if (chart == null) { return; } chart.onCustomDraw = delegate(VertexHelper vh) { var dataPoints = chart.series.list[0].dataPoints; if (dataPoints.Count > 0) { var pos = dataPoints[3]; var zeroPos = new Vector3(chart.grid.runtimeX, chart.grid.runtimeY); var startPos = new Vector3(pos.x, zeroPos.y); var endPos = new Vector3(pos.x, zeroPos.y + chart.grid.runtimeHeight); UGL.DrawLine(vh, startPos, endPos, chart.theme.serie.lineWidth, Color.blue); UGL.DrawCricle(vh, pos, 5, Color.blue); } }; }
private void DrawAngleAxis(VertexHelper vh) { foreach (var m_AngleAxis in m_AngleAxes) { var m_Polar = GetPolar(m_AngleAxis.polarIndex); var radius = m_Polar.runtimeRadius; var cenPos = m_Polar.runtimeCenterPos; var total = 360; var size = AxisHelper.GetScaleNumber(m_AngleAxis, total, null); var currAngle = m_AngleAxis.runtimeStartAngle; var tickWidth = m_AngleAxis.axisTick.GetWidth(m_Theme.angleAxis.tickWidth); var tickLength = m_AngleAxis.axisTick.GetLength(m_Theme.angleAxis.tickLength); for (int i = 0; i < size; i++) { var scaleWidth = AxisHelper.GetScaleWidth(m_AngleAxis, total, i); var pos = ChartHelper.GetPos(cenPos, radius, currAngle, true); if (m_AngleAxis.show && m_AngleAxis.splitLine.show) { var splitLineColor = m_AngleAxis.splitLine.GetColor(m_Theme.angleAxis.splitLineColor); var lineWidth = m_AngleAxis.splitLine.GetWidth(m_Theme.angleAxis.splitLineWidth); UGL.DrawLine(vh, cenPos, pos, lineWidth, splitLineColor); } if (m_AngleAxis.show && m_AngleAxis.axisTick.show) { var tickY = radius + tickLength; var tickPos = ChartHelper.GetPos(cenPos, tickY, currAngle, true); UGL.DrawLine(vh, pos, tickPos, tickWidth, m_Theme.axis.lineColor); } currAngle += scaleWidth; } if (m_AngleAxis.show && m_AngleAxis.axisLine.show) { var lineWidth = m_AngleAxis.axisLine.GetWidth(m_Theme.angleAxis.lineWidth); var outsideRaidus = radius + lineWidth * 2; UGL.DrawDoughnut(vh, cenPos, radius, outsideRaidus, m_Theme.axis.lineColor, Color.clear); } } }
protected override void OnPopulateMesh(VertexHelper vh) { Vector3 sp, cp, ep; vh.Clear(); //背景边框 UGL.DrawSquare(vh, m_Center, m_Width / 2, m_BackgroundColor); UGL.DrawBorder(vh, m_Center, m_Width, m_Height, 10, Color.green, 0, m_BorderRadius); //点 UGL.DrawCricle(vh, m_LeftTopPos + new Vector3(20, -20), 10, m_DrawColor); //直线 sp = new Vector3(m_LeftTopPos.x + 50, m_LeftTopPos.y - 20); ep = new Vector3(m_LeftTopPos.x + 250, m_LeftTopPos.y - 20); UGL.DrawLine(vh, sp, ep, 3, m_DrawColor); //3点确定的折线 sp = new Vector3(m_LeftTopPos.x + 20, m_LeftTopPos.y - 100); cp = new Vector3(m_LeftTopPos.x + 200, m_LeftTopPos.y - 40); ep = new Vector3(m_LeftTopPos.x + 250, m_LeftTopPos.y - 80); UGL.DrawLine(vh, sp, cp, ep, 5, m_DrawColor); }
private void DrawAxisTick(VertexHelper vh, Serie serie) { if (serie.gaugeType != GaugeType.Pointer) { return; } if (!serie.gaugeAxis.show || !serie.gaugeAxis.axisTick.show) { return; } if (serie.splitNumber <= 0) { return; } var axisTick = serie.gaugeAxis.axisTick; var totalAngle = serie.endAngle - serie.startAngle; var diffAngle = totalAngle / serie.splitNumber; var lineWidth = serie.gaugeAxis.axisLine.GetWidth(chart.theme.gauge.lineWidth); var tickWidth = axisTick.GetWidth(chart.theme.gauge.tickWidth); var tickLength = axisTick.GetLength(chart.theme.gauge.tickLength); var outsideRadius = serie.runtimeInsideRadius + lineWidth; var insideRadius = outsideRadius - (tickLength < 1 ? lineWidth * tickLength : tickLength); for (int i = 0; i < serie.splitNumber; i++) { for (int j = 1; j < axisTick.splitNumber; j++) { var angle = serie.startAngle + i * diffAngle + j * (diffAngle / axisTick.splitNumber); var lineColor = serie.gaugeAxis.GetSplitLineColor(chart.theme.gauge.tickColor, serie.index, angle); var p1 = ChartHelper.GetPosition(serie.runtimeCenterPos, angle, insideRadius); var p2 = ChartHelper.GetPosition(serie.runtimeCenterPos, angle, outsideRadius); UGL.DrawLine(vh, p1, p2, tickWidth, lineColor); } } }
private void DrawPieLabelLine(VertexHelper vh, Serie serie, SerieData serieData, Color color) { var serieLabel = SerieHelper.GetSerieLabel(serie, serieData); var labelLine = SerieHelper.GetSerieLabelLine(serie, serieData); if (serieLabel != null && serieLabel.show && labelLine != null && labelLine.show && (serieLabel.IsDefaultPosition(LabelStyle.Position.Outside))) { var insideRadius = serieData.context.insideRadius; var outSideRadius = serieData.context.outsideRadius; var center = serie.context.center; var currAngle = serieData.context.halfAngle; if (!ChartHelper.IsClearColor(labelLine.lineColor)) { color = labelLine.lineColor; } else if (labelLine.lineType == LabelLine.LineType.HorizontalLine) { color *= color; } float currSin = Mathf.Sin(currAngle * Mathf.Deg2Rad); float currCos = Mathf.Cos(currAngle * Mathf.Deg2Rad); var radius1 = labelLine.lineType == LabelLine.LineType.HorizontalLine ? serie.context.outsideRadius : outSideRadius; var radius3 = insideRadius + (outSideRadius - insideRadius) / 2; if (radius1 < serie.context.insideRadius) { radius1 = serie.context.insideRadius; } radius1 -= 0.1f; var pos0 = new Vector3(center.x + radius3 * currSin, center.y + radius3 * currCos); var pos1 = new Vector3(center.x + radius1 * currSin, center.y + radius1 * currCos); var pos2 = serieData.context.labelPosition; Vector3 pos4, pos6; var horizontalLineCircleRadius = labelLine.lineWidth * 4f; var lineCircleDiff = horizontalLineCircleRadius - 0.3f; var startAngle = serie.context.startAngle; if (currAngle < 90) { var r4 = Mathf.Sqrt(radius1 * radius1 - Mathf.Pow(currCos * radius3, 2)) - currSin * radius3; r4 += labelLine.lineLength1 - lineCircleDiff; pos6 = pos0 + Vector3.right * lineCircleDiff; pos4 = pos6 + Vector3.right * r4; } else if (currAngle < 180) { var r4 = Mathf.Sqrt(radius1 * radius1 - Mathf.Pow(currCos * radius3, 2)) - currSin * radius3; r4 += labelLine.lineLength1 - lineCircleDiff; pos6 = pos0 + Vector3.right * lineCircleDiff; pos4 = pos6 + Vector3.right * r4; } else if (currAngle < 270) { var currSin1 = Mathf.Sin((360 - currAngle) * Mathf.Deg2Rad); var currCos1 = Mathf.Cos((360 - currAngle) * Mathf.Deg2Rad); var r4 = Mathf.Sqrt(radius1 * radius1 - Mathf.Pow(currCos1 * radius3, 2)) - currSin1 * radius3; r4 += labelLine.lineLength1 - lineCircleDiff; pos6 = pos0 + Vector3.left * lineCircleDiff; pos4 = pos6 + Vector3.left * r4; } else { var currSin1 = Mathf.Sin((360 - currAngle) * Mathf.Deg2Rad); var currCos1 = Mathf.Cos((360 - currAngle) * Mathf.Deg2Rad); var r4 = Mathf.Sqrt(radius1 * radius1 - Mathf.Pow(currCos1 * radius3, 2)) - currSin1 * radius3; r4 += labelLine.lineLength1 - lineCircleDiff; pos6 = pos0 + Vector3.left * lineCircleDiff; pos4 = pos6 + Vector3.left * r4; } var pos5X = (currAngle - startAngle) % 360 > 180 ? pos2.x - labelLine.lineLength2 : pos2.x + labelLine.lineLength2; var pos5 = new Vector3(pos5X, pos2.y); var angle = Vector3.Angle(pos1 - center, pos2 - pos1); if (angle > 15) { UGL.DrawLine(vh, pos1, pos5, labelLine.lineWidth, color); } else { switch (labelLine.lineType) { case LabelLine.LineType.BrokenLine: UGL.DrawLine(vh, pos1, pos2, pos5, labelLine.lineWidth, color); break; case LabelLine.LineType.Curves: UGL.DrawCurves(vh, pos1, pos5, pos1, pos2, labelLine.lineWidth, color, chart.settings.lineSmoothness); break; case LabelLine.LineType.HorizontalLine: UGL.DrawCricle(vh, pos0, horizontalLineCircleRadius, color); UGL.DrawLine(vh, pos6, pos4, labelLine.lineWidth, color); break; } } } }
private void DrawCandlestickSerie(VertexHelper vh, SimplifiedCandlestick serie) { if (!serie.show) { return; } if (serie.animation.HasFadeOut()) { return; } XAxis xAxis; YAxis yAxis; GridCoord grid; if (!chart.TryGetChartComponent <XAxis>(out xAxis, serie.xAxisIndex)) { return; } if (!chart.TryGetChartComponent <YAxis>(out yAxis, serie.yAxisIndex)) { return; } if (!chart.TryGetChartComponent <GridCoord>(out grid, xAxis.gridIndex)) { return; } var theme = chart.theme; var dataZoom = chart.GetDataZoomOfAxis(xAxis); var showData = serie.GetDataList(dataZoom); float categoryWidth = AxisHelper.GetDataWidth(xAxis, grid.context.width, showData.Count, dataZoom); float barWidth = serie.GetBarWidth(categoryWidth); float gap = (categoryWidth - barWidth) / 2; int maxCount = serie.maxShow > 0 ? (serie.maxShow > showData.Count ? showData.Count : serie.maxShow) : showData.Count; bool dataChanging = false; float dataChangeDuration = serie.animation.GetUpdateAnimationDuration(); double yMinValue = yAxis.context.minValue; double yMaxValue = yAxis.context.maxValue; var isYAxis = false; var itemStyle = serie.itemStyle; serie.containerIndex = grid.index; serie.containterInstanceId = grid.instanceId; for (int i = serie.minShow; i < maxCount; i++) { var serieData = showData[i]; if (serie.IsIgnoreValue(serieData)) { serie.context.dataPoints.Add(Vector3.zero); continue; } var open = serieData.GetCurrData(0, dataChangeDuration, yAxis.inverse, yMinValue, yMaxValue); var close = serieData.GetCurrData(1, dataChangeDuration, yAxis.inverse, yMinValue, yMaxValue); var lowest = serieData.GetCurrData(2, dataChangeDuration, yAxis.inverse, yMinValue, yMaxValue); var heighest = serieData.GetCurrData(3, dataChangeDuration, yAxis.inverse, yMinValue, yMaxValue); var isRise = yAxis.inverse ? close <open : close> open; var borderWidth = open == 0 ? 0f : (itemStyle.runtimeBorderWidth == 0 ? theme.serie.candlestickBorderWidth : itemStyle.runtimeBorderWidth); if (serieData.IsDataChanged()) { dataChanging = true; } float pX = grid.context.x + i * categoryWidth; float zeroY = grid.context.y + yAxis.context.offset; if (!xAxis.boundaryGap) { pX -= categoryWidth / 2; } float pY = zeroY; var barHig = 0f; double valueTotal = yMaxValue - yMinValue; var minCut = (yMinValue > 0 ? yMinValue : 0); if (valueTotal != 0) { barHig = (float)((close - open) / valueTotal * grid.context.height); pY += (float)((open - minCut) / valueTotal * grid.context.height); } serieData.context.stackHeight = barHig; float currHig = AnimationStyleHelper.CheckDataAnimation(chart, serie, i, barHig); Vector3 plb, plt, prt, prb, top; plb = new Vector3(pX + gap + borderWidth, pY + borderWidth); plt = new Vector3(pX + gap + borderWidth, pY + currHig - borderWidth); prt = new Vector3(pX + gap + barWidth - borderWidth, pY + currHig - borderWidth); prb = new Vector3(pX + gap + barWidth - borderWidth, pY + borderWidth); top = new Vector3(pX + gap + barWidth / 2, pY + currHig - borderWidth); // if (serie.clip) // { // plb = chart.ClampInGrid(grid, plb); // plt = chart.ClampInGrid(grid, plt); // prt = chart.ClampInGrid(grid, prt); // prb = chart.ClampInGrid(grid, prb); // top = chart.ClampInGrid(grid, top); // } serie.context.dataPoints.Add(top); var areaColor = isRise ? itemStyle.GetColor(theme.serie.candlestickColor) : itemStyle.GetColor0(theme.serie.candlestickColor0); var borderColor = isRise ? itemStyle.GetBorderColor(theme.serie.candlestickBorderColor) : itemStyle.GetBorderColor0(theme.serie.candlestickBorderColor0); var itemWidth = Mathf.Abs(prt.x - plb.x); var itemHeight = Mathf.Abs(plt.y - prb.y); var center = new Vector3((plb.x + prt.x) / 2, (plt.y + prb.y) / 2); var lowPos = new Vector3(center.x, zeroY + (float)((lowest - minCut) / valueTotal * grid.context.height)); var heighPos = new Vector3(center.x, zeroY + (float)((heighest - minCut) / valueTotal * grid.context.height)); var openCenterPos = new Vector3(center.x, prb.y); var closeCenterPos = new Vector3(center.x, prt.y); if (barWidth > 2f * borderWidth) { if (itemWidth > 0 && itemHeight > 0) { if (itemStyle.IsNeedCorner()) { UGL.DrawRoundRectangle(vh, center, itemWidth, itemHeight, areaColor, areaColor, 0, itemStyle.cornerRadius, isYAxis, 0.5f); } else { chart.DrawClipPolygon(vh, ref prb, ref plb, ref plt, ref prt, areaColor, areaColor, serie.clip, grid); } UGL.DrawBorder(vh, center, itemWidth, itemHeight, 2 * borderWidth, borderColor, 0, itemStyle.cornerRadius, isYAxis, 0.5f); } if (isRise) { UGL.DrawLine(vh, openCenterPos, lowPos, borderWidth, borderColor); UGL.DrawLine(vh, closeCenterPos, heighPos, borderWidth, borderColor); } else { UGL.DrawLine(vh, closeCenterPos, lowPos, borderWidth, borderColor); UGL.DrawLine(vh, openCenterPos, heighPos, borderWidth, borderColor); } } else { UGL.DrawLine(vh, openCenterPos, closeCenterPos, Mathf.Max(borderWidth, barWidth / 2), borderColor); } } if (!serie.animation.IsFinish()) { serie.animation.CheckProgress(); } if (dataChanging) { chart.RefreshPainter(serie); } }
private void DrawLegend(VertexHelper vh) { if (chart.series.Count == 0) { return; } var legend = component; if (!legend.show) { return; } if (legend.iconType == Legend.Type.Custom) { return; } foreach (var kv in legend.context.buttonList) { var item = kv.Value; var rect = item.GetIconRect(); var radius = Mathf.Min(rect.width, rect.height) / 2; var color = item.GetIconColor(); var iconType = legend.iconType; if (legend.iconType == Legend.Type.Auto) { var serie = chart.GetSerie(item.legendName); if (serie != null && serie is Line) { var sp = new Vector3(rect.center.x - rect.width / 2, rect.center.y); var ep = new Vector3(rect.center.x + rect.width / 2, rect.center.y); UGL.DrawLine(vh, sp, ep, chart.settings.legendIconLineWidth, color); if (!serie.symbol.show) { continue; } switch (serie.symbol.type) { case SymbolType.None: continue; case SymbolType.Circle: iconType = Legend.Type.Circle; break; case SymbolType.Diamond: iconType = Legend.Type.Diamond; break; case SymbolType.EmptyCircle: iconType = Legend.Type.EmptyCircle; break; case SymbolType.Rect: iconType = Legend.Type.Rect; break; case SymbolType.Triangle: iconType = Legend.Type.Triangle; break; } } else { iconType = Legend.Type.Rect; } } switch (iconType) { case Legend.Type.Rect: var cornerRadius = chart.settings.legendIconCornerRadius; UGL.DrawRoundRectangle(vh, rect.center, rect.width, rect.height, color, color, 0, cornerRadius, false, 0.5f); break; case Legend.Type.Circle: UGL.DrawCricle(vh, rect.center, radius, color); break; case Legend.Type.Diamond: UGL.DrawDiamond(vh, rect.center, radius, color); break; case Legend.Type.EmptyCircle: var backgroundColor = chart.GetChartBackgroundColor(); UGL.DrawEmptyCricle(vh, rect.center, radius, 2 * chart.settings.legendIconLineWidth, color, color, backgroundColor, 1f); break; case Legend.Type.Triangle: UGL.DrawTriangle(vh, rect.center, 1.2f * radius, color); break; } } }
private void DrawBarBackground(VertexHelper vh, Serie serie, SerieData serieData, ItemStyle itemStyle, int colorIndex, bool highlight, float pX, float pY, float space, float barWidth, bool isYAxis, Grid grid) { var color = SerieHelper.GetItemBackgroundColor(serie, serieData, m_Theme, colorIndex, highlight, false); if (ChartHelper.IsClearColor(color)) { return; } if (isYAxis) { var axis = m_YAxes[serie.yAxisIndex]; var axisWidth = axis.axisLine.GetWidth(m_Theme.axis.lineWidth); Vector3 plt = new Vector3(grid.runtimeX + axisWidth, pY + space + barWidth); Vector3 prt = new Vector3(grid.runtimeX + axisWidth + grid.runtimeWidth, pY + space + barWidth); Vector3 prb = new Vector3(grid.runtimeX + axisWidth + grid.runtimeWidth, pY + space); Vector3 plb = new Vector3(grid.runtimeX + axisWidth, pY + space); if (serie.barType == BarType.Capsule) { var radius = barWidth / 2; var diff = Vector3.right * radius; var pcl = (plt + plb) / 2 + diff; var pcr = (prt + prb) / 2 - diff; Internal_CheckClipAndDrawPolygon(vh, plb + diff, plt + diff, prt - diff, prb - diff, color, color, serie.clip, grid); UGL.DrawSector(vh, pcl, radius, color, 180, 360); UGL.DrawSector(vh, pcr, radius, color, 0, 180); if (itemStyle.NeedShowBorder()) { var borderWidth = itemStyle.borderWidth; var borderColor = itemStyle.borderColor; var smoothness = settings.cicleSmoothness; var inRadius = radius - borderWidth; var outRadius = radius; var p1 = plb + diff + Vector3.up * borderWidth / 2; var p2 = prb - diff + Vector3.up * borderWidth / 2; var p3 = plt + diff - Vector3.up * borderWidth / 2; var p4 = prt - diff - Vector3.up * borderWidth / 2; UGL.DrawLine(vh, p1, p2, borderWidth / 2, borderColor); UGL.DrawLine(vh, p3, p4, borderWidth / 2, borderColor); UGL.DrawDoughnut(vh, pcl, inRadius, outRadius, borderColor, ChartConst.clearColor32, 180, 360, smoothness); UGL.DrawDoughnut(vh, pcr, inRadius, outRadius, borderColor, ChartConst.clearColor32, 0, 180, smoothness); } } else { Internal_CheckClipAndDrawPolygon(vh, ref plb, ref plt, ref prt, ref prb, color, color, serie.clip, grid); } } else { var axis = m_XAxes[serie.xAxisIndex]; var axisWidth = axis.axisLine.GetWidth(m_Theme.axis.lineWidth); Vector3 plb = new Vector3(pX + space, grid.runtimeY + axisWidth); Vector3 plt = new Vector3(pX + space, grid.runtimeY + grid.runtimeHeight + axisWidth); Vector3 prt = new Vector3(pX + space + barWidth, grid.runtimeY + grid.runtimeHeight + axisWidth); Vector3 prb = new Vector3(pX + space + barWidth, grid.runtimeY + axisWidth); if (serie.barType == BarType.Capsule) { var radius = barWidth / 2; var diff = Vector3.up * radius; var pct = (plt + prt) / 2 - diff; var pcb = (plb + prb) / 2 + diff; Internal_CheckClipAndDrawPolygon(vh, prb + diff, plb + diff, plt - diff, prt - diff, color, color, serie.clip, grid); UGL.DrawSector(vh, pct, radius, color, 270, 450); UGL.DrawSector(vh, pcb, radius, color, 90, 270); if (itemStyle.NeedShowBorder()) { var borderWidth = itemStyle.borderWidth; var borderColor = itemStyle.borderColor; var smoothness = settings.cicleSmoothness; var inRadius = radius - borderWidth; var outRadius = radius; var p1 = plb + diff + Vector3.right * borderWidth / 2; var p2 = plt - diff + Vector3.right * borderWidth / 2; var p3 = prb + diff - Vector3.right * borderWidth / 2; var p4 = prt - diff - Vector3.right * borderWidth / 2; UGL.DrawLine(vh, p1, p2, borderWidth / 2, borderColor); UGL.DrawLine(vh, p3, p4, borderWidth / 2, borderColor); UGL.DrawDoughnut(vh, pct, inRadius, outRadius, borderColor, ChartConst.clearColor32, 270, 450, smoothness); UGL.DrawDoughnut(vh, pcb, inRadius, outRadius, borderColor, ChartConst.clearColor32, 90, 270, smoothness); } } else { Internal_CheckClipAndDrawPolygon(vh, ref prb, ref plb, ref plt, ref prt, color, color, serie.clip, grid); } } }
private void DrawPieLabelLine(VertexHelper vh, Serie serie, SerieData serieData, Color color) { var serieLabel = SerieHelper.GetSerieLabel(serie, serieData); if (serieLabel.show && serieLabel.position == SerieLabel.Position.Outside && serieLabel.line) { var insideRadius = serieData.runtimePieInsideRadius; var outSideRadius = serieData.runtimePieOutsideRadius; var center = serie.runtimeCenterPos; var currAngle = serieData.runtimePieHalfAngle; if (!ChartHelper.IsClearColor(serieLabel.lineColor)) { color = serieLabel.lineColor; } else if (serieLabel.lineType == SerieLabel.LineType.HorizontalLine) { color *= color; } float currSin = Mathf.Sin(currAngle * Mathf.Deg2Rad); float currCos = Mathf.Cos(currAngle * Mathf.Deg2Rad); var radius1 = serieLabel.lineType == SerieLabel.LineType.HorizontalLine ? serie.runtimeOutsideRadius : outSideRadius; var radius2 = serie.runtimeOutsideRadius + serieLabel.lineLength1; var radius3 = insideRadius + (outSideRadius - insideRadius) / 2; if (radius1 < serie.runtimeInsideRadius) { radius1 = serie.runtimeInsideRadius; } radius1 -= 0.1f; var pos0 = new Vector3(center.x + radius3 * currSin, center.y + radius3 * currCos); var pos1 = new Vector3(center.x + radius1 * currSin, center.y + radius1 * currCos); var pos2 = serieData.labelPosition; if (pos2.x == 0) { pos2 = new Vector3(center.x + radius2 * currSin, center.y + radius2 * currCos); } Vector3 pos4, pos6; var horizontalLineCircleRadius = serieLabel.lineWidth * 4f; var lineCircleDiff = horizontalLineCircleRadius - 0.3f; if (currAngle < 90) { var r4 = Mathf.Sqrt(radius1 * radius1 - Mathf.Pow(currCos * radius3, 2)) - currSin * radius3; r4 += serieLabel.lineLength1 - lineCircleDiff; pos6 = pos0 + Vector3.right * lineCircleDiff; pos4 = pos6 + Vector3.right * r4; } else if (currAngle < 180) { var r4 = Mathf.Sqrt(radius1 * radius1 - Mathf.Pow(currCos * radius3, 2)) - currSin * radius3; r4 += serieLabel.lineLength1 - lineCircleDiff; pos6 = pos0 + Vector3.right * lineCircleDiff; pos4 = pos6 + Vector3.right * r4; } else if (currAngle < 270) { var currSin1 = Mathf.Sin((360 - currAngle) * Mathf.Deg2Rad); var currCos1 = Mathf.Cos((360 - currAngle) * Mathf.Deg2Rad); var r4 = Mathf.Sqrt(radius1 * radius1 - Mathf.Pow(currCos1 * radius3, 2)) - currSin1 * radius3; r4 += serieLabel.lineLength1 - lineCircleDiff; pos6 = pos0 + Vector3.left * lineCircleDiff; pos4 = pos6 + Vector3.left * r4; } else { var currSin1 = Mathf.Sin((360 - currAngle) * Mathf.Deg2Rad); var currCos1 = Mathf.Cos((360 - currAngle) * Mathf.Deg2Rad); var r4 = Mathf.Sqrt(radius1 * radius1 - Mathf.Pow(currCos1 * radius3, 2)) - currSin1 * radius3; r4 += serieLabel.lineLength1 - lineCircleDiff; pos6 = pos0 + Vector3.left * lineCircleDiff; pos4 = pos6 + Vector3.left * r4; } var pos5X = currAngle > 180 ? pos2.x - serieLabel.lineLength2 : pos2.x + serieLabel.lineLength2; var pos5 = new Vector3(pos5X, pos2.y); switch (serieLabel.lineType) { case SerieLabel.LineType.BrokenLine: UGL.DrawLine(vh, pos1, pos2, pos5, serieLabel.lineWidth, color); break; case SerieLabel.LineType.Curves: UGL.DrawCurves(vh, pos1, pos5, pos1, pos2, serieLabel.lineWidth, color, chart.settings.lineSmoothness); break; case SerieLabel.LineType.HorizontalLine: UGL.DrawCricle(vh, pos0, horizontalLineCircleRadius, color); UGL.DrawLine(vh, pos6, pos4, serieLabel.lineWidth, color); break; } } }
internal static void DrawAxisTick(VertexHelper vh, Axis axis, AxisTheme theme, DataZoom dataZoom, Orient orient, float startX, float startY, float axisLength) { var lineWidth = axis.axisLine.GetWidth(theme.lineWidth); var tickLength = axis.axisTick.GetLength(theme.tickLength); if (AxisHelper.NeedShowSplit(axis)) { var size = AxisHelper.GetScaleNumber(axis, axisLength, dataZoom); var current = orient == Orient.Horizonal ? startX : startY; for (int i = 0; i < size; i++) { var scaleWidth = AxisHelper.GetScaleWidth(axis, axisLength, i + 1, dataZoom); if (i == 0 && (!axis.axisTick.showStartTick || axis.axisTick.alignWithLabel)) { current += scaleWidth; continue; } if (i == size - 1 && !axis.axisTick.showEndTick) { current += scaleWidth; continue; } if (axis.axisTick.show) { if (orient == Orient.Horizonal) { float pX = axis.IsTime() ? (startX + axis.GetDistance(axis.GetLabelValue(i), axisLength)) : current; if (axis.boundaryGap && axis.axisTick.alignWithLabel) { pX -= scaleWidth / 2; } var sY = 0f; var eY = 0f; if ((axis.axisTick.inside && axis.IsBottom()) || (!axis.axisTick.inside && axis.IsTop())) { sY = startY + lineWidth; eY = sY + tickLength; } else { sY = startY - lineWidth; eY = sY - tickLength; } UGL.DrawLine(vh, new Vector3(pX, sY), new Vector3(pX, eY), axis.axisTick.GetWidth(theme.tickWidth), axis.axisTick.GetColor(theme.tickColor)); } else { float pY = axis.IsTime() ? (startY + axis.GetDistance(axis.GetLabelValue(i), axisLength)) : current; if (axis.boundaryGap && axis.axisTick.alignWithLabel) { pY -= scaleWidth / 2; } var sX = 0f; var eX = 0f; if ((axis.axisTick.inside && axis.IsLeft()) || (!axis.axisTick.inside && axis.IsRight())) { sX = startX + lineWidth; eX = sX + tickLength; } else { sX = startX - lineWidth; eX = sX - tickLength; } UGL.DrawLine(vh, new Vector3(sX, pY), new Vector3(eX, pY), axis.axisTick.GetWidth(theme.tickWidth), axis.axisTick.GetColor(theme.tickColor)); } } current += scaleWidth; } } if (axis.show && axis.axisLine.show && axis.axisLine.showArrow) { var lineY = startY + axis.offset; var inverse = axis.IsValue() && axis.inverse; var axisArrow = axis.axisLine.arrow; if (orient == Orient.Horizonal) { if (inverse) { var startPos = new Vector3(startX + axisLength, lineY); var arrowPos = new Vector3(startX, lineY); UGL.DrawArrow(vh, startPos, arrowPos, axisArrow.width, axisArrow.height, axisArrow.offset, axisArrow.dent, axisArrow.GetColor(axis.axisLine.GetColor(theme.lineColor))); } else { var arrowPosX = startX + axisLength + lineWidth; var startPos = new Vector3(startX, lineY); var arrowPos = new Vector3(arrowPosX, lineY); UGL.DrawArrow(vh, startPos, arrowPos, axisArrow.width, axisArrow.height, axisArrow.offset, axisArrow.dent, axisArrow.GetColor(axis.axisLine.GetColor(theme.lineColor))); } } else { if (inverse) { var startPos = new Vector3(startX, startY + axisLength); var arrowPos = new Vector3(startX, startY); UGL.DrawArrow(vh, startPos, arrowPos, axisArrow.width, axisArrow.height, axisArrow.offset, axisArrow.dent, axisArrow.GetColor(axis.axisLine.GetColor(theme.lineColor))); } else { var startPos = new Vector3(startX, startY); var arrowPos = new Vector3(startX, startY + axisLength + lineWidth); UGL.DrawArrow(vh, startPos, arrowPos, axisArrow.width, axisArrow.height, axisArrow.offset, axisArrow.dent, axisArrow.GetColor(axis.axisLine.GetColor(theme.lineColor))); } } } }
private void DrawParallelSerie(VertexHelper vh, Parallel serie) { if (!serie.show) { return; } if (serie.animation.HasFadeOut()) { return; } var parallel = chart.GetChartComponent <ParallelCoord>(serie.parallelIndex); if (parallel == null) { return; } var axisCount = parallel.context.parallelAxes.Count; if (axisCount <= 0) { return; } var animationIndex = serie.animation.GetCurrIndex(); var isHorizonal = parallel.orient == Orient.Horizonal; var lineColor = SerieHelper.GetLineColor(serie, null, chart.theme, serie.context.colorIndex, false); var lineWidth = serie.lineStyle.GetWidth(chart.theme.serie.lineWidth); float currDetailProgress = !isHorizonal ? parallel.context.x : parallel.context.y; float totalDetailProgress = !isHorizonal ? parallel.context.x + parallel.context.width : parallel.context.y + parallel.context.height; serie.animation.InitProgress(currDetailProgress, totalDetailProgress); serie.context.dataPoints.Clear(); serie.containerIndex = parallel.index; serie.containterInstanceId = parallel.instanceId; var currProgress = serie.animation.GetCurrDetail(); var isSmooth = serie.lineType == LineType.Smooth; foreach (var serieData in serie.data) { m_Points.Clear(); var count = Mathf.Min(axisCount, serieData.data.Count); var lp = Vector3.zero; for (int i = 0; i < count; i++) { if (animationIndex >= 0 && i > animationIndex) { continue; } var pos = GetPos(parallel, i, serieData.data[i], isHorizonal); if (!isHorizonal) { if (isSmooth) { m_Points.Add(pos); } else if (pos.x <= currProgress) { m_Points.Add(pos); } else { var currProgressStart = new Vector3(currProgress, parallel.context.y - 50); var currProgressEnd = new Vector3(currProgress, parallel.context.y + parallel.context.height + 50); var intersectionPos = Vector3.zero; if (UGLHelper.GetIntersection(lp, pos, currProgressStart, currProgressEnd, ref intersectionPos)) { m_Points.Add(intersectionPos); } else { m_Points.Add(pos); } break; } } else { if (isSmooth) { m_Points.Add(pos); } else if (pos.y <= currProgress) { m_Points.Add(pos); } else { var currProgressStart = new Vector3(parallel.context.x - 50, currProgress); var currProgressEnd = new Vector3(parallel.context.x + parallel.context.width + 50, currProgress); var intersectionPos = Vector3.zero; if (UGLHelper.GetIntersection(lp, pos, currProgressStart, currProgressEnd, ref intersectionPos)) { m_Points.Add(intersectionPos); } else { m_Points.Add(pos); } break; } } lp = pos; } if (isSmooth) { UGL.DrawCurves(vh, m_Points, lineWidth, lineColor, chart.settings.lineSmoothness, currProgress, isHorizonal); } else { UGL.DrawLine(vh, m_Points, lineWidth, lineColor, isSmooth); } } if (!serie.animation.IsFinish()) { serie.animation.CheckProgress(totalDetailProgress - currDetailProgress); chart.RefreshPainter(serie); } }
private void DrawVerticalDataZoomSlider(VertexHelper vh, DataZoom dataZoom) { if (!dataZoom.enable || !dataZoom.supportSlider) { return; } var p1 = new Vector3(dataZoom.context.x, dataZoom.context.y); var p2 = new Vector3(dataZoom.context.x, dataZoom.context.y + dataZoom.context.height); var p3 = new Vector3(dataZoom.context.x + dataZoom.context.width, dataZoom.context.y + dataZoom.context.height); var p4 = new Vector3(dataZoom.context.x + dataZoom.context.width, dataZoom.context.y); var lineColor = dataZoom.lineStyle.GetColor(chart.theme.dataZoom.dataLineColor); var lineWidth = dataZoom.lineStyle.GetWidth(chart.theme.dataZoom.dataLineWidth); var borderWidth = dataZoom.borderWidth == 0 ? chart.theme.dataZoom.borderWidth : dataZoom.borderWidth; var borderColor = dataZoom.GetBorderColor(chart.theme.dataZoom.borderColor); var backgroundColor = dataZoom.GetBackgroundColor(chart.theme.dataZoom.backgroundColor); var areaColor = dataZoom.areaStyle.GetColor(chart.theme.dataZoom.dataAreaColor); UGL.DrawQuadrilateral(vh, p1, p2, p3, p4, backgroundColor); var centerPos = new Vector3(dataZoom.context.x + dataZoom.context.width / 2, dataZoom.context.y + dataZoom.context.height / 2); UGL.DrawBorder(vh, centerPos, dataZoom.context.width, dataZoom.context.height, borderWidth, borderColor); if (dataZoom.showDataShadow && chart.series.Count > 0) { Serie serie = chart.series[0]; Axis axis = chart.GetChartComponent <YAxis>(0); var showData = serie.GetDataList(null); float scaleWid = dataZoom.context.height / (showData.Count - 1); Vector3 lp = Vector3.zero; Vector3 np = Vector3.zero; double minValue = 0; double maxValue = 0; SeriesHelper.GetYMinMaxValue(chart.series, null, 0, chart.IsAllAxisValue(), axis.inverse, out minValue, out maxValue); AxisHelper.AdjustMinMaxValue(axis, ref minValue, ref maxValue, true); int rate = 1; var sampleDist = serie.sampleDist < 2 ? 2 : serie.sampleDist; var maxCount = showData.Count; if (sampleDist > 0) { rate = (int)((maxCount - serie.minShow) / (dataZoom.context.height / sampleDist)); } if (rate < 1) { rate = 1; } var totalAverage = serie.sampleAverage > 0 ? serie.sampleAverage : DataHelper.DataAverage(ref showData, serie.sampleType, serie.minShow, maxCount, rate); var dataChanging = false; for (int i = 0; i < maxCount; i += rate) { double value = DataHelper.SampleValue(ref showData, serie.sampleType, rate, serie.minShow, maxCount, totalAverage, i, serie.animation.GetUpdateAnimationDuration(), ref dataChanging, axis); float pY = dataZoom.context.y + i * scaleWid; float dataHig = (maxValue - minValue) == 0 ? 0 : (float)((value - minValue) / (maxValue - minValue) * dataZoom.context.width); np = new Vector3(chart.chartX + chart.chartWidth - dataZoom.right - dataHig, pY); if (i > 0) { UGL.DrawLine(vh, lp, np, lineWidth, lineColor); Vector3 alp = new Vector3(lp.x, lp.y - lineWidth); Vector3 anp = new Vector3(np.x, np.y - lineWidth); Vector3 tnp = new Vector3(np.x, chart.chartY + dataZoom.bottom + lineWidth); Vector3 tlp = new Vector3(lp.x, chart.chartY + dataZoom.bottom + lineWidth); UGL.DrawQuadrilateral(vh, alp, anp, tnp, tlp, areaColor); } lp = np; } if (dataChanging) { chart.RefreshTopPainter(); } } switch (dataZoom.rangeMode) { case DataZoom.RangeMode.Percent: var start = dataZoom.context.y + dataZoom.context.height * dataZoom.start / 100; var end = dataZoom.context.y + dataZoom.context.height * dataZoom.end / 100; var fillerColor = dataZoom.GetFillerColor(chart.theme.dataZoom.fillerColor); p1 = new Vector2(dataZoom.context.x, start); p2 = new Vector2(dataZoom.context.x + dataZoom.context.width, start); p3 = new Vector2(dataZoom.context.x + dataZoom.context.width, end); p4 = new Vector2(dataZoom.context.x, end); UGL.DrawQuadrilateral(vh, p1, p2, p3, p4, fillerColor); UGL.DrawLine(vh, p1, p2, lineWidth, fillerColor); UGL.DrawLine(vh, p3, p4, lineWidth, fillerColor); break; } }
protected void DrawCandlestickSerie(VertexHelper vh, int colorIndex, Serie serie) { if (!IsActive(serie.index)) { return; } if (serie.animation.HasFadeOut()) { return; } var showData = serie.GetDataList(dataZoom); var yAxis = m_YAxes[serie.yAxisIndex]; var xAxis = m_XAxes[serie.xAxisIndex]; var grid = GetSerieGridOrDefault(serie); float categoryWidth = AxisHelper.GetDataWidth(xAxis, grid.runtimeWidth, showData.Count, dataZoom); float barWidth = serie.GetBarWidth(categoryWidth); float space = (categoryWidth - barWidth) / 2; int maxCount = serie.maxShow > 0 ? (serie.maxShow > showData.Count ? showData.Count : serie.maxShow) : showData.Count; bool dataChanging = false; float dataChangeDuration = serie.animation.GetUpdateAnimationDuration(); float yMinValue = yAxis.GetCurrMinValue(dataChangeDuration); float yMaxValue = yAxis.GetCurrMaxValue(dataChangeDuration); var isAllBarEnd = true; var isYAxis = false; for (int i = serie.minShow; i < maxCount; i++) { var serieData = showData[i]; if (serie.IsIgnoreValue(serieData.GetData(1))) { serie.dataPoints.Add(Vector3.zero); continue; } var highlight = (tooltip.show && tooltip.IsSelected(i)) || serie.data[i].highlighted || serie.highlighted; var itemStyle = SerieHelper.GetItemStyle(serie, serieData, highlight); var open = serieData.GetCurrData(0, dataChangeDuration, yAxis.inverse, yMinValue, yMaxValue); var close = serieData.GetCurrData(1, dataChangeDuration, yAxis.inverse, yMinValue, yMaxValue); var lowest = serieData.GetCurrData(2, dataChangeDuration, yAxis.inverse, yMinValue, yMaxValue); var heighest = serieData.GetCurrData(3, dataChangeDuration, yAxis.inverse, yMinValue, yMaxValue); var isRise = close > open; var borderWidth = open == 0 ? 0f : (itemStyle.runtimeBorderWidth == 0 ? m_Theme.serie.candlestickBorderWidth : itemStyle.runtimeBorderWidth); if (serieData.IsDataChanged()) { dataChanging = true; } float pX = grid.runtimeX + i * categoryWidth; float zeroY = grid.runtimeY + yAxis.runtimeZeroYOffset; if (!xAxis.boundaryGap) { pX -= categoryWidth / 2; } float pY = zeroY; var barHig = 0f; var valueTotal = yMaxValue - yMinValue; var minCut = (yMinValue > 0 ? yMinValue : 0); if (valueTotal != 0) { barHig = (close - open) / valueTotal * grid.runtimeHeight; pY += (open - minCut) / valueTotal * grid.runtimeHeight; } serieData.runtimeStackHig = barHig; var isBarEnd = false; float currHig = CheckAnimation(serie, i, barHig, out isBarEnd); if (!isBarEnd) { isAllBarEnd = false; } Vector3 plb, plt, prt, prb, top; plb = new Vector3(pX + space + borderWidth, pY + borderWidth); plt = new Vector3(pX + space + borderWidth, pY + currHig - borderWidth); prt = new Vector3(pX + space + barWidth - borderWidth, pY + currHig - borderWidth); prb = new Vector3(pX + space + barWidth - borderWidth, pY + borderWidth); top = new Vector3(pX + space + barWidth / 2, pY + currHig - borderWidth); if (serie.clip) { plb = ClampInGrid(grid, plb); plt = ClampInGrid(grid, plt); prt = ClampInGrid(grid, prt); prb = ClampInGrid(grid, prb); top = ClampInGrid(grid, top); } serie.dataPoints.Add(top); var areaColor = isRise ? itemStyle.GetColor(m_Theme.serie.candlestickColor) : itemStyle.GetColor0(m_Theme.serie.candlestickColor0); var borderColor = isRise ? itemStyle.GetBorderColor(m_Theme.serie.candlestickBorderColor) : itemStyle.GetBorderColor0(m_Theme.serie.candlestickBorderColor0); var itemWidth = Mathf.Abs(prt.x - plb.x); var itemHeight = Mathf.Abs(plt.y - prb.y); var center = new Vector3((plb.x + prt.x) / 2, (plt.y + prb.y) / 2); var lowPos = new Vector3(center.x, zeroY + (lowest - minCut) / valueTotal * grid.runtimeHeight); var heighPos = new Vector3(center.x, zeroY + (heighest - minCut) / valueTotal * grid.runtimeHeight); var openCenterPos = new Vector3(center.x, prb.y); var closeCenterPos = new Vector3(center.x, prt.y); if (barWidth > 2f * borderWidth) { if (itemWidth > 0 && itemHeight > 0) { if (ItemStyleHelper.IsNeedCorner(itemStyle)) { UGL.DrawRoundRectangle(vh, center, itemWidth, itemHeight, areaColor, areaColor, 0, itemStyle.cornerRadius, isYAxis, 0.5f); } else { CheckClipAndDrawPolygon(vh, ref prb, ref plb, ref plt, ref prt, areaColor, areaColor, serie.clip, grid); } UGL.DrawBorder(vh, center, itemWidth, itemHeight, 2 * borderWidth, borderColor, 0, itemStyle.cornerRadius, isYAxis, 0.5f); } } else { UGL.DrawLine(vh, openCenterPos, closeCenterPos, Mathf.Max(borderWidth, barWidth / 2), borderColor); } if (isRise) { UGL.DrawLine(vh, openCenterPos, lowPos, borderWidth, borderColor); UGL.DrawLine(vh, closeCenterPos, heighPos, borderWidth, borderColor); } else { UGL.DrawLine(vh, closeCenterPos, lowPos, borderWidth, borderColor); UGL.DrawLine(vh, openCenterPos, heighPos, borderWidth, borderColor); } } if (isAllBarEnd) { serie.animation.AllBarEnd(); } if (dataChanging) { RefreshPainter(serie); } }