private void ZoomAxisValueArea(NumberAxisValueArea result)
{
long minMuilt, maxMuilt;
if (ChartHelper.DoubleHasValue(this._minValue))
{
if (ChartHelper.DoubleHasValue(this._maxValue))
{
//不调整
}
else
{
maxMuilt = ChartHelper.CalDoubleToIntegerMuilt(result.Max);
result.Max = ChartHelper.DoubleToCeilingInteger(result.Max, maxMuilt);
}
}
else
{
minMuilt = ChartHelper.CalDoubleToIntegerMuilt(result.Min);
if (ChartHelper.DoubleHasValue(this._maxValue))
{
result.Min = ChartHelper.DoubleToFloorInteger(result.Min, minMuilt);
}
else
{
maxMuilt = ChartHelper.CalDoubleToIntegerMuilt(result.Max);
long muilt = minMuilt > maxMuilt ? minMuilt : maxMuilt;
result.Min = ChartHelper.DoubleToFloorInteger(result.Min, muilt);
result.Max = ChartHelper.DoubleToCeilingInteger(result.Max, muilt);
}
}
}
private double GetAxis(IChartItem item, bool x, double axisSize)
{
if (this._axisData == null)
{
return(double.NaN);
}
object obj = ChartHelper.GetChartItemAxisValue(item, x);
if (item == null)
{
return(double.NaN);
}
double value = ChartHelper.ConvertToDouble(obj);
if (!ChartHelper.DoubleHasValue(value))
{
return(double.NaN);
}
double result = axisSize * (value - this._axisData.MinValue) / this._axisData.Area;
if (base.Orientation == AxisLabelOrientation.BottomToTop ||
base.Orientation == AxisLabelOrientation.RightToLeft)
{
result = axisSize - result;
}
return(result);
}
public AngleQuadrantInfo(double angle, double pre)
{
this._rotate = ChartHelper.DoubleHasValue(angle);
if (!this._rotate)
{
return;
}
//将角度转换为-360到360度之间
angle = angle % MathEx.ANGLE_360;
if (angle < ChartConstant.ZERO_D)
{
//将负数角度转换为正数角度
angle += MathEx.ANGLE_360;
}
this._angle = angle;
//角度值无效或小于精度值,则认为不需要旋转
if (angle <= pre)
{
this._rotate = false;
return;
}
double mathAngle;
Quadrant quadrant;
if (angle - MathEx.ANGLE_270 > ChartConstant.ZERO_D)
{
//angle:270-360°
quadrant = Quadrant.One;
mathAngle = angle - MathEx.ANGLE_270;
this._modRadians = MathEx.AngleToRadians(MathEx.ANGLE_180 - MathEx.ANGLE_90 - mathAngle);
}
else if (angle - MathEx.ANGLE_180 > ChartConstant.ZERO_D)
{
//angle:180-270°
quadrant = Quadrant.Two;
mathAngle = angle - MathEx.ANGLE_180;
this._modRadians = MathEx.AngleToRadians(MathEx.ANGLE_360 - MathEx.ANGLE_90 - angle);
}
else if (angle - MathEx.ANGLE_90 > ChartConstant.ZERO_D)
{
//angle:90-180°
quadrant = Quadrant.Three;
mathAngle = angle - MathEx.ANGLE_90;
this._modRadians = MathEx.AngleToRadians(MathEx.ANGLE_270 - MathEx.ANGLE_90 - angle);
}
else
{
//angle:0-90°
quadrant = Quadrant.Four;
mathAngle = angle;
}
this._radians = MathEx.AngleToRadians(mathAngle);
this._quadrant = quadrant;
}
private bool AllowZoom()
{
if (ChartHelper.DoubleHasValue(this._zoomDelta) && this._zoomDelta > ChartConstant.ZERO_D)
{
return(true);
}
return(false);
}
private AxisYWidthInfo DrawAxisYByAxisXHeightInfo(ChartCollection <AxisAbs> axisCollection, UIElementCollection children,
ChartCollection <ISeries> seriesCollection, double yAxisHeight, double top)
{
if (!ChartHelper.DoubleHasValue(yAxisHeight) || yAxisHeight <= ChartConstant.ZERO_D)
{
return(new AxisYWidthInfo(ChartConstant.ZERO_D, ChartConstant.ZERO_D, null));
}
double leftAxisTotalWidth = ChartConstant.ZERO_D, rightAxisTotalWidth = ChartConstant.ZERO_D;
Dictionary <AxisAbs, List <double> > axisYLabelDic = null;
if (axisCollection != null && axisCollection.Count > ChartConstant.ZERO_I)
{
FrameworkElement axisYControl;
double axisLeft = ChartConstant.ZERO_D, axisRight = ChartConstant.ZERO_D;
List <double> yList;
foreach (var axis in axisCollection)
{
if (axis.AxisType != AxisType.Y)
{
continue;
}
yList = axis.DrawY(seriesCollection, yAxisHeight);
if (axis.EnableBackgroundLabelLine && yList != null)
{
if (axisYLabelDic == null)
{
axisYLabelDic = new Dictionary <AxisAbs, List <double> >();
}
axisYLabelDic.Add(axis, yList);
}
axisYControl = axis.AxisControl;
axisYControl.VerticalAlignment = VerticalAlignment.Top;
children.Add(axisYControl);
if (axis.IsAxisYLeft())
{
axisYControl.HorizontalAlignment = HorizontalAlignment.Left;
axisYControl.Margin = new Thickness(axisLeft, top, ChartConstant.ZERO_D, ChartConstant.ZERO_D);
leftAxisTotalWidth += axis.Width;
axisLeft += axis.Width;
}
else
{
axisYControl.HorizontalAlignment = HorizontalAlignment.Right;
axisYControl.Margin = new Thickness(ChartConstant.ZERO_D, top, axisRight, ChartConstant.ZERO_D);
rightAxisTotalWidth += axis.Width;
axisRight += axis.Width;
}
}
}
return(new AxisYWidthInfo(leftAxisTotalWidth, rightAxisTotalWidth, axisYLabelDic));
}
/// <summary>
/// 获取Y轴Label和文本之间的间隔
/// </summary>
/// <returns>Y轴Label和文本之间的间隔</returns>
protected double GetAxisYLabelTextLineInterval()
{
double interval = ChartConstant.LABEL_TEXT_INTERVAL;
if (ChartHelper.DoubleHasValue(this._labelSize) && this._labelSize > ChartConstant.ZERO_D)
{
interval = interval + this._labelSize;
}
return(interval);
}
/// <summary>
/// 计算X轴高度和Y轴宽度
/// </summary>
/// <param name="labelTextSize">Label文本X轴高度,Y轴宽度</param>
/// <returns></returns>
protected double CalculateAxisSize(double labelTextSize)
{
double axisSize = labelTextSize + ChartConstant.LABEL_TEXT_INTERVAL * 3;
if (ChartHelper.DoubleHasValue(this._labelSize) && this._labelSize > ChartConstant.ZERO_D)
{
axisSize = axisSize + this._labelSize;
}
return(axisSize);
}
private double CalculateSeriesSize(Dictionary <IColumnSeries, double> seriesSizeDic, double labelStepSize)
{
double totalSeriesSize = ChartConstant.ZERO_D;
int seriesAutoSizeCount = 0;
foreach (var seriesSize in seriesSizeDic.Values)
{
if (ChartHelper.DoubleHasValue(seriesSize))
{
totalSeriesSize += seriesSize;
}
else
{
seriesAutoSizeCount++;
}
}
if (seriesAutoSizeCount > 0)
{
double seriesAutoSize = ChartConstant.ZERO_D;
double availableSpace = labelStepSize - totalSeriesSize;
if (availableSpace >= base._PRE)
{
seriesAutoSize = availableSpace / (seriesAutoSizeCount + this._autoSizeFactor);
//计算固定大小的平均值
int fixSeriesSizeCount = seriesSizeDic.Count - seriesAutoSizeCount;
if (fixSeriesSizeCount > 0)
{
double avgSeriesSize = totalSeriesSize / fixSeriesSizeCount;
if (avgSeriesSize - seriesAutoSize < base._PRE)
{
//取固定大小平均值与可用空间自动计算值中的更小的值
seriesAutoSize = avgSeriesSize;
}
}
}
int index = -1;
foreach (var kv in seriesSizeDic)
{
index++;
if (ChartHelper.DoubleHasValue(kv.Value))
{
seriesAutoSize = kv.Value;
}
kv.Key.Size = seriesAutoSize;
totalSeriesSize += seriesAutoSize;
}
}
return((labelStepSize - totalSeriesSize) / 2);
}
private Dictionary <AxisAbs, List <double> > DrawAxisX(ChartCollection <AxisAbs> axisCollection, ChartCollection <ISeries> seriesCollection,
Grid chartGrid, double xAxisWidth, double left)
{
if (!ChartHelper.DoubleHasValue(xAxisWidth) || xAxisWidth <= ChartConstant.ZERO_D)
{
return(null);
}
Dictionary <AxisAbs, List <double> > axisXLabelDic = null;
bool hasAxis = axisCollection != null && axisCollection.Count > ChartConstant.ZERO_I;
if (hasAxis)
{
FrameworkElement axisXControl;
double axisTop = ChartConstant.ZERO_D, axisBottom = ChartConstant.ZERO_D;
List <double> xList;
foreach (var axis in axisCollection)
{
if (axis.AxisType != AxisType.X)
{
continue;
}
xList = axis.DrawX(seriesCollection, xAxisWidth);
if (axis.EnableBackgroundLabelLine && xList != null)
{
if (axisXLabelDic == null)
{
axisXLabelDic = new Dictionary <AxisAbs, List <double> >();
}
axisXLabelDic.Add(axis, xList);
}
axisXControl = axis.AxisControl;
axisXControl.HorizontalAlignment = HorizontalAlignment.Left;
chartGrid.Children.Add(axisXControl);
if (axis.IsAxisXBottom())
{
axisXControl.VerticalAlignment = VerticalAlignment.Top;
axisXControl.Margin = new Thickness(left, axisTop, ChartConstant.ZERO_D, ChartConstant.ZERO_D);
axisTop += axis.Height;
}
else
{
axisXControl.VerticalAlignment = VerticalAlignment.Bottom;
axisXControl.Margin = new Thickness(left, ChartConstant.ZERO_D, ChartConstant.ZERO_D, axisBottom);
axisBottom += axis.Height;
}
}
}
return(axisXLabelDic);
}
private void PrimitiveDrawHorizontal(Canvas canvas)
{
double x, y, size;
Rectangle columnElement;
foreach (var value in base._values)
{
x = this.AxisX.GetX(value);
if (!ChartHelper.DoubleHasValue(x))
{
continue;
}
y = this.AxisY.GetY(value);
if (!ChartHelper.DoubleHasValue(y))
{
continue;
}
columnElement = ChartHelper.CreateColumn(this);
columnElement.Visibility = base.Visibility;
if (value != null)
{
ChartHelper.SetColumnTooltipText(this, value.TooltipText, columnElement);
}
if (ChartHelper.DoubleHasValue(this._size))
{
columnElement.Height = this._size;
}
canvas.Children.Add(columnElement);
this._columnElementList.Add(columnElement);
if (this.AxisY.IsAxisYLeft())
{
size = x;
Canvas.SetLeft(columnElement, ChartConstant.ZERO_D);
}
else
{
size = canvas.Width - x;
Canvas.SetRight(columnElement, ChartConstant.ZERO_D);
}
if (size < ChartConstant.ZERO_D)
{
size = ChartConstant.ZERO_D;
}
columnElement.Width = size;
Canvas.SetTop(columnElement, y);
}
}
private NumberAxisData CreateNumberAxisData(double min, double max)
{
if (!ChartHelper.DoubleHasValue(min) ||
!ChartHelper.DoubleHasValue(max) ||
max - min <= base._PRE)
{
return(null);
}
return(new NumberAxisData(min, max));
}
private void UpdateScrollBarWidth(double scrollBarWidth)
{
if (!ChartHelper.DoubleHasValue(scrollBarWidth) || scrollBarWidth < ChartConstant.ZERO_D)
{
scrollBarWidth = _SCROLL_BAR_DEFAULT_WIDTH;
}
this._scrollViewer.Resources[SystemParameters.VerticalScrollBarWidthKey] = scrollBarWidth;
this._scrollViewer.Resources[SystemParameters.HorizontalScrollBarHeightKey] = scrollBarWidth;
this._scrollBarWidth = scrollBarWidth;
}
/// <summary>
/// 创建雷达图坐标样式(Path)
/// </summary>
/// <param name="stroke">颜色</param>
/// <param name="fill">填充</param>
/// <param name="opacity">透明度</param>
/// <param name="strokeThickness">Path.StrokeThickness</param>
/// <param name="mouseOverStrokeThickness">鼠标移上去时Path.StrokeThickness的值</param>
/// <returns>达图坐标样式</returns>
public static Style CreateRadarSeriesItemStytle(Brush stroke, Brush fill = null, double opacity = 0.5d, double strokeThickness = 2d, double mouseOverStrokeThickness = 3d)
{
Style style = CreateLineSeriesStyle(stroke, strokeThickness, mouseOverStrokeThickness);
if (fill != null)
{
style.Setters.Add(new Setter(Path.FillProperty, fill));
}
if (ChartHelper.DoubleHasValue(opacity))
{
style.Setters.Add(new Setter(Path.OpacityProperty, opacity));
}
return(style);
}
/// <summary>
/// 缩放
/// </summary>
private bool PrimitiveZoom(Canvas chartCanvas, out double zoomChangeSize)
{
if (!ChartHelper.DoubleHasValue(this._axisSize))
{
zoomChangeSize = double.NaN;
return(false);
}
double zoomedSize;
switch (this._axisType)
{
case AxisType.X:
zoomedSize = this._axisSize * this._zoom;
zoomChangeSize = zoomedSize - this._axisCanvas.Width;
this._axisCanvas.Width = zoomedSize;
break;
case AxisType.Y:
zoomedSize = this._axisSize * this._zoom;
zoomChangeSize = zoomedSize - this._axisCanvas.Height;
this._axisCanvas.Height = zoomedSize;
break;
default:
throw new NotImplementedException();
}
//移除坐标背景线
if (this._backgroundLabelLine != null)
{
chartCanvas.Children.Remove(this._backgroundLabelLine);
this._backgroundLabelLine = null;
}
//清空坐标信息
this._axisCanvas.Children.Clear();
//更新坐标
List <double> axisList = this.Update(this._axisCanvas);
//绘制坐标背景钱
this.AddBackgroundLabelLine(chartCanvas, axisList);
return(true);
}
private void GetCollectionMinAndMax(object obj, ref double pre, ref double min, ref double max)
{
double tmp, tmpTotalChild;
IEnumerable enumerable = (IEnumerable)obj;
tmpTotalChild = double.NaN;
foreach (var item in enumerable)
{
if (item == null || !(item is IChartChildValue))
{
continue;
}
tmp = ChartHelper.ConvertToDouble(((IChartChildValue)item).GetValue());
if (!ChartHelper.DoubleHasValue(tmp))
{
continue;
}
if (!ChartHelper.DoubleHasValue(min) || tmp - min < pre)
{
min = tmp;
}
if (ChartHelper.DoubleHasValue(tmpTotalChild))
{
tmpTotalChild += tmp;
}
else
{
tmpTotalChild = tmp;
}
}
if (!ChartHelper.DoubleHasValue(tmpTotalChild))
{
return;
}
if (!ChartHelper.DoubleHasValue(max) || tmpTotalChild - max > pre)
{
max = tmpTotalChild;
}
}
private List <List <PointInfo> > GeneratePointList()
{
if (base._values == null || base._values.Count == 0)
{
return(null);
}
List <List <PointInfo> > pointInfoListCollection = null;
List <PointInfo> pointList = null;
double x, y;
foreach (var item in base._values)
{
x = this.AxisX.GetX(item);
if (!ChartHelper.DoubleHasValue(x))
{
pointList = null;
continue;
}
y = this.AxisY.GetY(item);
if (!ChartHelper.DoubleHasValue(y))
{
pointList = null;
continue;
}
if (pointList == null)
{
pointList = new List <PointInfo>();
if (pointInfoListCollection == null)
{
pointInfoListCollection = new List <List <PointInfo> >();
}
pointInfoListCollection.Add(pointList);
}
pointList.Add(new PointInfo(new Point(x, y), item));
this._pointInfoList.Add(pointList.Last());
}
return(pointInfoListCollection);
}
private void GetMinAndMax(object obj, ref double pre, ref double min, ref double max)
{
var tmp = ChartHelper.ConvertToDouble(obj);
if (!ChartHelper.DoubleHasValue(tmp))
{
return;
}
if (!ChartHelper.DoubleHasValue(min) || tmp - min < pre)
{
min = tmp;
}
if (!ChartHelper.DoubleHasValue(max) || tmp - max > pre)
{
max = tmp;
}
}
private NumberAxisValueArea CompleteAxisAreaValue(NumberAxisValueArea result)
{
if (ChartHelper.DoubleHasValue(result.Max))
{
if (!ChartHelper.DoubleHasValue(result.Min) && ChartHelper.DoubleHasValue(this._labelStep))
{
result.Min = result.Max - this._labelStep;
}
}
else
{
if (ChartHelper.DoubleHasValue(result.Min) && ChartHelper.DoubleHasValue(this._labelStep))
{
result.Max = result.Min + this._labelStep;
}
}
return(result);
}
/// <summary>
/// 创建ColumnSeries样式(Rectangle)
/// </summary>
/// <param name="fill">Rectangle.Fill</param>
/// <param name="mouseOverOpacity">鼠标移上去时Rectangle.Opacity的值</param>
/// <returns></returns>
public static Style CreateColumnSeriesStyle(Brush fill, double mouseOverOpacity = 0.8d)
{
var style = new Style();
style.TargetType = typeof(Rectangle);
style.Setters.Add(new Setter(Rectangle.FillProperty, fill));
style.Setters.Add(new Setter(Rectangle.StrokeThicknessProperty, ChartConstant.ZERO_D));
if (ChartHelper.DoubleHasValue(mouseOverOpacity) && mouseOverOpacity > ChartConstant.ZERO_D)
{
var trigger = new Trigger();
trigger.Property = Rectangle.IsMouseOverProperty;
trigger.Value = true;
trigger.Setters.Add(new Setter(Rectangle.OpacityProperty, mouseOverOpacity));
style.Triggers.Add(trigger);
}
return(style);
}
/// <summary>
/// 创建LineSeries样式(Path)
/// </summary>
/// <param name="stroke">Path.Stroke</param>
/// <param name="strokeThickness">Path.StrokeThickness</param>
/// <param name="mouseOverStrokeThickness">鼠标移上去时Path.StrokeThickness的值</param>
/// <returns>LineSeries样式</returns>
public static Style CreateLineSeriesStyle(Brush stroke, double strokeThickness = 2d, double mouseOverStrokeThickness = 3d)
{
var style = new Style();
style.TargetType = typeof(Path);
style.Setters.Add(new Setter(Path.StrokeProperty, stroke));
style.Setters.Add(new Setter(Path.StrokeThicknessProperty, strokeThickness));
//style.Setters.Add(new Setter(Path.FillProperty, Brushes.White));
if (ChartHelper.DoubleHasValue(mouseOverStrokeThickness) && mouseOverStrokeThickness > ChartConstant.ZERO_D)
{
var trigger = new Trigger();
trigger.Property = Path.IsMouseOverProperty;
trigger.Value = true;
trigger.Setters.Add(new Setter(Path.StrokeThicknessProperty, mouseOverStrokeThickness));
style.Triggers.Add(trigger);
}
return(style);
}
private NumberAxisData CreateAxisData(ChartCollection <ISeries> seriesCollection)
{
if (!ChartHelper.DoubleHasValue(this._minValue) || !ChartHelper.DoubleHasValue(this._maxValue))
{
NumberAxisValueArea result = this.GetMinAndMaxValue(seriesCollection);
if (ChartHelper.DoubleHasValue(this._minValue))
{
result.Min = this._minValue;
}
if (ChartHelper.DoubleHasValue(this._maxValue))
{
result.Max = this._maxValue;
}
this.ZoomAxisValueArea(result);
this.CompleteAxisAreaValue(result);
return(this.CreateNumberAxisData(result.Min, result.Max));
}
else
{
return(this.CreateNumberAxisData(this._minValue, this._maxValue));
}
}
/// <summary>
/// 将Series绘制到已设置设定大小的画布中
/// </summary>
/// <param name="canvas">目标画布</param>
protected override void PrimitiveDraw(Canvas canvas)
{
this._segmentList.Clear();
this.AddLegendItem();
if (base._values == null || base._values.Count == 0)
{
return;
}
IChartAxisDoubleValue doubleValue;
double x1, x2, y1, y2;
foreach (var value in base._values)
{
doubleValue = value as IChartAxisDoubleValue;
if (doubleValue == null)
{
continue;
}
switch (this._orientation)
{
case SeriesOrientation.Horizontal:
object obj = doubleValue.GetYValue1().GetValue();
y1 = this.AxisY.GetY(doubleValue.GetYValue1());
if (ChartHelper.DoubleHasValue(y1))
{
//第一个有值
y2 = y1;
}
else
{
y2 = this.AxisY.GetY(doubleValue.GetYValue2());
if (ChartHelper.DoubleHasValue(y2))
{
//第一个没有值,第二个有值
y1 = y2;
}
else
{
//两个都没有值
continue;
}
}
x1 = this.AxisX.GetX(doubleValue.GetXValue1());
if (!ChartHelper.DoubleHasValue(x1))
{
continue;
}
x2 = this.AxisX.GetX(doubleValue.GetXValue2());
if (!ChartHelper.DoubleHasValue(x2))
{
continue;
}
break;
case SeriesOrientation.Vertical:
x1 = this.AxisX.GetX(doubleValue.GetXValue1());
if (ChartHelper.DoubleHasValue(x1))
{
//第一个有值
x2 = x1;
}
else
{
x2 = this.AxisX.GetX(doubleValue.GetXValue2());
if (ChartHelper.DoubleHasValue(x2))
{
//第一个没有值,第二个有值
x1 = x2;
}
else
{
//两个都没有值
continue;
}
}
y1 = this.AxisY.GetY(doubleValue.GetYValue1());
if (!ChartHelper.DoubleHasValue(y1))
{
continue;
}
y2 = this.AxisY.GetY(doubleValue.GetYValue2());
if (!ChartHelper.DoubleHasValue(y2))
{
continue;
}
break;
default:
throw new NotImplementedException(this._orientation.ToString());
}
Line line = new Line();
line.Style = this.GetStyle();
line.X1 = x1;
line.X2 = x2;
line.Y1 = y1;
line.Y2 = y2;
line.Visibility = base.Visibility;
if (this.EnableTooltip)
{
line.ToolTip = doubleValue.TooltipText;
}
line.Tag = doubleValue;
canvas.Children.Add(line);
this._segmentList.Add(line);
}
}
