private void DrawXBarSerie(VertexHelper vh, int serieIndex, int stackCount, Serie serie, Color color, ref List <float> seriesHig) { if (!IsActive(serie.name)) { return; } List <float> showData = serie.GetYDataList(m_DataZoom); var yAxis = m_YAxises[serie.axisIndex]; var xAxis = m_XAxises[serie.axisIndex]; if (!xAxis.show) { xAxis = m_XAxises[(serie.axisIndex + 1) % m_XAxises.Count]; } float scaleWid = xAxis.GetDataWidth(coordinateWid, m_DataZoom); float barWid = m_Bar.barWidth > 1 ? m_Bar.barWidth : scaleWid * m_Bar.barWidth; float offset = m_Bar.inSameBar ? (scaleWid - barWid - m_Bar.space * (stackCount - 1)) / 2 : (scaleWid - barWid * stackCount - m_Bar.space * (stackCount - 1)) / 2; int maxCount = maxShowDataNumber > 0 ? (maxShowDataNumber > showData.Count ? showData.Count : maxShowDataNumber) : showData.Count; if (seriesHig.Count < minShowDataNumber) { for (int i = 0; i < minShowDataNumber; i++) { seriesHig.Add(0); } } for (int i = minShowDataNumber; i < maxCount; i++) { if (i >= seriesHig.Count) { seriesHig.Add(0); } float value = showData[i]; float pX = coordinateX + i * scaleWid; float zeroY = coordinateY + yAxis.zeroYOffset; if (!xAxis.boundaryGap) { pX -= scaleWid / 2; } float pY = seriesHig[i] + zeroY + m_Coordinate.tickness; float barHig = (yAxis.minValue > 0 ? value - yAxis.minValue : value) / (yAxis.maxValue - yAxis.minValue) * coordinateHig; seriesHig[i] += barHig; float space = m_Bar.inSameBar ? offset : offset + serieIndex * (barWid + m_Bar.space); Vector3 p1 = new Vector3(pX + space, pY); Vector3 p2 = new Vector3(pX + space, pY + barHig); Vector3 p3 = new Vector3(pX + space + barWid, pY + barHig); Vector3 p4 = new Vector3(pX + space + barWid, pY); if (serie.show) { ChartHelper.DrawPolygon(vh, p1, p2, p3, p4, color); } } }
private void DrawDataZoom(VertexHelper vh) { if (!m_DataZoom.show) { return; } var p1 = new Vector2(coordinateX, m_DataZoom.bottom); var p2 = new Vector2(coordinateX, m_DataZoom.bottom + m_DataZoom.height); var p3 = new Vector2(coordinateX + coordinateWid, m_DataZoom.bottom + m_DataZoom.height); var p4 = new Vector2(coordinateX + coordinateWid, m_DataZoom.bottom); ChartHelper.DrawLine(vh, p1, p2, m_Coordinate.tickness, m_ThemeInfo.dataZoomLineColor); ChartHelper.DrawLine(vh, p2, p3, m_Coordinate.tickness, m_ThemeInfo.dataZoomLineColor); ChartHelper.DrawLine(vh, p3, p4, m_Coordinate.tickness, m_ThemeInfo.dataZoomLineColor); ChartHelper.DrawLine(vh, p4, p1, m_Coordinate.tickness, m_ThemeInfo.dataZoomLineColor); if (m_DataZoom.showDataShadow && m_Series.Count > 0) { Serie serie = m_Series.series[0]; float scaleWid = coordinateWid / (serie.data.Count - 1); Vector3 lp = Vector3.zero; Vector3 np = Vector3.zero; for (int i = 0; i < serie.data.Count; i++) { float value = serie.data[i]; float pX = zeroX + i * scaleWid; float dataHig = value / (maxValue - minValue) * m_DataZoom.height; np = new Vector3(pX, m_DataZoom.bottom + dataHig); if (i > 0) { Color color = m_ThemeInfo.dataZoomLineColor; ChartHelper.DrawLine(vh, lp, np, m_Coordinate.tickness, color); Vector3 alp = new Vector3(lp.x, lp.y - m_Coordinate.tickness); Vector3 anp = new Vector3(np.x, np.y - m_Coordinate.tickness); Color areaColor = new Color(color.r, color.g, color.b, color.a * 0.75f); Vector3 tnp = new Vector3(np.x, m_DataZoom.bottom + m_Coordinate.tickness); Vector3 tlp = new Vector3(lp.x, m_DataZoom.bottom + m_Coordinate.tickness); ChartHelper.DrawPolygon(vh, alp, anp, tnp, tlp, areaColor); } lp = np; } } switch (m_DataZoom.rangeMode) { case DataZoom.RangeMode.Percent: var start = coordinateX + coordinateWid * m_DataZoom.start / 100; var end = coordinateX + coordinateWid * m_DataZoom.end / 100; p1 = new Vector2(start, m_DataZoom.bottom); p2 = new Vector2(start, m_DataZoom.bottom + m_DataZoom.height); p3 = new Vector2(end, m_DataZoom.bottom + m_DataZoom.height); p4 = new Vector2(end, m_DataZoom.bottom); ChartHelper.DrawPolygon(vh, p1, p2, p3, p4, m_ThemeInfo.dataZoomSelectedColor); ChartHelper.DrawLine(vh, p1, p2, m_Coordinate.tickness, m_ThemeInfo.dataZoomSelectedColor); ChartHelper.DrawLine(vh, p3, p4, m_Coordinate.tickness, m_ThemeInfo.dataZoomSelectedColor); break; } }
private void DrawBackground(VertexHelper vh) { // draw bg Vector3 p1 = new Vector3(0, chartHeight); Vector3 p2 = new Vector3(chartWidth, chartHeight); Vector3 p3 = new Vector3(chartWidth, 0); Vector3 p4 = new Vector3(0, 0); ChartHelper.DrawPolygon(vh, p1, p2, p3, p4, m_ThemeInfo.backgroundColor); }
private void DrawYBarSerie(VertexHelper vh, int serieIndex, int stackCount, Serie serie, Color color, ref Dictionary <int, float> seriesHig) { if (!m_Legend.IsActive(serie.name)) { return; } var xAxis = m_XAxises[serie.axisIndex]; var yAxis = m_YAxises[serie.axisIndex]; if (!yAxis.show) { yAxis = m_YAxises[(serie.axisIndex + 1) % m_YAxises.Count]; } float scaleWid = yAxis.GetDataWidth(coordinateHig, m_DataZoom); float barWid = m_Bar.barWidth > 1 ? m_Bar.barWidth : scaleWid * m_Bar.barWidth; float offset = m_Bar.inSameBar ? (scaleWid - barWid - m_Bar.space * (stackCount - 1)) / 2 : (scaleWid - barWid * stackCount - m_Bar.space * (stackCount - 1)) / 2; int maxCount = maxShowDataNumber > 0 ? (maxShowDataNumber > serie.yData.Count ? serie.yData.Count : maxShowDataNumber) : serie.yData.Count; for (int i = minShowDataNumber; i < maxCount; i++) { if (!seriesHig.ContainsKey(i)) { seriesHig[i] = 0; } float value = serie.yData[i]; float pX = seriesHig[i] + coordinateX + xAxis.zeroXOffset + m_Coordinate.tickness; float pY = coordinateY + +i * scaleWid; if (!yAxis.boundaryGap) { pY -= scaleWid / 2; } float barHig = (xAxis.minValue > 0 ? value - xAxis.minValue : value) / (xAxis.maxValue - xAxis.minValue) * coordinateWid; float space = m_Bar.inSameBar ? offset : offset + serieIndex * (barWid + m_Bar.space); seriesHig[i] += barHig; Vector3 p1 = new Vector3(pX, pY + space + barWid); Vector3 p2 = new Vector3(pX + barHig, pY + space + barWid); Vector3 p3 = new Vector3(pX + barHig, pY + space); Vector3 p4 = new Vector3(pX, pY + space); if (serie.show) { ChartHelper.DrawPolygon(vh, p1, p2, p3, p4, color); } } }
private void DrawRadar(VertexHelper vh, Radar radar) { if (!radar.lineStyle.show && !radar.splitArea.show) { return; } float insideRadius = 0, outsideRadius = 0; float block = radar.actualRadius / radar.splitNumber; int indicatorNum = radar.indicatorList.Count; Vector3 p1, p2, p3, p4; Vector3 p = radar.centerPos; float angle = 2 * Mathf.PI / indicatorNum; var lineColor = GetLineColor(radar); for (int i = 0; i < radar.splitNumber; i++) { Color color = radar.splitArea.color[i % radar.splitArea.color.Count]; outsideRadius = insideRadius + block; p1 = new Vector3(p.x + insideRadius * Mathf.Sin(0), p.y + insideRadius * Mathf.Cos(0)); p2 = new Vector3(p.x + outsideRadius * Mathf.Sin(0), p.y + outsideRadius * Mathf.Cos(0)); for (int j = 0; j <= indicatorNum; j++) { float currAngle = j * angle; p3 = new Vector3(p.x + outsideRadius * Mathf.Sin(currAngle), p.y + outsideRadius * Mathf.Cos(currAngle)); p4 = new Vector3(p.x + insideRadius * Mathf.Sin(currAngle), p.y + insideRadius * Mathf.Cos(currAngle)); if (radar.splitArea.show) { ChartHelper.DrawPolygon(vh, p1, p2, p3, p4, color); } if (radar.lineStyle.show) { ChartHelper.DrawLine(vh, p2, p3, radar.lineStyle.width, lineColor); } p1 = p4; p2 = p3; } insideRadius = outsideRadius; } for (int j = 0; j <= indicatorNum; j++) { float currAngle = j * angle; p3 = new Vector3(p.x + outsideRadius * Mathf.Sin(currAngle), p.y + outsideRadius * Mathf.Cos(currAngle)); if (radar.lineStyle.show) { ChartHelper.DrawLine(vh, p, p3, radar.lineStyle.width / 2, lineColor); } } }
private void DrawPolygonToZero(VertexHelper vh, Vector3 sp, Vector3 ep, Axis axis, Vector3 zeroPos, Color areaColor, Color areaToColor) { float diff = 0; if (axis is YAxis) { diff = sp.x < zeroPos.x || ep.x < zeroPos.x ? -axis.axisLine.width : axis.axisLine.width; ChartHelper.DrawPolygon(vh, new Vector3(zeroPos.x + diff, sp.y), new Vector3(zeroPos.x + diff, ep.y), ep, sp, areaToColor, areaColor); } else { diff = sp.y < zeroPos.y || ep.y < zeroPos.y ? -axis.axisLine.width : axis.axisLine.width; ChartHelper.DrawPolygon(vh, sp, ep, new Vector3(ep.x, zeroPos.y + diff), new Vector3(sp.x, zeroPos.y + diff), areaColor, areaToColor); } }
protected void DrawLabelBackground(VertexHelper vh, Serie serie, SerieData serieData) { var labelHalfWid = serieData.GetLabelWidth() / 2; var labelHalfHig = serieData.GetLabelHeight() / 2; var centerPos = serieData.labelPosition; var p1 = new Vector3(centerPos.x - labelHalfWid, centerPos.y + labelHalfHig); var p2 = new Vector3(centerPos.x + labelHalfWid, centerPos.y + labelHalfHig); var p3 = new Vector3(centerPos.x + labelHalfWid, centerPos.y - labelHalfHig); var p4 = new Vector3(centerPos.x - labelHalfWid, centerPos.y - labelHalfHig); if (serie.label.rotate > 0) { p1 = ChartHelper.RotateRound(p1, centerPos, Vector3.forward, serie.label.rotate); p2 = ChartHelper.RotateRound(p2, centerPos, Vector3.forward, serie.label.rotate); p3 = ChartHelper.RotateRound(p3, centerPos, Vector3.forward, serie.label.rotate); p4 = ChartHelper.RotateRound(p4, centerPos, Vector3.forward, serie.label.rotate); } ChartHelper.DrawPolygon(vh, p1, p2, p3, p4, serie.label.backgroundColor); if (serie.label.border) { var borderWid = serie.label.borderWidth; p1 = new Vector3(centerPos.x - labelHalfWid, centerPos.y + labelHalfHig + borderWid); p2 = new Vector3(centerPos.x + labelHalfWid + 2 * borderWid, centerPos.y + labelHalfHig + borderWid); p3 = new Vector3(centerPos.x + labelHalfWid + borderWid, centerPos.y + labelHalfHig); p4 = new Vector3(centerPos.x + labelHalfWid + borderWid, centerPos.y - labelHalfHig - 2 * borderWid); var p5 = new Vector3(centerPos.x + labelHalfWid, centerPos.y - labelHalfHig - borderWid); var p6 = new Vector3(centerPos.x - labelHalfWid - 2 * borderWid, centerPos.y - labelHalfHig - borderWid); var p7 = new Vector3(centerPos.x - labelHalfWid - borderWid, centerPos.y - labelHalfHig); var p8 = new Vector3(centerPos.x - labelHalfWid - borderWid, centerPos.y + labelHalfHig + 2 * borderWid); if (serie.label.rotate > 0) { p1 = ChartHelper.RotateRound(p1, centerPos, Vector3.forward, serie.label.rotate); p2 = ChartHelper.RotateRound(p2, centerPos, Vector3.forward, serie.label.rotate); p3 = ChartHelper.RotateRound(p3, centerPos, Vector3.forward, serie.label.rotate); p4 = ChartHelper.RotateRound(p4, centerPos, Vector3.forward, serie.label.rotate); p5 = ChartHelper.RotateRound(p5, centerPos, Vector3.forward, serie.label.rotate); p6 = ChartHelper.RotateRound(p6, centerPos, Vector3.forward, serie.label.rotate); p7 = ChartHelper.RotateRound(p7, centerPos, Vector3.forward, serie.label.rotate); p8 = ChartHelper.RotateRound(p8, centerPos, Vector3.forward, serie.label.rotate); } ChartHelper.DrawLine(vh, p1, p2, borderWid, serie.label.borderColor); ChartHelper.DrawLine(vh, p3, p4, borderWid, serie.label.borderColor); ChartHelper.DrawLine(vh, p5, p6, borderWid, serie.label.borderColor); ChartHelper.DrawLine(vh, p7, p8, borderWid, serie.label.borderColor); } }
protected void DrawSymbol(VertexHelper vh, SerieSymbolType type, float symbolSize, float tickness, Vector3 pos, Color color) { switch (type) { case SerieSymbolType.None: break; case SerieSymbolType.Circle: ChartHelper.DrawCricle(vh, pos, symbolSize, color, GetSymbolCricleSegment(symbolSize)); break; case SerieSymbolType.EmptyCircle: int segment = GetSymbolCricleSegment(symbolSize); ChartHelper.DrawCricle(vh, pos, symbolSize, m_ThemeInfo.backgroundColor, segment); ChartHelper.DrawDoughnut(vh, pos, symbolSize - tickness, symbolSize, 0, 360, color, segment); break; case SerieSymbolType.Rect: ChartHelper.DrawPolygon(vh, pos, symbolSize, color); break; case SerieSymbolType.Triangle: var x = symbolSize * Mathf.Cos(30 * Mathf.PI / 180); var y = symbolSize * Mathf.Sin(30 * Mathf.PI / 180); var p1 = new Vector2(pos.x - x, pos.y - y); var p2 = new Vector2(pos.x, pos.y + symbolSize); var p3 = new Vector2(pos.x + x, pos.y - y); ChartHelper.DrawTriangle(vh, p1, p2, p3, color); break; case SerieSymbolType.Diamond: p1 = new Vector2(pos.x - symbolSize, pos.y); p2 = new Vector2(pos.x, pos.y + symbolSize); p3 = new Vector2(pos.x + symbolSize, pos.y); var p4 = new Vector2(pos.x, pos.y - symbolSize); ChartHelper.DrawPolygon(vh, p1, p2, p3, p4, color); break; } }
private void DrawRadar(VertexHelper vh) { float insideRadius = 0, outsideRadius = 0; float block = m_Radar.radius / m_Radar.splitNumber; int indicatorNum = m_Radar.indicatorList.Count; Vector3 p1, p2, p3, p4; Vector3 p = new Vector3(m_RadarCenterX, m_RadarCenterY); float angle = 2 * Mathf.PI / indicatorNum; for (int i = 0; i < m_Radar.splitNumber; i++) { Color color = m_Radar.backgroundColorList[i % m_Radar.backgroundColorList.Count]; outsideRadius = insideRadius + block; p1 = new Vector3(p.x + insideRadius * Mathf.Sin(0), p.y + insideRadius * Mathf.Cos(0)); p2 = new Vector3(p.x + outsideRadius * Mathf.Sin(0), p.y + outsideRadius * Mathf.Cos(0)); for (int j = 0; j <= indicatorNum; j++) { float currAngle = j * angle; p3 = new Vector3(p.x + outsideRadius * Mathf.Sin(currAngle), p.y + outsideRadius * Mathf.Cos(currAngle)); p4 = new Vector3(p.x + insideRadius * Mathf.Sin(currAngle), p.y + insideRadius * Mathf.Cos(currAngle)); ChartHelper.DrawPolygon(vh, p1, p2, p3, p4, color); ChartHelper.DrawLine(vh, p2, p3, m_Radar.lineTickness, m_Radar.lineColor); p1 = p4; p2 = p3; } insideRadius = outsideRadius; } for (int j = 0; j <= indicatorNum; j++) { float currAngle = j * angle; p3 = new Vector3(p.x + outsideRadius * Mathf.Sin(currAngle), p.y + outsideRadius * Mathf.Cos(currAngle)); ChartHelper.DrawLine(vh, p, p3, m_Radar.lineTickness / 2, m_Radar.lineColor); } }
private void DrawYBarSerie(VertexHelper vh, int serieIndex, int stackCount, Serie serie, int colorIndex, ref List <float> seriesHig) { if (!IsActive(serie.name)) { return; } var xAxis = m_XAxises[serie.axisIndex]; var yAxis = m_YAxises[serie.axisIndex]; if (!yAxis.show) { yAxis = m_YAxises[(serie.axisIndex + 1) % m_YAxises.Count]; } float categoryWidth = yAxis.GetDataWidth(coordinateHig, m_DataZoom); float barGap = GetBarGap(); float totalBarWidth = GetBarTotalWidth(categoryWidth, barGap); float barWidth = serie.GetBarWidth(categoryWidth); float offset = (categoryWidth - totalBarWidth) / 2; float barGapWidth = barWidth + barWidth * barGap; float space = serie.barGap == -1 ? offset : offset + m_BarLastOffset; var showData = serie.GetDataList(m_DataZoom); int maxCount = maxShowDataNumber > 0 ? (maxShowDataNumber > showData.Count ? showData.Count : maxShowDataNumber) : showData.Count; if (seriesHig.Count < minShowDataNumber) { for (int i = 0; i < minShowDataNumber; i++) { seriesHig.Add(0); } } for (int i = minShowDataNumber; i < maxCount; i++) { if (i >= seriesHig.Count) { seriesHig.Add(0); } float value = showData[i].data[1]; float pX = seriesHig[i] + coordinateX + xAxis.zeroXOffset + yAxis.axisLine.width; float pY = coordinateY + +i * categoryWidth; if (!yAxis.boundaryGap) { pY -= categoryWidth / 2; } float barHig = (xAxis.minValue > 0 ? value - xAxis.minValue : value) / (xAxis.maxValue - xAxis.minValue) * coordinateWid; seriesHig[i] += barHig; Vector3 p1 = new Vector3(pX, pY + space + barWidth); Vector3 p2 = new Vector3(pX + barHig, pY + space + barWidth); Vector3 p3 = new Vector3(pX + barHig, pY + space); Vector3 p4 = new Vector3(pX, pY + space); serie.dataPoints.Add(new Vector3(pX + barHig, pY + space + barWidth / 2)); var highlight = (m_Tooltip.show && m_Tooltip.IsSelected(i)) || serie.data[i].highlighted || serie.highlighted; if (serie.show) { Color areaColor = serie.GetAreaColor(m_ThemeInfo, colorIndex, highlight); Color areaToColor = serie.GetAreaToColor(m_ThemeInfo, colorIndex, highlight); ChartHelper.DrawPolygon(vh, p1, p2, p3, p4, areaColor, areaToColor); } } if (!m_Series.IsStack(serie.stack, SerieType.Bar)) { m_BarLastOffset += barGapWidth; } }
private void DrawXCategory(VertexHelper vh) { var stackSeries = m_Series.GetStackSeries(); int seriesCount = stackSeries.Count; float scaleWid = m_XAxis.GetDataWidth(coordinateWid, m_DataZoom); int serieCount = 0; List <Vector3> points = new List <Vector3>(); List <Vector3> smoothPoints = new List <Vector3>(); List <Color> colorList = new List <Color>(); int dataCount = 0; for (int j = 0; j < seriesCount; j++) { var seriesCurrHig = new Dictionary <int, float>(); var serieList = stackSeries[j]; for (int n = 0; n < serieList.Count; n++) { Serie serie = serieList[n]; if (!IsActive(serie.name)) { continue; } List <Vector3> lastPoints = new List <Vector3>(); List <Vector3> lastSmoothPoints = new List <Vector3>(); List <float> serieData = serie.GetData(m_DataZoom); Color color = m_ThemeInfo.GetColor(serieCount); Vector3 lp = Vector3.zero; Vector3 np = Vector3.zero; float startX = zeroX + (m_XAxis.boundaryGap ? scaleWid / 2 : 0); int maxCount = maxShowDataNumber > 0 ? (maxShowDataNumber > serieData.Count ? serieData.Count : maxShowDataNumber) : serieData.Count; dataCount = (maxCount - minShowDataNumber); if (m_Line.area && points.Count > 0) { if (!m_Line.smooth && points.Count > 0) { for (int m = points.Count - dataCount; m < points.Count; m++) { lastPoints.Add(points[m]); } } else if (m_Line.smooth && smoothPoints.Count > 0) { for (int m = 0; m < smoothPoints.Count; m++) { lastSmoothPoints.Add(smoothPoints[m]); } smoothPoints.Clear(); } } int smoothPointCount = 1; for (int i = minShowDataNumber; i < maxCount; i++) { if (!seriesCurrHig.ContainsKey(i)) { seriesCurrHig[i] = 0; } float value = serieData[i]; float pX = startX + i * scaleWid; float pY = seriesCurrHig[i] + zeroY + m_Coordinate.tickness; float dataHig = value / (maxValue - minValue) * coordinateHig; np = new Vector3(pX, pY + dataHig); if (i > 0) { if (m_Line.step) { Vector2 middle1, middle2; switch (m_Line.stepTpe) { case Line.StepType.Start: middle1 = new Vector2(lp.x, np.y + m_Line.tickness); middle2 = new Vector2(lp.x - m_Line.tickness, np.y); ChartHelper.DrawLine(vh, lp, middle1, m_Line.tickness, color); ChartHelper.DrawLine(vh, middle2, np, m_Line.tickness, color); if (m_Line.area) { Color areaColor = new Color(color.r, color.g, color.b, color.a * 0.75f); ChartHelper.DrawPolygon(vh, new Vector2(middle1.x, zeroY), middle1, np, new Vector2(np.x, zeroY), areaColor); } break; case Line.StepType.Middle: middle1 = new Vector2((lp.x + np.x) / 2 + m_Line.tickness, lp.y); middle2 = new Vector2((lp.x + np.x) / 2 - m_Line.tickness, np.y); ChartHelper.DrawLine(vh, lp, middle1, m_Line.tickness, color); ChartHelper.DrawLine(vh, new Vector2(middle1.x - m_Line.tickness, middle1.y), new Vector2(middle2.x + m_Line.tickness, middle2.y), m_Line.tickness, color); ChartHelper.DrawLine(vh, middle2, np, m_Line.tickness, color); if (m_Line.area) { Color areaColor = new Color(color.r, color.g, color.b, color.a * 0.75f); ChartHelper.DrawPolygon(vh, new Vector2(lp.x, zeroY), lp, middle1, new Vector2(middle1.x, zeroY), areaColor); ChartHelper.DrawPolygon(vh, new Vector2(middle2.x + 2 * m_Line.tickness, zeroY), new Vector2(middle2.x + 2 * m_Line.tickness, middle2.y), np, new Vector2(np.x, zeroY), areaColor); } break; case Line.StepType.End: middle1 = new Vector2(np.x + m_Line.tickness, lp.y); middle2 = new Vector2(np.x, lp.y); ChartHelper.DrawLine(vh, lp, middle1, m_Line.tickness, color); ChartHelper.DrawLine(vh, middle2, np, m_Line.tickness, color); if (m_Line.area) { Color areaColor = new Color(color.r, color.g, color.b, color.a * 0.75f); ChartHelper.DrawPolygon(vh, new Vector2(lp.x, zeroY), lp, new Vector2(middle1.x - m_Line.tickness, middle1.y), new Vector2(middle1.x - m_Line.tickness, zeroY), areaColor); } break; } } else if (m_Line.smooth) { var list = ChartHelper.GetBezierList(lp, np, m_Line.smoothStyle); Vector3 start, to; start = list[0]; for (int k = 1; k < list.Length; k++) { smoothPoints.Add(list[k]); to = list[k]; ChartHelper.DrawLine(vh, start, to, m_Line.tickness, color); if (m_Line.area) { Vector3 alp = new Vector3(start.x, start.y - m_Line.tickness); Vector3 anp = new Vector3(to.x, to.y - m_Line.tickness); Vector3 tnp = serieCount > 0 ? (smoothPointCount > lastSmoothPoints.Count - 1 ? new Vector3(lastSmoothPoints[lastSmoothPoints.Count - 1].x, lastSmoothPoints[lastSmoothPoints.Count - 1].y + m_Line.tickness) : new Vector3(lastSmoothPoints[smoothPointCount].x, lastSmoothPoints[smoothPointCount].y + m_Line.tickness)) : new Vector3(to.x, zeroY + m_Coordinate.tickness); Vector3 tlp = serieCount > 0 ? (smoothPointCount > lastSmoothPoints.Count - 1 ? new Vector3(lastSmoothPoints[lastSmoothPoints.Count - 2].x, lastSmoothPoints[lastSmoothPoints.Count - 2].y + m_Line.tickness) : new Vector3(lastSmoothPoints[smoothPointCount - 1].x, lastSmoothPoints[smoothPointCount - 1].y + m_Line.tickness)) : new Vector3(start.x, zeroY + m_Coordinate.tickness); Color areaColor = new Color(color.r, color.g, color.b, color.a * 0.75f); ChartHelper.DrawPolygon(vh, alp, anp, tnp, tlp, areaColor); } smoothPointCount++; start = to; } } else { ChartHelper.DrawLine(vh, lp, np, m_Line.tickness, color); if (m_Line.area) { Vector3 alp = new Vector3(lp.x, lp.y - m_Line.tickness); Vector3 anp = new Vector3(np.x, np.y - m_Line.tickness); Color areaColor = new Color(color.r, color.g, color.b, color.a * 0.75f); var cross = ChartHelper.GetIntersection(lp, np, new Vector3(zeroX, zeroY), new Vector3(zeroX + coordinateWid, zeroY)); if (cross == Vector3.zero) { Vector3 tnp = serieCount > 0 ? new Vector3(lastPoints[i].x, lastPoints[i].y + m_Line.tickness) : new Vector3(np.x, zeroY + m_Coordinate.tickness); Vector3 tlp = serieCount > 0 ? new Vector3(lastPoints[i - 1].x, lastPoints[i - 1].y + m_Line.tickness) : new Vector3(lp.x, zeroY + m_Coordinate.tickness); ChartHelper.DrawPolygon(vh, alp, anp, tnp, tlp, areaColor); } else { Vector3 cross1 = new Vector3(cross.x, cross.y + (alp.y > zeroY ? m_Coordinate.tickness : -m_Coordinate.tickness)); Vector3 cross2 = new Vector3(cross.x, cross.y + (anp.y > zeroY ? m_Coordinate.tickness : -m_Coordinate.tickness)); Vector3 xp1 = new Vector3(alp.x, zeroY + (alp.y > zeroY ? m_Coordinate.tickness : -m_Coordinate.tickness)); Vector3 xp2 = new Vector3(anp.x, zeroY + (anp.y > zeroY ? m_Coordinate.tickness : -m_Coordinate.tickness)); ChartHelper.DrawTriangle(vh, alp, cross1, xp1, areaColor); ChartHelper.DrawTriangle(vh, anp, cross2, xp2, areaColor); } } } } if (m_Line.point) { points.Add(np); colorList.Add(color); } seriesCurrHig[i] += dataHig; lp = np; } if (serie.show) { serieCount++; } } // draw point if (m_Line.point) { for (int i = 0; i < points.Count; i++) { Vector3 p = points[i]; float pointWid = m_Line.pointWidth; if (m_Tooltip.show && i % dataCount == m_Tooltip.dataIndex - 1) { pointWid = pointWid * 1.8f; } if (m_Theme == Theme.Dark) { ChartHelper.DrawCricle(vh, p, pointWid, colorList[i], (int)m_Line.pointWidth * 5); } else { ChartHelper.DrawCricle(vh, p, pointWid, Color.white); ChartHelper.DrawDoughnut(vh, p, pointWid - m_Line.tickness, pointWid, 0, 360, colorList[i]); } } } } //draw tooltip line if (m_Tooltip.show && m_Tooltip.dataIndex > 0) { float splitWidth = m_XAxis.GetSplitWidth(coordinateWid, m_DataZoom); float px = zeroX + (m_Tooltip.dataIndex - 1) * splitWidth + (m_XAxis.boundaryGap ? splitWidth / 2 : 0); Vector2 sp = new Vector2(px, coordinateY); Vector2 ep = new Vector2(px, coordinateY + coordinateHig); ChartHelper.DrawLine(vh, sp, ep, m_Coordinate.tickness, m_ThemeInfo.tooltipLineColor); if (m_Tooltip.crossLabel) { sp = new Vector2(zeroX, m_Tooltip.pointerPos.y); ep = new Vector2(zeroX + coordinateWid, m_Tooltip.pointerPos.y); DrawSplitLine(vh, true, Axis.SplitLineType.Dashed, sp, ep, m_ThemeInfo.tooltipLineColor); } } }
protected override void DrawChart(VertexHelper vh) { base.DrawChart(vh); if (m_YAxis.type == Axis.AxisType.Category) { var stackSeries = m_Series.GetStackSeries(); int seriesCount = stackSeries.Count; float scaleWid = m_YAxis.GetDataWidth(coordinateHig, m_DataZoom); float barWid = m_Bar.barWidth > 1 ? m_Bar.barWidth : scaleWid * m_Bar.barWidth; float offset = m_Bar.inSameBar ? (scaleWid - barWid - m_Bar.space * (seriesCount - 1)) / 2 : (scaleWid - barWid * seriesCount - m_Bar.space * (seriesCount - 1)) / 2; int serieCount = 0; for (int j = 0; j < seriesCount; j++) { var seriesCurrHig = new Dictionary <int, float>(); var serieList = stackSeries[j]; for (int n = 0; n < serieList.Count; n++) { Serie serie = serieList[n]; if (!m_Legend.IsActive(serie.name)) { continue; } Color color = m_ThemeInfo.GetColor(serieCount); int maxCount = maxShowDataNumber > 0 ? (maxShowDataNumber > serie.data.Count ? serie.data.Count : maxShowDataNumber) : serie.data.Count; for (int i = minShowDataNumber; i < maxCount; i++) { if (!seriesCurrHig.ContainsKey(i)) { seriesCurrHig[i] = 0; } float value = serie.data[i]; float pX = seriesCurrHig[i] + zeroX + m_Coordinate.tickness; float pY = coordinateY + i * scaleWid; if (!m_YAxis.boundaryGap) { pY -= scaleWid / 2; } float barHig = value / (maxValue - minValue) * coordinateWid; float space = m_Bar.inSameBar ? offset : offset + j * (barWid + m_Bar.space); seriesCurrHig[i] += barHig; Vector3 p1 = new Vector3(pX, pY + space + barWid); Vector3 p2 = new Vector3(pX + barHig, pY + space + barWid); Vector3 p3 = new Vector3(pX + barHig, pY + space); Vector3 p4 = new Vector3(pX, pY + space); if (serie.show) { ChartHelper.DrawPolygon(vh, p1, p2, p3, p4, color); } } if (serie.show) { serieCount++; } } } if (m_Tooltip.show && m_Tooltip.dataIndex > 0) { if (m_Tooltip.crossLabel) { Vector3 sp = new Vector2(m_Tooltip.pointerPos.x, zeroY); Vector3 ep = new Vector2(m_Tooltip.pointerPos.x, zeroY + coordinateHig); DrawSplitLine(vh, false, Axis.SplitLineType.Dashed, sp, ep, m_ThemeInfo.tooltipLineColor); float splitWidth = m_YAxis.GetSplitWidth(coordinateHig, m_DataZoom); float pY = zeroY + (m_Tooltip.dataIndex - 1) * splitWidth + (m_YAxis.boundaryGap ? splitWidth / 2 : 0); sp = new Vector2(coordinateX, pY); ep = new Vector2(coordinateX + coordinateWid, pY); DrawSplitLine(vh, true, Axis.SplitLineType.Dashed, sp, ep, m_ThemeInfo.tooltipLineColor); } else { float tooltipSplitWid = scaleWid < 1 ? 1 : scaleWid; float pX = coordinateX + coordinateWid; float pY = coordinateY + scaleWid * (m_Tooltip.dataIndex - 1) - (m_YAxis.boundaryGap ? 0 : scaleWid / 2); Vector3 p1 = new Vector3(coordinateX, pY); Vector3 p2 = new Vector3(coordinateX, pY + tooltipSplitWid); Vector3 p3 = new Vector3(pX, pY + tooltipSplitWid); Vector3 p4 = new Vector3(pX, pY); ChartHelper.DrawPolygon(vh, p1, p2, p3, p4, m_ThemeInfo.tooltipFlagAreaColor); } } } else { var stackSeries = m_Series.GetStackSeries(); int seriesCount = stackSeries.Count; float scaleWid = m_XAxis.GetDataWidth(coordinateWid, m_DataZoom); float barWid = m_Bar.barWidth > 1 ? m_Bar.barWidth : scaleWid * m_Bar.barWidth; float offset = m_Bar.inSameBar ? (scaleWid - barWid - m_Bar.space * (seriesCount - 1)) / 2 : (scaleWid - barWid * seriesCount - m_Bar.space * (seriesCount - 1)) / 2; int serieCount = 0; for (int j = 0; j < seriesCount; j++) { var seriesCurrHig = new Dictionary <int, float>(); var serieList = stackSeries[j]; for (int n = 0; n < serieList.Count; n++) { Serie serie = serieList[n]; if (!m_Legend.IsActive(serie.name)) { continue; } Color color = m_ThemeInfo.GetColor(serieCount); List <float> showData = serie.GetData(m_DataZoom); int maxCount = maxShowDataNumber > 0 ? (maxShowDataNumber > showData.Count ? showData.Count : maxShowDataNumber) : showData.Count; for (int i = minShowDataNumber; i < maxCount; i++) { if (!seriesCurrHig.ContainsKey(i)) { seriesCurrHig[i] = 0; } float value = showData[i]; float pX = zeroX + i * scaleWid; if (!m_XAxis.boundaryGap) { pX -= scaleWid / 2; } float pY = seriesCurrHig[i] + zeroY + m_Coordinate.tickness; float barHig = value / (maxValue - minValue) * coordinateHig; seriesCurrHig[i] += barHig; float space = m_Bar.inSameBar ? offset : offset + j * (barWid + m_Bar.space); Vector3 p1 = new Vector3(pX + space, pY); Vector3 p2 = new Vector3(pX + space, pY + barHig); Vector3 p3 = new Vector3(pX + space + barWid, pY + barHig); Vector3 p4 = new Vector3(pX + space + barWid, pY); if (serie.show) { ChartHelper.DrawPolygon(vh, p1, p2, p3, p4, color); } } if (serie.show) { serieCount++; } } } if (m_Tooltip.show && m_Tooltip.dataIndex > 0) { if (m_Tooltip.crossLabel) { Vector3 sp = new Vector2(zeroX, m_Tooltip.pointerPos.y); Vector3 ep = new Vector2(zeroX + coordinateWid, m_Tooltip.pointerPos.y); DrawSplitLine(vh, true, Axis.SplitLineType.Dashed, sp, ep, m_ThemeInfo.tooltipLineColor); float splitWidth = m_XAxis.GetSplitWidth(coordinateWid, m_DataZoom); float px = zeroX + (m_Tooltip.dataIndex - 1) * splitWidth + (m_XAxis.boundaryGap ? splitWidth / 2 : 0); sp = new Vector2(px, coordinateY); ep = new Vector2(px, coordinateY + coordinateHig); DrawSplitLine(vh, false, Axis.SplitLineType.Dashed, sp, ep, m_ThemeInfo.tooltipLineColor); } else { float tooltipSplitWid = scaleWid < 1 ? 1 : scaleWid; float pX = coordinateX + scaleWid * (m_Tooltip.dataIndex - 1) - (m_XAxis.boundaryGap ? 0 : scaleWid / 2); float pY = coordinateY + coordinateHig; Vector3 p1 = new Vector3(pX, coordinateY); Vector3 p2 = new Vector3(pX, pY); Vector3 p3 = new Vector3(pX + tooltipSplitWid, pY); Vector3 p4 = new Vector3(pX + tooltipSplitWid, coordinateY); ChartHelper.DrawPolygon(vh, p1, p2, p3, p4, m_ThemeInfo.tooltipFlagAreaColor); } } } }
private void DrawXLineSerie(VertexHelper vh, int serieIndex, Color color, Serie serie, ref int dataCount, ref List <Vector3> points, ref List <int> pointSerieIndexs, ref List <float> seriesHig) { if (!IsActive(serie.index)) { return; } lastPoints.Clear(); lastSmoothPoints.Clear(); smoothPoints.Clear(); List <float> yData = serie.GetYDataList(m_DataZoom); List <float> xData = serie.GetXDataList(m_DataZoom); Vector3 lp = Vector3.zero; Vector3 np = Vector3.zero; var yAxis = m_YAxises[serie.axisIndex]; var xAxis = m_XAxises[serie.axisIndex]; if (!xAxis.show) { xAxis = m_XAxises[(serie.axisIndex + 1) % m_XAxises.Count]; } float scaleWid = xAxis.GetDataWidth(coordinateWid, m_DataZoom); float startX = coordinateX + (xAxis.boundaryGap ? scaleWid / 2 : 0); int maxCount = maxShowDataNumber > 0 ? (maxShowDataNumber > yData.Count ? yData.Count : maxShowDataNumber) : yData.Count; dataCount = (maxCount - minShowDataNumber); if (m_Line.area && points.Count > 0) { if (!m_Line.smooth && points.Count > 0) { for (int m = points.Count - dataCount; m < points.Count; m++) { lastPoints.Add(points[m]); } } else if (m_Line.smooth && smoothPoints.Count > 0) { for (int m = 0; m < smoothPoints.Count; m++) { lastSmoothPoints.Add(smoothPoints[m]); } smoothPoints.Clear(); } } int smoothPointCount = 1; if (seriesHig.Count < minShowDataNumber) { for (int i = 0; i < minShowDataNumber; i++) { seriesHig.Add(0); } } for (int i = minShowDataNumber; i < maxCount; i++) { if (i >= seriesHig.Count) { seriesHig.Add(0); } float yValue = yData[i]; float yDataHig; if (xAxis.IsValue()) { float xValue = i > xData.Count - 1 ? 0 : xData[i]; float pX = coordinateX + m_Coordinate.tickness; float pY = seriesHig[i] + coordinateY + m_Coordinate.tickness; float xDataHig = (xValue - xAxis.minValue) / (xAxis.maxValue - xAxis.minValue) * coordinateWid; yDataHig = (yValue - yAxis.minValue) / (yAxis.maxValue - yAxis.minValue) * coordinateHig; np = new Vector3(pX + xDataHig, pY + yDataHig); } else { float pX = startX + i * scaleWid; float pY = seriesHig[i] + coordinateY + m_Coordinate.tickness; yDataHig = (yValue - yAxis.minValue) / (yAxis.maxValue - yAxis.minValue) * coordinateHig; np = new Vector3(pX, pY + yDataHig); } if (i > 0) { if (m_Line.step) { Vector2 middle1, middle2; switch (m_Line.stepTpe) { case Line.StepType.Start: middle1 = new Vector2(lp.x, np.y + m_Line.tickness); middle2 = new Vector2(lp.x - m_Line.tickness, np.y); ChartHelper.DrawLine(vh, lp, middle1, m_Line.tickness, color); ChartHelper.DrawLine(vh, middle2, np, m_Line.tickness, color); if (m_Line.area) { Color areaColor = new Color(color.r, color.g, color.b, color.a * 0.75f); ChartHelper.DrawPolygon(vh, new Vector2(middle1.x, coordinateY), middle1, np, new Vector2(np.x, coordinateY), areaColor); } break; case Line.StepType.Middle: middle1 = new Vector2((lp.x + np.x) / 2 + m_Line.tickness, lp.y); middle2 = new Vector2((lp.x + np.x) / 2 - m_Line.tickness, np.y); ChartHelper.DrawLine(vh, lp, middle1, m_Line.tickness, color); ChartHelper.DrawLine(vh, new Vector2(middle1.x - m_Line.tickness, middle1.y), new Vector2(middle2.x + m_Line.tickness, middle2.y), m_Line.tickness, color); ChartHelper.DrawLine(vh, middle2, np, m_Line.tickness, color); if (m_Line.area) { Color areaColor = new Color(color.r, color.g, color.b, color.a * 0.75f); ChartHelper.DrawPolygon(vh, new Vector2(lp.x, coordinateY), lp, middle1, new Vector2(middle1.x, coordinateY), areaColor); ChartHelper.DrawPolygon(vh, new Vector2(middle2.x + 2 * m_Line.tickness, coordinateY), new Vector2(middle2.x + 2 * m_Line.tickness, middle2.y), np, new Vector2(np.x, coordinateY), areaColor); } break; case Line.StepType.End: middle1 = new Vector2(np.x + m_Line.tickness, lp.y); middle2 = new Vector2(np.x, lp.y); ChartHelper.DrawLine(vh, lp, middle1, m_Line.tickness, color); ChartHelper.DrawLine(vh, middle2, np, m_Line.tickness, color); if (m_Line.area) { Color areaColor = new Color(color.r, color.g, color.b, color.a * 0.75f); ChartHelper.DrawPolygon(vh, new Vector2(lp.x, coordinateY), lp, new Vector2(middle1.x - m_Line.tickness, middle1.y), new Vector2(middle1.x - m_Line.tickness, coordinateY), areaColor); } break; } } else if (m_Line.smooth) { if (xAxis.IsValue()) { ChartHelper.GetBezierListVertical(ref smoothSegmentPoints, lp, np, m_Line.smoothStyle); } else { ChartHelper.GetBezierList(ref smoothSegmentPoints, lp, np, m_Line.smoothStyle); } Vector3 start, to; start = smoothSegmentPoints[0]; for (int k = 1; k < smoothSegmentPoints.Count; k++) { smoothPoints.Add(smoothSegmentPoints[k]); to = smoothSegmentPoints[k]; ChartHelper.DrawLine(vh, start, to, m_Line.tickness, color); if (m_Line.area) { Vector3 alp = new Vector3(start.x, start.y - m_Line.tickness); Vector3 anp = new Vector3(to.x, to.y - m_Line.tickness); Vector3 tnp = serieIndex > 0 ? (smoothPointCount > lastSmoothPoints.Count - 1 ? new Vector3(lastSmoothPoints[lastSmoothPoints.Count - 1].x, lastSmoothPoints[lastSmoothPoints.Count - 1].y + m_Line.tickness) : new Vector3(lastSmoothPoints[smoothPointCount].x, lastSmoothPoints[smoothPointCount].y + m_Line.tickness)) : new Vector3(to.x, coordinateY + m_Coordinate.tickness); Vector3 tlp = serieIndex > 0 ? (smoothPointCount > lastSmoothPoints.Count - 1 ? new Vector3(lastSmoothPoints[lastSmoothPoints.Count - 2].x, lastSmoothPoints[lastSmoothPoints.Count - 2].y + m_Line.tickness) : new Vector3(lastSmoothPoints[smoothPointCount - 1].x, lastSmoothPoints[smoothPointCount - 1].y + m_Line.tickness)) : new Vector3(start.x, coordinateY + m_Coordinate.tickness); Color areaColor = new Color(color.r, color.g, color.b, color.a * 0.75f); ChartHelper.DrawPolygon(vh, alp, anp, tnp, tlp, areaColor); } smoothPointCount++; start = to; } } else { ChartHelper.DrawLine(vh, lp, np, m_Line.tickness, color); if (m_Line.area) { Vector3 alp = new Vector3(lp.x, lp.y - m_Line.tickness); Vector3 anp = new Vector3(np.x, np.y - m_Line.tickness); Color areaColor = new Color(color.r, color.g, color.b, color.a * 0.75f); var cross = ChartHelper.GetIntersection(lp, np, new Vector3(coordinateX, coordinateY), new Vector3(coordinateX + coordinateWid, coordinateY)); if (cross == Vector3.zero) { Vector3 tnp = serieIndex > 0 ? new Vector3(lastPoints[i].x, lastPoints[i].y + m_Line.tickness) : new Vector3(np.x, coordinateY + m_Coordinate.tickness); Vector3 tlp = serieIndex > 0 ? new Vector3(lastPoints[i - 1].x, lastPoints[i - 1].y + m_Line.tickness) : new Vector3(lp.x, coordinateY + m_Coordinate.tickness); ChartHelper.DrawPolygon(vh, alp, anp, tnp, tlp, areaColor); } else { Vector3 cross1 = new Vector3(cross.x, cross.y + (alp.y > coordinateY ? m_Coordinate.tickness : -m_Coordinate.tickness)); Vector3 cross2 = new Vector3(cross.x, cross.y + (anp.y > coordinateY ? m_Coordinate.tickness : -m_Coordinate.tickness)); Vector3 xp1 = new Vector3(alp.x, coordinateY + (alp.y > coordinateY ? m_Coordinate.tickness : -m_Coordinate.tickness)); Vector3 xp2 = new Vector3(anp.x, coordinateY + (anp.y > coordinateY ? m_Coordinate.tickness : -m_Coordinate.tickness)); ChartHelper.DrawTriangle(vh, alp, cross1, xp1, areaColor); ChartHelper.DrawTriangle(vh, anp, cross2, xp2, areaColor); } } } } if (serie.symbol.type != SerieSymbolType.None || m_Line.area) { points.Add(np); pointSerieIndexs.Add(serie.index); } seriesHig[i] += yDataHig; lp = np; } }
private void DrawStackArea(VertexHelper vh, Serie serie, Axis axis, List <Vector3> smoothPoints, List <Vector3> lastSmoothPoints, Color lineColor, Color areaColor, Color areaToColor) { if (!serie.areaStyle.show || lastSmoothPoints.Count <= 0) { return; } Vector3 start, to; var isYAxis = axis is YAxis; var lastCount = 1; start = smoothPoints[0]; for (int k = 1; k < smoothPoints.Count; k++) { to = smoothPoints[k]; Vector3 tnp, tlp; if (k == smoothPoints.Count - 1) { if (k < lastSmoothPoints.Count - 1) { tnp = lastSmoothPoints[lastCount - 1]; ChartHelper.DrawTriangle(vh, start, to, tnp, areaColor, areaColor, areaToColor); while (lastCount < lastSmoothPoints.Count) { tlp = lastSmoothPoints[lastCount]; ChartHelper.DrawTriangle(vh, tnp, to, tlp, areaToColor, areaColor, areaToColor); lastCount++; tnp = tlp; } start = to; continue; } } if (lastCount >= lastSmoothPoints.Count) { tlp = lastSmoothPoints[lastSmoothPoints.Count - 1]; ChartHelper.DrawTriangle(vh, to, start, tlp, areaColor, areaColor, areaToColor); start = to; continue; } tnp = lastSmoothPoints[lastCount]; var diff = isYAxis ? tnp.y - to.y : tnp.x - to.x; if (Math.Abs(diff) < 1) { tlp = lastSmoothPoints[lastCount - 1]; ChartHelper.DrawPolygon(vh, start, to, tnp, tlp, areaColor, areaToColor); lastCount++; } else { if (diff < 0) { tnp = lastSmoothPoints[lastCount - 1]; ChartHelper.DrawTriangle(vh, start, to, tnp, areaColor, areaColor, areaToColor); while (diff < 0 && lastCount < lastSmoothPoints.Count) { tlp = lastSmoothPoints[lastCount]; ChartHelper.DrawTriangle(vh, tnp, to, tlp, areaToColor, areaColor, areaToColor); lastCount++; diff = isYAxis ? tlp.y - to.y : tlp.x - to.x; tnp = tlp; } } else { tlp = lastSmoothPoints[lastCount - 1]; ChartHelper.DrawTriangle(vh, start, to, tlp, areaColor, areaColor, areaToColor); } } start = to; } if (lastCount < lastSmoothPoints.Count) { var p1 = lastSmoothPoints[lastCount - 1]; var p2 = lastSmoothPoints[lastSmoothPoints.Count - 1]; ChartHelper.DrawTriangle(vh, p1, start, p2, areaToColor, areaColor, areaToColor); } }
private void DrawStepLine(VertexHelper vh, int serieIndex, Serie serie, Axis axis, Vector3 lp, Vector3 np, int dataIndex, Color lineColor, Color areaColor, Vector3 zeroPos) { bool isYAxis = axis is YAxis; float lineWidth = serie.lineStyle.width; Vector2 middle1, middle2, p1, p2, p4; switch (serie.lineType) { case LineType.StepStart: middle1 = isYAxis ? new Vector2(np.x, lp.y) : new Vector2(lp.x, np.y + lineWidth); middle2 = isYAxis ? new Vector2(np.x, lp.y - lineWidth) : new Vector2(lp.x - lineWidth, np.y); ChartHelper.DrawLine(vh, lp, middle1, lineWidth, lineColor); ChartHelper.DrawLine(vh, middle2, np, lineWidth, lineColor); if (serie.areaStyle.show) { p1 = isYAxis ? new Vector2(zeroPos.x, middle1.y) : new Vector2(middle1.x, zeroPos.y); p4 = isYAxis ? new Vector2(zeroPos.x, np.y) : new Vector2(np.x, zeroPos.y); ChartHelper.DrawPolygon(vh, p1, middle1, np, p4, areaColor); } break; case LineType.StepMiddle: middle1 = isYAxis ? new Vector2(lp.x, (lp.y + np.y) / 2 + lineWidth) : new Vector2((lp.x + np.x) / 2 + lineWidth, lp.y); middle2 = isYAxis ? new Vector2(np.x, (lp.y + np.y) / 2 - lineWidth) : new Vector2((lp.x + np.x) / 2 - lineWidth, np.y); p1 = isYAxis ? new Vector2(middle1.x, middle1.y - lineWidth) : new Vector2(middle1.x - lineWidth, middle1.y); p2 = isYAxis ? new Vector2(middle2.x, middle2.y + lineWidth) : new Vector2(middle2.x + lineWidth, middle2.y); ChartHelper.DrawLine(vh, lp, middle1, lineWidth, lineColor); ChartHelper.DrawLine(vh, p1, p2, lineWidth, lineColor); ChartHelper.DrawLine(vh, middle2, np, lineWidth, lineColor); if (serie.areaStyle.show) { if (isYAxis) { ChartHelper.DrawPolygon(vh, new Vector2(zeroPos.x, lp.y), lp, middle1, new Vector2(zeroPos.x, middle1.y), areaColor); ChartHelper.DrawPolygon(vh, new Vector2(zeroPos.x, middle2.y + 2 * lineWidth), new Vector2(middle2.x, middle2.y + 2 * lineWidth), np, new Vector2(zeroPos.x, np.y), areaColor); } else { ChartHelper.DrawPolygon(vh, new Vector2(lp.x, zeroPos.y), lp, middle1, new Vector2(middle1.x, zeroPos.y), areaColor); ChartHelper.DrawPolygon(vh, new Vector2(middle2.x + 2 * lineWidth, zeroPos.y), new Vector2(middle2.x + 2 * lineWidth, middle2.y), np, new Vector2(np.x, zeroPos.y), areaColor); } } break; case LineType.StepEnd: middle1 = isYAxis ? new Vector2(np.x, lp.y) : new Vector2(np.x + lineWidth, lp.y); middle2 = isYAxis ? new Vector2(np.x, lp.y - serie.lineStyle.width) : new Vector2(np.x, lp.y); ChartHelper.DrawLine(vh, lp, middle1, lineWidth, lineColor); ChartHelper.DrawLine(vh, middle2, np, lineWidth, lineColor); if (serie.areaStyle.show) { if (isYAxis) { ChartHelper.DrawPolygon(vh, new Vector2(zeroPos.x, lp.y), middle1, new Vector2(np.x, np.y), new Vector2(zeroPos.x, np.y), areaColor); } else { ChartHelper.DrawPolygon(vh, new Vector2(lp.x, zeroPos.y), lp, new Vector2(middle1.x - lineWidth, middle1.y), new Vector2(middle1.x - lineWidth, zeroPos.y), areaColor); } } break; } }
private void DrawYLineSerie(VertexHelper vh, int serieIndex, Serie serie, ref int dataCount, ref List <Vector3> points, ref List <Color> colors, ref Dictionary <int, float> seriesHig) { if (!IsActive(serie.name)) { return; } List <Vector3> lastPoints = new List <Vector3>(); List <Vector3> lastSmoothPoints = new List <Vector3>(); List <Vector3> smoothPoints = new List <Vector3>(); Color color = m_ThemeInfo.GetColor(serieIndex); Vector3 lp = Vector3.zero; Vector3 np = Vector3.zero; var xAxis = m_XAxises[serie.axisIndex]; var yAxis = m_YAxises[serie.axisIndex]; if (!yAxis.show) { yAxis = m_YAxises[(serie.axisIndex + 1) % m_YAxises.Count]; } float scaleWid = yAxis.GetDataWidth(coordinateHig, m_DataZoom); float startY = coordinateY + (yAxis.boundaryGap ? scaleWid / 2 : 0); int maxCount = maxShowDataNumber > 0 ? (maxShowDataNumber > serie.yData.Count ? serie.yData.Count : maxShowDataNumber) : serie.yData.Count; dataCount = (maxCount - minShowDataNumber); if (m_Line.area && points.Count > 0) { if (!m_Line.smooth && points.Count > 0) { for (int m = points.Count - dataCount; m < points.Count; m++) { lastPoints.Add(points[m]); } } else if (m_Line.smooth && smoothPoints.Count > 0) { for (int m = 0; m < smoothPoints.Count; m++) { lastSmoothPoints.Add(smoothPoints[m]); } smoothPoints.Clear(); } } int smoothPointCount = 1; for (int i = minShowDataNumber; i < maxCount; i++) { if (!seriesHig.ContainsKey(i)) { seriesHig[i] = 0; } float value = serie.yData[i]; float pY = startY + i * scaleWid; float pX = seriesHig[i] + coordinateX + m_Coordinate.tickness; float dataHig = (value - xAxis.minValue) / (xAxis.maxValue - xAxis.minValue) * coordinateWid; np = new Vector3(pX + dataHig, pY); if (i > 0) { if (m_Line.step) { Vector2 middle1, middle2; switch (m_Line.stepTpe) { case Line.StepType.Start: middle1 = new Vector2(np.x, lp.y); middle2 = new Vector2(np.x, lp.y - m_Line.tickness); ChartHelper.DrawLine(vh, lp, middle1, m_Line.tickness, color); ChartHelper.DrawLine(vh, middle2, np, m_Line.tickness, color); if (m_Line.area) { Color areaColor = new Color(color.r, color.g, color.b, color.a * 0.75f); ChartHelper.DrawPolygon(vh, new Vector2(coordinateX, middle1.y), middle1, np, new Vector2(coordinateX, np.y), areaColor); } break; case Line.StepType.Middle: middle1 = new Vector2(lp.x, (lp.y + np.y) / 2 + m_Line.tickness); middle2 = new Vector2(np.x, (lp.y + np.y) / 2 - m_Line.tickness); ChartHelper.DrawLine(vh, lp, middle1, m_Line.tickness, color); ChartHelper.DrawLine(vh, new Vector2(middle1.x, middle1.y - m_Line.tickness), new Vector2(middle2.x, middle2.y + m_Line.tickness), m_Line.tickness, color); ChartHelper.DrawLine(vh, middle2, np, m_Line.tickness, color); if (m_Line.area) { Color areaColor = new Color(color.r, color.g, color.b, color.a * 0.75f); ChartHelper.DrawPolygon(vh, new Vector2(coordinateX, lp.y), lp, middle1, new Vector2(coordinateX, middle1.y), areaColor); ChartHelper.DrawPolygon(vh, new Vector2(coordinateX, middle2.y + 2 * m_Line.tickness), new Vector2(middle2.x, middle2.y + 2 * m_Line.tickness), np, new Vector2(coordinateX, np.y), areaColor); } break; case Line.StepType.End: middle1 = new Vector2(np.x, lp.y); middle2 = new Vector2(np.x, lp.y - m_Line.tickness); ChartHelper.DrawLine(vh, lp, middle1, m_Line.tickness, color); ChartHelper.DrawLine(vh, middle2, np, m_Line.tickness, color); if (m_Line.area) { Color areaColor = new Color(color.r, color.g, color.b, color.a * 0.75f); ChartHelper.DrawPolygon(vh, new Vector2(coordinateX, lp.y), middle1, new Vector2(np.x, np.y), new Vector2(coordinateX, np.y), areaColor); } break; } } else if (m_Line.smooth) { var list = ChartHelper.GetBezierListVertical(lp, np, m_Line.smoothStyle); Vector3 start, to; start = list[0]; for (int k = 1; k < list.Length; k++) { smoothPoints.Add(list[k]); to = list[k]; ChartHelper.DrawLine(vh, start, to, m_Line.tickness, color); if (m_Line.area) { Vector3 alp = new Vector3(start.x, start.y - m_Line.tickness); Vector3 anp = new Vector3(to.x, to.y - m_Line.tickness); Vector3 tnp = serieIndex > 0 ? (smoothPointCount > lastSmoothPoints.Count - 1 ? new Vector3(lastSmoothPoints[lastSmoothPoints.Count - 1].x, lastSmoothPoints[lastSmoothPoints.Count - 1].y + m_Line.tickness) : new Vector3(lastSmoothPoints[smoothPointCount].x, lastSmoothPoints[smoothPointCount].y + m_Line.tickness)) : new Vector3(coordinateX + m_Coordinate.tickness, to.y); Vector3 tlp = serieIndex > 0 ? (smoothPointCount > lastSmoothPoints.Count - 1 ? new Vector3(lastSmoothPoints[lastSmoothPoints.Count - 2].x, lastSmoothPoints[lastSmoothPoints.Count - 2].y + m_Line.tickness) : new Vector3(lastSmoothPoints[smoothPointCount - 1].x, lastSmoothPoints[smoothPointCount - 1].y + m_Line.tickness)) : new Vector3(coordinateX + m_Coordinate.tickness, start.y); Color areaColor = new Color(color.r, color.g, color.b, color.a * 0.75f); ChartHelper.DrawPolygon(vh, alp, anp, tnp, tlp, areaColor); } smoothPointCount++; start = to; } } else { ChartHelper.DrawLine(vh, lp, np, m_Line.tickness, color); if (m_Line.area) { Vector3 alp = new Vector3(lp.x, lp.y - m_Line.tickness); Vector3 anp = new Vector3(np.x, np.y - m_Line.tickness); Color areaColor = new Color(color.r, color.g, color.b, color.a * 0.75f); var cross = ChartHelper.GetIntersection(lp, np, new Vector3(coordinateX, coordinateY), new Vector3(coordinateX, coordinateY + coordinateHig)); if (cross == Vector3.zero) { Vector3 tnp = serieIndex > 0 ? new Vector3(lastPoints[i].x, lastPoints[i].y + m_Line.tickness) : new Vector3(coordinateX + m_Coordinate.tickness, np.y); Vector3 tlp = serieIndex > 0 ? new Vector3(lastPoints[i - 1].x, lastPoints[i - 1].y + m_Line.tickness) : new Vector3(coordinateX + m_Coordinate.tickness, lp.y); ChartHelper.DrawPolygon(vh, alp, anp, tnp, tlp, areaColor); } else { Vector3 cross1 = new Vector3(cross.x + (alp.x > coordinateX ? m_Coordinate.tickness : -m_Coordinate.tickness), cross.y); Vector3 cross2 = new Vector3(cross.x + (anp.x > coordinateX ? m_Coordinate.tickness : -m_Coordinate.tickness), cross.y); Vector3 xp1 = new Vector3(coordinateX + (alp.x > coordinateX ? m_Coordinate.tickness : -m_Coordinate.tickness), alp.y); Vector3 xp2 = new Vector3(coordinateX + (anp.x > coordinateX ? m_Coordinate.tickness : -m_Coordinate.tickness), anp.y); ChartHelper.DrawTriangle(vh, alp, cross1, xp1, areaColor); ChartHelper.DrawTriangle(vh, anp, cross2, xp2, areaColor); } } } } if (m_Line.point) { points.Add(np); colors.Add(color); } seriesHig[i] += dataHig; lp = np; } }
private void DrawYLineSerie(VertexHelper vh, int serieIndex, Color lineColor, Serie serie, ref List <float> seriesHig) { if (!IsActive(serie.index)) { return; } var showData = serie.GetDataList(m_DataZoom); Vector3 lp = Vector3.zero; Vector3 np = Vector3.zero; Color areaColor = new Color(lineColor.r, lineColor.g, lineColor.b, lineColor.a * 0.75f); var xAxis = m_XAxises[serie.axisIndex]; var yAxis = m_YAxises[serie.axisIndex]; var lastSerie = m_Series.GetSerie(serieIndex - 1); var isStack = m_Series.IsStack(serie.stack); if (!yAxis.show) { yAxis = m_YAxises[(serie.axisIndex + 1) % m_YAxises.Count]; } float scaleWid = yAxis.GetDataWidth(coordinateHig, m_DataZoom); float startY = coordinateY + (yAxis.boundaryGap ? scaleWid / 2 : 0); int maxCount = maxShowDataNumber > 0 ? (maxShowDataNumber > showData.Count ? showData.Count : maxShowDataNumber) : showData.Count; if (seriesHig.Count < minShowDataNumber) { for (int i = 0; i < minShowDataNumber; i++) { seriesHig.Add(0); } } for (int i = minShowDataNumber; i < maxCount; i++) { if (i >= seriesHig.Count) { seriesHig.Add(0); } float value = showData[i].data[1]; float pY = startY + i * scaleWid; float pX = seriesHig[i] + coordinateX + yAxis.axisLine.width; float dataHig = (value - xAxis.minValue) / (xAxis.maxValue - xAxis.minValue) * coordinateWid; np = new Vector3(pX + dataHig, pY); if (i > 0) { if (m_Line.step) { Vector2 middle1, middle2; switch (m_Line.stepTpe) { case Line.StepType.Start: middle1 = new Vector2(np.x, lp.y); middle2 = new Vector2(np.x, lp.y - m_Line.tickness); ChartHelper.DrawLine(vh, lp, middle1, m_Line.tickness, lineColor); ChartHelper.DrawLine(vh, middle2, np, m_Line.tickness, lineColor); if (m_Line.area) { ChartHelper.DrawPolygon(vh, new Vector2(coordinateX, middle1.y), middle1, np, new Vector2(coordinateX, np.y), areaColor); } break; case Line.StepType.Middle: middle1 = new Vector2(lp.x, (lp.y + np.y) / 2 + m_Line.tickness); middle2 = new Vector2(np.x, (lp.y + np.y) / 2 - m_Line.tickness); ChartHelper.DrawLine(vh, lp, middle1, m_Line.tickness, lineColor); ChartHelper.DrawLine(vh, new Vector2(middle1.x, middle1.y - m_Line.tickness), new Vector2(middle2.x, middle2.y + m_Line.tickness), m_Line.tickness, lineColor); ChartHelper.DrawLine(vh, middle2, np, m_Line.tickness, lineColor); if (m_Line.area) { ChartHelper.DrawPolygon(vh, new Vector2(coordinateX, lp.y), lp, middle1, new Vector2(coordinateX, middle1.y), areaColor); ChartHelper.DrawPolygon(vh, new Vector2(coordinateX, middle2.y + 2 * m_Line.tickness), new Vector2(middle2.x, middle2.y + 2 * m_Line.tickness), np, new Vector2(coordinateX, np.y), areaColor); } break; case Line.StepType.End: middle1 = new Vector2(np.x, lp.y); middle2 = new Vector2(np.x, lp.y - m_Line.tickness); ChartHelper.DrawLine(vh, lp, middle1, m_Line.tickness, lineColor); ChartHelper.DrawLine(vh, middle2, np, m_Line.tickness, lineColor); if (m_Line.area) { ChartHelper.DrawPolygon(vh, new Vector2(coordinateX, lp.y), middle1, new Vector2(np.x, np.y), new Vector2(coordinateX, np.y), areaColor); } break; } } else if (m_Line.smooth) { DrawSmoothAreaPoints(vh, serieIndex, serie, yAxis, lp, np, i, lineColor, areaColor, isStack); } else { ChartHelper.DrawLine(vh, lp, np, m_Line.tickness, lineColor); if (m_Line.area) { Vector3 alp = new Vector3(lp.x, lp.y); Vector3 anp = new Vector3(np.x, np.y); var cross = ChartHelper.GetIntersection(lp, np, new Vector3(coordinateX, coordinateY), new Vector3(coordinateX, coordinateY + coordinateHig)); if (cross == Vector3.zero) { Vector3 tnp = serieIndex > 0 ? new Vector3(lastSerie.dataPoints[i].x + yAxis.axisLine.width, lastSerie.dataPoints[i].y) : new Vector3(coordinateX + yAxis.axisLine.width, np.y); Vector3 tlp = serieIndex > 0 ? new Vector3(lastSerie.dataPoints[i - 1].x + yAxis.axisLine.width, lastSerie.dataPoints[i - 1].y) : new Vector3(coordinateX + yAxis.axisLine.width, lp.y); ChartHelper.DrawPolygon(vh, alp, anp, tnp, tlp, areaColor); } else { Vector3 cross1 = new Vector3(cross.x + (alp.x > coordinateX ? yAxis.axisLine.width : -yAxis.axisLine.width), cross.y); Vector3 cross2 = new Vector3(cross.x + (anp.x > coordinateX ? yAxis.axisLine.width : -yAxis.axisLine.width), cross.y); Vector3 xp1 = new Vector3(coordinateX + (alp.x > coordinateX ? yAxis.axisLine.width : -yAxis.axisLine.width), alp.y); Vector3 xp2 = new Vector3(coordinateX + (anp.x > coordinateX ? yAxis.axisLine.width : -yAxis.axisLine.width), anp.y); ChartHelper.DrawTriangle(vh, alp, cross1, xp1, areaColor); ChartHelper.DrawTriangle(vh, anp, cross2, xp2, areaColor); } } } } serie.dataPoints.Add(np); seriesHig[i] += dataHig; lp = np; } }
private void DrawSmoothAreaPoints(VertexHelper vh, int serieIndex, Serie serie, Axis xAxis, Vector3 lp, Vector3 np, int dataIndex, Color lineColor, Color areaColor, bool isStack) { bool isYAxis = xAxis is YAxis; if (isYAxis) { ChartHelper.GetBezierListVertical(ref smoothSegmentPoints, lp, np, m_Line.smoothStyle); } else { ChartHelper.GetBezierList(ref smoothSegmentPoints, lp, np, m_Line.smoothStyle); } Vector3 start, to; start = smoothSegmentPoints[0]; var smoothPoints = serie.GetSmoothList(dataIndex, smoothSegmentPoints.Count); smoothPoints.Clear(); var lastSerie = m_Series.GetSerie(serie.index - 1); var lastSmoothPoints = lastSerie != null?lastSerie.GetSmoothList(dataIndex, smoothSegmentPoints.Count) : new List <Vector3>(); smoothPoints.Add(start); var lastCount = 1; for (int k = 1; k < smoothSegmentPoints.Count; k++) { smoothPoints.Add(smoothSegmentPoints[k]); to = smoothSegmentPoints[k]; ChartHelper.DrawLine(vh, start, to, m_Line.tickness, lineColor); if (m_Line.area) { Vector3 alp, anp, tnp, tlp; if (isYAxis) { alp = new Vector3(start.x - m_Line.tickness, start.y); anp = new Vector3(to.x - m_Line.tickness, to.y); } else { alp = new Vector3(start.x, start.y - m_Line.tickness); anp = new Vector3(to.x, to.y - m_Line.tickness); } if (serieIndex > 0 && isStack) { if (k == smoothSegmentPoints.Count - 1) { if (k < lastSmoothPoints.Count - 1) { tnp = lastSmoothPoints[lastCount - 1]; if (isYAxis) { tnp.x += m_Line.tickness; } else { tnp.y += m_Line.tickness; } ChartHelper.DrawTriangle(vh, alp, anp, tnp, areaColor); while (lastCount < lastSmoothPoints.Count) { tlp = lastSmoothPoints[lastCount]; if (isYAxis) { tlp.x += m_Line.tickness; } else { tlp.y += m_Line.tickness; } ChartHelper.DrawTriangle(vh, tnp, anp, tlp, areaColor); lastCount++; tnp = tlp; } start = to; continue; } } if (lastCount >= lastSmoothPoints.Count) { tlp = lastSmoothPoints[lastSmoothPoints.Count - 1]; if (isYAxis) { tlp.x += m_Line.tickness; } else { tlp.y += m_Line.tickness; } ChartHelper.DrawTriangle(vh, anp, alp, tlp, areaColor); start = to; continue; } if (isYAxis) { tnp = new Vector3(lastSmoothPoints[lastCount].x + m_Line.tickness, lastSmoothPoints[lastCount].y); } else { tnp = new Vector3(lastSmoothPoints[lastCount].x, lastSmoothPoints[lastCount].y + m_Line.tickness); } var diff = isYAxis ? tnp.y - to.y : tnp.x - to.x; if (Math.Abs(diff) < 1) { if (isYAxis) { tlp = new Vector3(lastSmoothPoints[lastCount - 1].x + m_Line.tickness, lastSmoothPoints[lastCount - 1].y); } else { tlp = new Vector3(lastSmoothPoints[lastCount - 1].x, lastSmoothPoints[lastCount - 1].y + m_Line.tickness); } ChartHelper.DrawPolygon(vh, alp, anp, tnp, tlp, areaColor); lastCount++; } else { if (diff < 0) { if (isYAxis) { tnp = new Vector3(lastSmoothPoints[lastCount - 1].x + m_Line.tickness, lastSmoothPoints[lastCount - 1].y); } else { tnp = new Vector3(lastSmoothPoints[lastCount - 1].x, lastSmoothPoints[lastCount - 1].y + m_Line.tickness); } ChartHelper.DrawTriangle(vh, alp, anp, tnp, areaColor); while (diff < 0 && lastCount < lastSmoothPoints.Count) { if (isYAxis) { tlp = new Vector3(lastSmoothPoints[lastCount].x + m_Line.tickness, lastSmoothPoints[lastCount].y); } else { tlp = new Vector3(lastSmoothPoints[lastCount].x, lastSmoothPoints[lastCount].y + m_Line.tickness); } ChartHelper.DrawTriangle(vh, tnp, anp, tlp, areaColor); lastCount++; diff = isYAxis ? tlp.y - to.y : tlp.x - to.x; tnp = tlp; } } else { if (isYAxis) { tlp = new Vector3(lastSmoothPoints[lastCount - 1].x + m_Line.tickness, lastSmoothPoints[lastCount - 1].y); } else { tlp = new Vector3(lastSmoothPoints[lastCount - 1].x, lastSmoothPoints[lastCount - 1].y + m_Line.tickness); } ChartHelper.DrawTriangle(vh, alp, anp, tlp, areaColor); } } } else { if (isYAxis) { tnp = new Vector3(coordinateX + xAxis.axisLine.width, to.y); tlp = new Vector3(coordinateX + xAxis.axisLine.width, start.y); } else { tnp = new Vector3(to.x, coordinateY + xAxis.axisLine.width); tlp = new Vector3(start.x, coordinateY + xAxis.axisLine.width); } ChartHelper.DrawPolygon(vh, alp, anp, tnp, tlp, areaColor); } } start = to; } }
private void DrawCoordinate(VertexHelper vh) { #region draw tick and splitline if (m_YAxis.show) { var scaleWidth = m_YAxis.GetScaleWidth(coordinateHig, m_DataZoom); var size = m_YAxis.GetScaleNumber(m_DataZoom); for (int i = 0; i < size; i++) { float pX = 0; float pY = coordinateY + i * scaleWidth; if (m_YAxis.boundaryGap && m_YAxis.axisTick.alignWithLabel) { pY -= scaleWidth / 2; } if (m_YAxis.splitArea.show && i < size - 1) { ChartHelper.DrawPolygon(vh, new Vector2(coordinateX, pY), new Vector2(coordinateX + coordinateWid, pY), new Vector2(coordinateX + coordinateWid, pY + scaleWidth), new Vector2(coordinateX, pY + scaleWidth), m_YAxis.splitArea.getColor(i)); } if (m_YAxis.axisTick.show) { pX += zeroX - (m_YAxis.axisTick.inside ? -m_YAxis.axisTick.length : m_YAxis.axisTick.length); ChartHelper.DrawLine(vh, new Vector3(zeroX, pY), new Vector3(pX, pY), m_Coordinate.tickness, m_ThemeInfo.axisLineColor); } if (m_YAxis.showSplitLine) { DrawSplitLine(vh, true, m_YAxis.splitLineType, new Vector3(coordinateX, pY), new Vector3(coordinateX + coordinateWid, pY), m_ThemeInfo.axisSplitLineColor); } } } if (m_XAxis.show) { var scaleWidth = m_XAxis.GetScaleWidth(coordinateWid, m_DataZoom); var size = m_XAxis.GetScaleNumber(m_DataZoom); for (int i = 0; i < size; i++) { float pX = coordinateX + i * scaleWidth; float pY = 0; if (m_XAxis.boundaryGap && m_XAxis.axisTick.alignWithLabel) { pX -= scaleWidth / 2; } if (m_XAxis.splitArea.show && i < size - 1) { ChartHelper.DrawPolygon(vh, new Vector2(pX, coordinateY), new Vector2(pX, coordinateY + coordinateHig), new Vector2(pX + scaleWidth, coordinateY + coordinateHig), new Vector2(pX + scaleWidth, coordinateY), m_XAxis.splitArea.getColor(i)); } if (m_XAxis.axisTick.show) { pY += zeroY + (m_XAxis.axisTick.inside ? m_XAxis.axisTick.length : -m_XAxis.axisTick.length); ChartHelper.DrawLine(vh, new Vector3(pX, zeroY), new Vector3(pX, pY), m_Coordinate.tickness, m_ThemeInfo.axisLineColor); } if (m_XAxis.showSplitLine) { DrawSplitLine(vh, false, m_XAxis.splitLineType, new Vector3(pX, coordinateY), new Vector3(pX, coordinateY + coordinateHig), m_ThemeInfo.axisSplitLineColor); } } } #endregion DrawXAxisLine(vh); DrawYAxisLine(vh); }
private void DrawXCategory(VertexHelper vh) { int seriesCount = m_Series.Count; float scaleWid = m_XAxis.GetDataWidth(coordinateWid); for (int j = 0; j < seriesCount; j++) { if (!IsActive(j)) continue; Serie serie = m_Series.series[j]; Color32 color = m_ThemeInfo.GetColor(j); Vector3 lp = Vector3.zero; Vector3 np = Vector3.zero; float startX = zeroX + (m_XAxis.boundaryGap ? scaleWid / 2 : 0); int maxCount = maxShowDataNumber > 0 ? (maxShowDataNumber > serie.data.Count ? serie.data.Count : maxShowDataNumber) : serie.data.Count; for (int i = minShowDataNumber; i < maxCount; i++) { float value = serie.data[i]; float dataHig = coordinateY + (value - minValue) / (maxValue - minValue) * coordinateHig; np = new Vector3(startX + i * scaleWid, dataHig); if (i > 0) { if (m_Line.smooth) { var list = ChartHelper.GetBezierList(lp, np, m_Line.smoothStyle); Vector3 start, to; start = list[0]; for (int k = 1; k < list.Length; k++) { to = list[k]; ChartHelper.DrawLine(vh, start, to, m_Line.tickness, color); start = to; } } else { ChartHelper.DrawLine(vh, lp, np, m_Line.tickness, color); if (m_Line.area) { ChartHelper.DrawPolygon(vh, lp, np, new Vector3(np.x, zeroY), new Vector3(lp.x, zeroY), color); } } } lp = np; } // draw point if (m_Line.point) { for (int i = 0; i < serie.data.Count; i++) { float value = serie.data[i]; float dataHig = coordinateY + (value - minValue) / (maxValue - minValue) * coordinateHig; Vector3 p = new Vector3(startX + i * scaleWid, dataHig); float pointWid = m_Line.pointWidth; if (m_Tooltip.show && i == m_Tooltip.dataIndex - 1) { pointWid = pointWid * 1.8f; } if (m_Theme == Theme.Dark) { ChartHelper.DrawCricle(vh, p, pointWid, color, (int)m_Line.pointWidth * 5); } else { ChartHelper.DrawCricle(vh, p, pointWid, Color.white); ChartHelper.DrawDoughnut(vh, p, pointWid - m_Line.tickness, pointWid, 0, 360, color); } } } } //draw tooltip line if (m_Tooltip.show && m_Tooltip.dataIndex > 0) { float splitWidth = m_XAxis.GetSplitWidth(coordinateWid); float px = zeroX + (m_Tooltip.dataIndex - 1) * splitWidth + (m_XAxis.boundaryGap ? splitWidth / 2 : 0); Vector2 sp = new Vector2(px, coordinateY); Vector2 ep = new Vector2(px, coordinateY + coordinateHig); ChartHelper.DrawLine(vh, sp, ep, m_Coordinate.tickness, m_ThemeInfo.tooltipFlagAreaColor); } }
private void DrawNormalLine(VertexHelper vh, int serieIndex, Serie serie, Axis axis, Vector3 lp, Vector3 np, Vector3 nnp, int dataIndex, Color lineColor, Color areaColor, Color areaToColor, Vector3 zeroPos) { bool isYAxis = axis is YAxis; var lastSerie = m_Series.GetLastStackSerie(serie); Vector3 dnPos, upPos1, upPos2, dir1v, dir2v; bool isDown; var dir1 = (np - lp).normalized; dir1v = Vector3.Cross(dir1, Vector3.forward).normalized *(isYAxis ? -1 : 1); float cut = 0; if (np != nnp) { var dir2 = (nnp - np).normalized; var dir3 = (dir1 + dir2).normalized; var normal = Vector3.Cross(dir1, dir2); isDown = isYAxis ? normal.z >= 0 : normal.z <= 0; var angle = (180 - Vector3.Angle(dir1, dir2)) * Mathf.Deg2Rad / 2; var diff = serie.lineStyle.width / Mathf.Sin(angle); cut = serie.lineStyle.width / Mathf.Tan(angle); var dirDp = Vector3.Cross(dir3, Vector3.forward).normalized *(isYAxis ? -1 : 1); dir2v = Vector3.Cross(dir2, Vector3.forward).normalized *(isYAxis ? -1 : 1); dnPos = np + (isDown ? dirDp : -dirDp) * diff; upPos1 = np + (isDown ? -dir1v : dir1v) * serie.lineStyle.width; upPos2 = np + (isDown ? -dir2v : dir2v) * serie.lineStyle.width; if (dataIndex == 1) { stPos1 = lp - dir1v * serie.lineStyle.width; stPos2 = lp + dir1v * serie.lineStyle.width; } if (isDown) { ChartHelper.DrawPolygon(vh, stPos1, upPos1, dnPos, stPos2, lineColor); ChartHelper.DrawTriangle(vh, upPos1, upPos2, dnPos, lineColor); } else { ChartHelper.DrawPolygon(vh, stPos1, dnPos, upPos1, stPos2, lineColor); ChartHelper.DrawTriangle(vh, dnPos, upPos2, upPos1, lineColor); } lastDir = dir1; } else { isDown = Vector3.Cross(dir1, lastDir).z <= 0; if (isYAxis) { isDown = !isDown; } dir1v = Vector3.Cross(dir1, Vector3.forward).normalized *(isYAxis ? -1 : 1); upPos1 = np - dir1v * serie.lineStyle.width; upPos2 = np + dir1v * serie.lineStyle.width; dnPos = isDown ? upPos2 : upPos1; ChartHelper.DrawPolygon(vh, stPos1, upPos1, upPos2, stPos2, lineColor); } var smoothPoints = serie.GetUpSmoothList(dataIndex); var smoothDownPoints = serie.GetDownSmoothList(dataIndex); var dist = Vector3.Distance(lp, np); var fine = m_Series.IsAnyGradientSerie(serie.stack); var tick = fine ? 3f : 30f; int segment = (int)(dist / tick); smoothPoints.Clear(); smoothDownPoints.Clear(); smoothPoints.Add(stPos1); smoothDownPoints.Add(stPos2); for (int i = 1; i < segment; i++) { var cp = lp + dir1 * dist * i / segment; var tp1 = cp - dir1v * serie.lineStyle.width; var tp2 = cp + dir1v * serie.lineStyle.width; if (isDown) { if (isYAxis) { if (tp1.y > lastDnPos.y || dataIndex == 1) { smoothPoints.Add(tp1); } if (tp2.y < dnPos.y) { smoothDownPoints.Add(tp2); } } else { if (tp1.x > lastDnPos.x || dataIndex == 1) { smoothPoints.Add(tp1); } if (tp2.x < dnPos.x || dataIndex == 1) { smoothDownPoints.Add(tp2); } } } else { if (isYAxis) { if (tp1.y < dnPos.y) { smoothPoints.Add(tp1); } if (tp2.y > lastDnPos.y || dataIndex == 1) { smoothDownPoints.Add(tp2); } } else { if (tp1.x < dnPos.x) { smoothPoints.Add(tp1); } if (tp2.x > lastDnPos.x || dataIndex == 1) { smoothDownPoints.Add(tp2); } } } } if (isDown) { smoothPoints.Add(upPos1); smoothPoints.Add(upPos2); smoothDownPoints.Add(dnPos); } else { smoothPoints.Add(dnPos); if (isYAxis) { smoothDownPoints.Add(np != nnp ? upPos1 : upPos2); smoothDownPoints.Add(np != nnp ? upPos2 : upPos1); } else { smoothDownPoints.Add(np != nnp ? upPos1 : upPos2); smoothDownPoints.Add(np != nnp ? upPos2 : upPos1); } } if (serie.areaStyle.show) { if (lastSerie != null) { var lastSmoothPoints = lastSerie.GetUpSmoothList(dataIndex); DrawStackArea(vh, serie, axis, smoothDownPoints, lastSmoothPoints, lineColor, areaColor, areaToColor); } else { Vector3 alp = new Vector3(lp.x, lp.y - serie.lineStyle.width); Vector3 anp = new Vector3(np.x, np.y - serie.lineStyle.width); Vector3 aep = isYAxis ? new Vector3(zeroPos.x, zeroPos.y + coordinateHig) : new Vector3(zeroPos.x + coordinateWid, zeroPos.y); var cross = ChartHelper.GetIntersection(lp, np, zeroPos, aep); if (cross == Vector3.zero) { var points = ((isYAxis && lp.x < zeroPos.x) || (!isYAxis && lp.y < zeroPos.y)) ? smoothPoints : smoothDownPoints; Vector3 sp = points[0]; Vector3 ep; for (int i = 1; i < points.Count; i++) { ep = points[i]; DrawPolygonToZero(vh, sp, ep, axis, zeroPos, areaColor, areaToColor); sp = ep; } } else { var sp1 = smoothDownPoints[1]; var ep1 = smoothDownPoints[smoothDownPoints.Count - 2]; var axisUpStart = zeroPos + (isYAxis ? Vector3.right : Vector3.up) * axis.axisLine.width; var axisUpEnd = axisUpStart + (isYAxis ? Vector3.up * coordinateHig : Vector3.right * coordinateWid); var axisDownStart = zeroPos - (isYAxis ? Vector3.right : Vector3.up) * axis.axisLine.width; var axisDownEnd = axisDownStart + (isYAxis ? Vector3.up * coordinateHig : Vector3.right * coordinateWid); var luPos = ChartHelper.GetIntersection(sp1, ep1, axisUpStart, axisUpEnd); var ldPos = ChartHelper.GetIntersection(sp1, ep1, axisDownStart, axisDownEnd); sp1 = smoothPoints[1]; ep1 = smoothPoints[smoothPoints.Count - 2]; var ruPos = ChartHelper.GetIntersection(sp1, ep1, axisUpStart, axisUpEnd); var rdPos = ChartHelper.GetIntersection(sp1, ep1, axisDownStart, axisDownEnd); Vector3 sp, ep; if ((isYAxis && lp.x > zeroPos.x) || (!isYAxis && lp.y > zeroPos.y)) { sp = smoothDownPoints[0]; for (int i = 1; i < smoothDownPoints.Count; i++) { ep = smoothDownPoints[i]; if ((isYAxis && ep.y > luPos.y) || (!isYAxis && ep.x > luPos.x)) { var tp = isYAxis ? new Vector3(luPos.x, sp.y) : new Vector3(sp.x, luPos.y); ChartHelper.DrawTriangle(vh, sp, luPos, tp, areaColor, areaToColor, areaToColor); break; } DrawPolygonToZero(vh, sp, ep, axis, zeroPos, areaColor, areaToColor); sp = ep; } sp = smoothPoints[smoothPoints.Count - 1]; for (int i = smoothPoints.Count - 2; i >= 0; i--) { ep = smoothPoints[i]; if ((isYAxis && ep.y > rdPos.y) || (!isYAxis && ep.x > rdPos.x)) { DrawPolygonToZero(vh, sp, ep, axis, zeroPos, areaColor, areaToColor); } else { var tp = isYAxis ? new Vector3(rdPos.x, sp.y) : new Vector3(sp.x, rdPos.y); ChartHelper.DrawTriangle(vh, sp, rdPos, tp, areaColor, areaToColor, areaToColor); break; } sp = ep; } } else { sp = smoothPoints[0]; for (int i = 1; i < smoothPoints.Count; i++) { ep = smoothPoints[i]; if ((isYAxis && ep.y > rdPos.y) || (!isYAxis && ep.x > rdPos.x)) { var tp = isYAxis ? new Vector3(rdPos.x, sp.y) : new Vector3(sp.x, rdPos.y); ChartHelper.DrawTriangle(vh, sp, rdPos, tp, areaColor, areaToColor, areaToColor); break; } DrawPolygonToZero(vh, sp, ep, axis, zeroPos, areaColor, areaToColor); sp = ep; } sp = smoothDownPoints[smoothDownPoints.Count - 1]; for (int i = smoothDownPoints.Count - 2; i >= 0; i--) { ep = smoothDownPoints[i]; if ((isYAxis && ep.y > luPos.y) || (!isYAxis && ep.x > luPos.x)) { DrawPolygonToZero(vh, sp, ep, axis, zeroPos, areaColor, areaToColor); } else { var tp = isYAxis ? new Vector3(luPos.x, sp.y) : new Vector3(sp.x, luPos.y); ChartHelper.DrawTriangle(vh, sp, luPos, tp, areaColor, areaToColor, areaToColor); break; } sp = ep; } } } } } stPos1 = isDown ? upPos2 : dnPos; stPos2 = isDown ? dnPos : upPos2; lastDnPos = dnPos; }
private void DrawSmoothLine(VertexHelper vh, int serieIndex, Serie serie, Axis xAxis, Vector3 lp, Vector3 np, int dataIndex, Color lineColor, Color areaColor, Color areaToColor, bool isStack, Vector3 zeroPos) { bool isYAxis = xAxis is YAxis; var lineWidth = serie.lineStyle.width; var smoothPoints = serie.GetUpSmoothList(dataIndex); var smoothDownPoints = serie.GetDownSmoothList(dataIndex); var fine = isStack && m_Series.IsAnyGradientSerie(serie.stack); if (isYAxis) { ChartHelper.GetBezierListVertical(ref bezierPoints, lp, np, fine, lineSmoothStyle); } else { ChartHelper.GetBezierList(ref bezierPoints, lp, np, fine, lineSmoothStyle); } Vector3 start, to; start = bezierPoints[0]; var dir = bezierPoints[1] - start; var dir1v = Vector3.Cross(dir, Vector3.forward).normalized; var startUp = start + (isYAxis ? Vector3.right : Vector3.up) * lineWidth; var startDn = start - (isYAxis ? Vector3.right : Vector3.up) * lineWidth; Vector3 toUp, toDn, tnp, tlp; smoothPoints.Add(startUp); smoothDownPoints.Add(startDn); for (int k = 1; k < bezierPoints.Count; k++) { to = bezierPoints[k]; dir = to - start; if (k < bezierPoints.Count - 1) { dir1v = Vector3.Cross(dir, Vector3.forward).normalized *(isYAxis ? -1 : 1); var diff = dir1v * lineWidth; toUp = to - diff; toDn = to + diff; if (isYAxis) { ChartHelper.DrawPolygon(vh, startDn, toDn, toUp, startUp, lineColor); } else { ChartHelper.DrawPolygon(vh, startUp, toUp, toDn, startDn, lineColor); } } else { toUp = to + (isYAxis ? Vector3.right : Vector3.up) * lineWidth; toDn = to - (isYAxis ? Vector3.right : Vector3.up) * lineWidth; if (isYAxis) { ChartHelper.DrawPolygon(vh, toDn, toUp, startUp, startDn, lineColor); } else { ChartHelper.DrawPolygon(vh, startUp, toUp, toDn, startDn, lineColor); } } smoothPoints.Add(toUp); smoothDownPoints.Add(toDn); if (serie.areaStyle.show && (serieIndex == 0 || !isStack)) { if (isYAxis) { if (start.x > zeroPos.x && to.x > zeroPos.x) { tnp = new Vector3(zeroPos.x + xAxis.axisLine.width, toDn.y); tlp = new Vector3(zeroPos.x + xAxis.axisLine.width, startDn.y); ChartHelper.DrawPolygon(vh, startDn, toDn, tnp, tlp, areaColor, areaToColor); } else if (start.x < zeroPos.x && to.x < zeroPos.x) { tnp = new Vector3(zeroPos.x - xAxis.axisLine.width, toUp.y); tlp = new Vector3(zeroPos.x - xAxis.axisLine.width, startUp.y); ChartHelper.DrawPolygon(vh, tnp, tlp, startUp, toUp, areaToColor, areaColor); } } else { if (start.y > zeroPos.y && to.y > zeroPos.y) { tnp = new Vector3(toDn.x, zeroPos.y + xAxis.axisLine.width); tlp = new Vector3(startDn.x, zeroPos.y + xAxis.axisLine.width); ChartHelper.DrawPolygon(vh, startDn, toDn, tnp, tlp, areaColor, areaToColor); } else if (start.y < zeroPos.y && to.y < zeroPos.y) { tnp = new Vector3(toUp.x, zeroPos.y - xAxis.axisLine.width); tlp = new Vector3(startUp.x, zeroPos.y - xAxis.axisLine.width); ChartHelper.DrawPolygon(vh, tlp, tnp, toUp, startUp, areaToColor, areaColor); } } } start = to; startUp = toUp; startDn = toDn; } if (serie.areaStyle.show) { var lastSerie = m_Series.GetLastStackSerie(serie); if (lastSerie != null) { var lastSmoothPoints = lastSerie.GetUpSmoothList(dataIndex); DrawStackArea(vh, serie, xAxis, smoothDownPoints, lastSmoothPoints, lineColor, areaColor, areaToColor); } } }
protected override void DrawChart(VertexHelper vh) { base.DrawChart(vh); if (m_YAxises[0].type == Axis.AxisType.Category) { var stackSeries = m_Series.GetStackSeries(); int seriesCount = stackSeries.Count; int serieCount = 0; for (int j = 0; j < seriesCount; j++) { var seriesHig = new Dictionary <int, float>(); var serieList = stackSeries[j]; for (int n = 0; n < serieList.Count; n++) { Serie serie = serieList[n]; Color color = m_ThemeInfo.GetColor(serieCount); DrawYBarSerie(vh, j, seriesCount, serie, color, ref seriesHig); if (serie.show) { serieCount++; } } } if (m_Tooltip.show && m_Tooltip.dataIndex > 0) { if (m_Tooltip.crossLabel) { for (int i = 0; i < m_YAxises.Count; i++) { var yAxis = m_YAxises[i]; if (!yAxis.show) { continue; } Vector3 sp = new Vector2(m_Tooltip.pointerPos.x, coordinateY); Vector3 ep = new Vector2(m_Tooltip.pointerPos.x, coordinateY + coordinateHig); DrawSplitLine(vh, false, Axis.SplitLineType.Dashed, sp, ep, m_ThemeInfo.tooltipLineColor); float splitWidth = yAxis.GetSplitWidth(coordinateHig, m_DataZoom); float pY = coordinateY + (m_Tooltip.yValues[i] - 1) * splitWidth + (yAxis.boundaryGap ? splitWidth / 2 : 0); sp = new Vector2(coordinateX, pY); ep = new Vector2(coordinateX + coordinateWid, pY); DrawSplitLine(vh, true, Axis.SplitLineType.Solid, sp, ep, m_ThemeInfo.tooltipLineColor); } } else { for (int i = 0; i < m_YAxises.Count; i++) { var yAxis = m_YAxises[i]; if (!yAxis.show) { continue; } float splitWidth = yAxis.GetSplitWidth(coordinateHig, m_DataZoom); float tooltipSplitWid = splitWidth < 1 ? 1 : splitWidth; float pX = coordinateX + coordinateWid; float pY = coordinateY + splitWidth * (m_Tooltip.yValues[i] - 1) - (yAxis.boundaryGap ? 0 : splitWidth / 2); Vector3 p1 = new Vector3(coordinateX, pY); Vector3 p2 = new Vector3(coordinateX, pY + tooltipSplitWid); Vector3 p3 = new Vector3(pX, pY + tooltipSplitWid); Vector3 p4 = new Vector3(pX, pY); ChartHelper.DrawPolygon(vh, p1, p2, p3, p4, m_ThemeInfo.tooltipFlagAreaColor); } } } } else { var stackSeries = m_Series.GetStackSeries(); int seriesCount = stackSeries.Count; int serieCount = 0; for (int j = 0; j < seriesCount; j++) { var seriesHig = new Dictionary <int, float>(); var serieList = stackSeries[j]; for (int n = 0; n < serieList.Count; n++) { Serie serie = serieList[n]; Color color = m_ThemeInfo.GetColor(serieCount); DrawXBarSerie(vh, j, seriesCount, serie, color, ref seriesHig); if (serie.show) { serieCount++; } } } if (m_Tooltip.show && m_Tooltip.dataIndex > 0) { if (m_Tooltip.crossLabel) { for (int i = 0; i < m_XAxises.Count; i++) { var xAxis = m_XAxises[i]; if (!xAxis.show) { continue; } Vector3 sp = new Vector2(coordinateX, m_Tooltip.pointerPos.y); Vector3 ep = new Vector2(coordinateX + coordinateWid, m_Tooltip.pointerPos.y); DrawSplitLine(vh, true, Axis.SplitLineType.Dashed, sp, ep, m_ThemeInfo.tooltipLineColor); float splitWidth = xAxis.GetSplitWidth(coordinateWid, m_DataZoom); float px = coordinateX + (m_Tooltip.xValues[i] - 1) * splitWidth + (xAxis.boundaryGap ? splitWidth / 2 : 0); sp = new Vector2(px, coordinateY); ep = new Vector2(px, coordinateY + coordinateHig); DrawSplitLine(vh, false, Axis.SplitLineType.Solid, sp, ep, m_ThemeInfo.tooltipLineColor); } } else { for (int i = 0; i < m_XAxises.Count; i++) { var xAxis = m_XAxises[i]; if (!xAxis.show) { continue; } float splitWidth = xAxis.GetSplitWidth(coordinateWid, m_DataZoom); float tooltipSplitWid = splitWidth < 1 ? 1 : splitWidth; float pX = coordinateX + splitWidth * (m_Tooltip.xValues[i] - 1) - (xAxis.boundaryGap ? 0 : splitWidth / 2); float pY = coordinateY + coordinateHig; Vector3 p1 = new Vector3(pX, coordinateY); Vector3 p2 = new Vector3(pX, pY); Vector3 p3 = new Vector3(pX + tooltipSplitWid, pY); Vector3 p4 = new Vector3(pX + tooltipSplitWid, coordinateY); ChartHelper.DrawPolygon(vh, p1, p2, p3, p4, m_ThemeInfo.tooltipFlagAreaColor); } } } } }
private void DrawYBarSerie(VertexHelper vh, int serieIndex, int stackCount, Serie serie, Color color, ref List <float> seriesHig) { if (!IsActive(serie.name)) { return; } var xAxis = m_XAxises[serie.axisIndex]; var yAxis = m_YAxises[serie.axisIndex]; if (!yAxis.show) { yAxis = m_YAxises[(serie.axisIndex + 1) % m_YAxises.Count]; } float scaleWid = yAxis.GetDataWidth(coordinateHig, m_DataZoom); float barWid = m_Bar.barWidth > 1 ? m_Bar.barWidth : scaleWid * m_Bar.barWidth; float offset = m_Bar.inSameBar ? (scaleWid - barWid - m_Bar.space * (stackCount - 1)) / 2 : (scaleWid - barWid * stackCount - m_Bar.space * (stackCount - 1)) / 2; var showData = serie.GetDataList(m_DataZoom); int maxCount = maxShowDataNumber > 0 ? (maxShowDataNumber > showData.Count ? showData.Count : maxShowDataNumber) : showData.Count; if (seriesHig.Count < minShowDataNumber) { for (int i = 0; i < minShowDataNumber; i++) { seriesHig.Add(0); } } for (int i = minShowDataNumber; i < maxCount; i++) { if (i >= seriesHig.Count) { seriesHig.Add(0); } float value = showData[i].data[1]; float pX = seriesHig[i] + coordinateX + xAxis.zeroXOffset + yAxis.axisLine.width; float pY = coordinateY + +i * scaleWid; if (!yAxis.boundaryGap) { pY -= scaleWid / 2; } float barHig = (xAxis.minValue > 0 ? value - xAxis.minValue : value) / (xAxis.maxValue - xAxis.minValue) * coordinateWid; float space = m_Bar.inSameBar ? offset : offset + serieIndex * (barWid + m_Bar.space); seriesHig[i] += barHig; Vector3 p1 = new Vector3(pX, pY + space + barWid); Vector3 p2 = new Vector3(pX + barHig, pY + space + barWid); Vector3 p3 = new Vector3(pX + barHig, pY + space); Vector3 p4 = new Vector3(pX, pY + space); if ((m_Tooltip.show && m_Tooltip.IsSelected(i)) || serie.data[i].highlighted || serie.highlighted) { color *= 1.05f; } if (serie.show) { ChartHelper.DrawPolygon(vh, p1, p2, p3, p4, color); } } }