/* 绘制曲线
*/
protected void _DrawCurves(Graphics g, int width, int height)
{
for (int i = 0; i < _Curves.Count; ++i)
{
ChartCurve1V cc = _Curves[i];
_DrawSingleCurve(g, width, height, cc);
}
}
/* 绘制X坐标轴
*/
protected virtual void _DrawXAxis(Graphics g, int width, int height)
{
Rectangle rect_grid = _GetGridRect(width, height);
Rectangle rect_axis = _GetXAxisRect(width, height);
_DrawSingleXAxis(g, rect_axis, rect_grid, _AxesPen);
float delta_amount = _GetMaxDeltaAmount();
float start_delta_amount, stop_delta_amount;
ChartCurve1V.GetYAxisStartStopDeltaAmountByBilichi(_DataBilichiStart, _DataBilichiStop, delta_amount, out start_delta_amount, out stop_delta_amount);
_XAxisMinValueUsed = start_delta_amount;
_XAxisMaxValueUsed = stop_delta_amount;
string name_unit = XAxisName + (string.IsNullOrEmpty(XAxisUnitName) ? "" : ("（" + XAxisUnitName + "）"));
DataFormat df = XAxisKdFormat;
_DrawSingleXAxisVal(g, rect_axis, rect_grid, name_unit, _AxesFont, _AxesBrush, start_delta_amount, stop_delta_amount, df);
}
/* 绘制游标
*/
protected virtual void _DrawCursors(Graphics g, Point pt)
{
for (int ijk = 0; ijk < _Curves.Count; ++ijk)
{
ChartCurve1V cc = _Curves[ijk];
Dictionary <int, ChartCursor1V> cc_cursors = cc._ChartCursors1V;
ChartCursor1V cursor = _GetNearestPtCursor(pt.X, cc_cursors);
if (cursor != null)
{
g.FillEllipse(_OutlinePtBrush, cursor.Pt_x - _CURSOR_HALF_SIDE, cursor.Pt_y - _CURSOR_HALF_SIDE, _CURSOR_HALF_SIDE << 1, _CURSOR_HALF_SIDE << 1);
string info = "";
if (CursorFormat == null)
{
StringBuilder sb = new StringBuilder();
sb.Append("X:").Append(XAxisValueFormat.Format(cursor.YIndex * cc.Delta));
if (!string.IsNullOrEmpty(XAxisUnitName))
{
sb.Append("(").Append(XAxisUnitName).Append(")");
}
sb.Append("Y:").Append(cc.YAxisValueFormat.Format(cursor.Y_max));
if (!string.IsNullOrEmpty(cc.YAxisUnitName))
{
sb.Append("(").Append(cc.YAxisUnitName).Append(")");
}
sb.Append("\r\n");
info = sb.ToString();
sb.Clear();
}
else
{
info = CursorFormat.Format <int>(cursor.YIndex);
}
if (!string.IsNullOrEmpty(info))
{
_DrawCursor(g, info, new Point(cursor.Pt_x, cursor.Pt_y), cc.Pen, _AxesFont, cc.Brush, _DragRectBrush, _DestImage.Width, _DestImage.Height);
}
}
}
}
/* 绘制Y坐标轴
*/
protected virtual void _DrawYAxis(Graphics g, int width, int height)
{
Rectangle rect_grid = _GetGridRect(width, height);
Rectangle rect_axis = _GetYAxisRect(width, height);
float delta_amount = _GetMaxDeltaAmount();
float start_delta_amount, stop_delta_amount;
ChartCurve1V.GetYAxisStartStopDeltaAmountByBilichi(_DataBilichiStart, _DataBilichiStop, delta_amount, out start_delta_amount, out stop_delta_amount);
if (YAxisCombined || _Curves.Count == 0)
{
_DrawSingleYAxis(g, rect_axis, rect_grid, _AxesPen);
string name_unit = YAxisName + (string.IsNullOrEmpty(YAxisUnitName) ? "" : ("（" + YAxisUnitName + "）"));
if (YAxisIsAuto)
{
float y_axis_max = 0.0f, y_axis_min = 0.0f;
bool first = true;
for (int i = 0; i < _Curves.Count; ++i)
{
ChartCurve1V cc = _Curves[i];
List <float> data = cc.YAxisData;
int start_index, stop_index;
cc.GetYAxisStartStopIndex(start_delta_amount, stop_delta_amount, out start_index, out stop_index);
float f_max, f_min;
cc.GetYAxisDataMaxMinValueInSpan(start_index, stop_index, out f_max, out f_min);
if (first)
{
first = false;
y_axis_max = f_max;
y_axis_min = f_min;
}
else
{
if (y_axis_max < f_max)
{
y_axis_max = f_max;
}
if (y_axis_min > f_min)
{
y_axis_min = f_min;
}
}
}
float abs_max = Math.Abs(y_axis_max) > Math.Abs(y_axis_min) ? Math.Abs(y_axis_max) : Math.Abs(y_axis_min);
Int64 y_axis_range = ChartCurve1V.GetAxisRange(abs_max);
_YAxisMaxValueUsed = (float)y_axis_range / (float)1E6;
_YAxisMinValueUsed = -_YAxisMaxValueUsed;
}
else
{
_YAxisMaxValueUsed = YAxisMaxValue;
_YAxisMinValueUsed = YAxisMinValue;
}
_DrawSingleYAxisVal(g, rect_axis, rect_grid, name_unit, _AxesFont, _AxesBrush, _YAxisMinValueUsed, _YAxisMaxValueUsed, YAxisKdFormat);
}
else
{
int single_axis_width = (int)Math.Round((double)rect_axis.Width / (double)_Curves.Count);
for (int i = 0; i < _Curves.Count; ++i)
{
ChartCurve1V cc = _Curves[i];
Rectangle rect_axis_single;
if (i == 0)
{
rect_axis_single = new Rectangle(rect_axis.Right - single_axis_width, rect_axis.Y, single_axis_width, rect_axis.Height);
}
else if (i == _Curves.Count - 1)
{
rect_axis_single = new Rectangle(rect_axis.X, rect_axis.Y, single_axis_width, rect_axis.Height);
}
else
{
rect_axis_single = new Rectangle(rect_axis.X + (_Curves.Count - 1 - i) * single_axis_width, rect_axis.Y, single_axis_width, rect_axis.Height);
}
_DrawSingleYAxis(g, rect_axis_single, rect_grid, cc.Pen);
string name_unit = cc.YAxisName + (string.IsNullOrEmpty(cc.YAxisUnitName) ? "" : ("（" + cc.YAxisUnitName + "）"));
if (cc.YAxisIsAuto)
{
int start_index, stop_index;
cc.GetYAxisStartStopIndex(start_delta_amount, stop_delta_amount, out start_index, out stop_index);
float f_max, f_min;
cc.GetYAxisDataMaxMinValueInSpan(start_index, stop_index, out f_max, out f_min);
float abs_max = Math.Abs(f_max) > Math.Abs(f_min) ? Math.Abs(f_max) : Math.Abs(f_min);
Int64 y_axis_range = ChartCurve1V.GetAxisRange(abs_max);
cc.YAxisMaxValueUsed = (float)y_axis_range / (float)1E6;
cc.YAxisMinValueUsed = -cc.YAxisMaxValueUsed;
}
else
{
cc.YAxisMaxValueUsed = cc.YAxisMaxValue;
cc.YAxisMinValueUsed = cc.YAxisMinValue;
}
_DrawSingleYAxisVal(g, rect_axis_single, rect_grid, name_unit, _AxesFont, cc.Brush, cc.YAxisMinValueUsed, cc.YAxisMaxValueUsed, cc.YAxisKdFormat);
}
}
}
/* 绘制单条曲线
*/
protected virtual void _DrawSingleCurve(Graphics g, int width, int height, ChartCurve1V cc)
{
Rectangle rect_grid = _GetGridRect(width, height);
int chart_width = rect_grid.Width;
int chart_height = rect_grid.Height;
List <Point> pts = new List <Point>();
List <float> data_y = cc.YAxisData;
if (data_y.Count < 2)
{
return;
}
cc._ChartCursors1V.Clear();
int start_index, stop_index;
cc.GetYAxisStartStopIndex(_XAxisMinValueUsed, _XAxisMaxValueUsed, out start_index, out stop_index);
float y_axis_max, y_axis_min;
if (YAxisCombined)
{
y_axis_max = _YAxisMaxValueUsed;
y_axis_min = _YAxisMinValueUsed;
}
else
{
y_axis_max = cc.YAxisMaxValueUsed;
y_axis_min = cc.YAxisMinValueUsed;
}
for (int i = start_index; i <= stop_index && i < data_y.Count; ++i)
{
float x_v = i * cc.Delta;
int pt_x = rect_grid.X + _GetXAxisPos(x_v, _XAxisMaxValueUsed, _XAxisMinValueUsed, rect_grid.Width);
float y_v = data_y[i];
int pt_y = rect_grid.Y + _GetYAxisPos(y_v, y_axis_max, y_axis_min, rect_grid.Height);
pts.Add(new Point(pt_x, pt_y));
ChartCursor1V cursor = new ChartCursor1V
{
Pt_x = pt_x,
Pt_y = pt_y,
YValue = y_v,
Pt_count = 1,
Y_max = y_v,
Y_min = y_v,
YIndex = i,
};
if (!cc._ChartCursors1V.Keys.Contains(pt_x))
{
cc._ChartCursors1V.Add(pt_x, cursor);
}
else
{
ChartCursor1V cursor_exist = cc._ChartCursors1V[pt_x];
cursor_exist.Pt_count++;
cursor_exist.Y_max = (cursor_exist.Y_max >= y_v ? cursor_exist.Y_max : y_v);
cursor_exist.Y_min = (cursor_exist.Y_min <= y_v ? cursor_exist.Y_min : y_v);
}
}
if (pts.Count > 1)
{
g.DrawLines(cc.Pen, pts.ToArray());
if (pts.Count < rect_grid.Width / 2)
{
Rectangle r = new Rectangle();
r.Width = 4;
r.Height = 4;
pts.ForEach((Point pt) =>
{
r.X = pt.X - 2;
r.Y = pt.Y - 2;
g.DrawRectangle(cc.Pen, r);
});
}
}
else if (pts.Count == 1)
{
g.DrawRectangle(cc.Pen, new Rectangle(pts[0].X - 2, pts[0].Y - 2, 4, 4));
}
}
/* 绘制单条曲线
*/
protected override void _DrawSingleCurve(Graphics g, int width, int height, ChartCurve1V c)
{
ChartCurve2V cc = c as ChartCurve2V;
Rectangle rect_grid = _GetGridRect(width, height);
int chart_width = rect_grid.Width;
int chart_height = rect_grid.Height;
List <Point> pts = new List <Point>();
List <float> data_y = cc.YAxisData;
List <float> data_x = cc.XAxisData;
if (data_y.Count < 2)
{
return;
}
cc._ChartCursors2V.Clear();
float y_axis_max, y_axis_min;
if (YAxisCombined)
{
y_axis_max = _YAxisMaxValueUsed;
y_axis_min = _YAxisMinValueUsed;
}
else
{
y_axis_max = cc.YAxisMaxValueUsed;
y_axis_min = cc.YAxisMinValueUsed;
}
float x_axis_max, x_axis_min;
if (XAxisCombined)
{
x_axis_max = _XAxisMaxValueUsed;
x_axis_min = _XAxisMinValueUsed;
}
else
{
x_axis_max = cc.XAxisMaxValueUsed;
x_axis_min = cc.XAxisMinValueUsed;
}
for (int i = 0; i < data_x.Count && i < data_y.Count; ++i)
{
float x_v = data_x[i];
int pt_x = rect_grid.X + _GetXAxisPos(x_v, x_axis_max, x_axis_min, rect_grid.Width);
float y_v = data_y[i];
int pt_y = rect_grid.Y + _GetYAxisPos(y_v, y_axis_max, y_axis_min, rect_grid.Height);
pts.Add(new Point(pt_x, pt_y));
ChartCursor2V cursor = new ChartCursor2V
{
Pt_x = pt_x,
Pt_y = pt_y,
XValue = x_v,
YValue = y_v,
Pt_count = 1,
Y_max = y_v,
Y_min = y_v,
X_max = x_v,
X_min = x_v,
};
if (!cc._ChartCursors2V.Keys.Contains(pt_x))
{
cc._ChartCursors2V.Add(pt_x, new Dictionary <int, ChartCursor2V>());
cc._ChartCursors2V[pt_x].Add(pt_y, cursor);
}
else
{
if (!cc._ChartCursors2V[pt_x].Keys.Contains(pt_y))
{
cc._ChartCursors2V[pt_x].Add(pt_y, cursor);
}
else
{
ChartCursor2V cursor_exist = cc._ChartCursors2V[pt_x][pt_y];
cursor_exist.Pt_count++;
cursor_exist.Y_max = (cursor_exist.Y_max >= y_v ? cursor_exist.Y_max : y_v);
cursor_exist.Y_min = (cursor_exist.Y_min <= y_v ? cursor_exist.Y_min : y_v);
cursor_exist.X_max = (cursor_exist.X_max >= x_v ? cursor_exist.X_max : x_v);
cursor_exist.X_min = (cursor_exist.X_min >= x_v ? cursor_exist.X_min : x_v);
}
}
}
if (pts.Count > 1)
{
g.DrawLines(cc.Pen, pts.ToArray());
Rectangle r = new Rectangle();
r.Width = 4;
r.Height = 4;
foreach (var kv in cc._ChartCursors2V)
{
int pt_x = kv.Key;
if (cc._ChartCursors2V.Keys.Contains(pt_x + 1) || cc._ChartCursors2V.Keys.Contains(pt_x - 1))
{
continue;
}
foreach (var kv2 in kv.Value)
{
int pt_y = kv2.Key;
if (kv.Value.Keys.Contains(pt_y + 1) || kv.Value.Keys.Contains(pt_y - 1))
{
continue;
}
r.X = pt_x - 2;
r.Y = pt_y - 2;
g.DrawRectangle(cc.Pen, r);
}
}
}
else if (pts.Count == 1)
{
g.DrawRectangle(cc.Pen, new Rectangle(pts[0].X - 2, pts[0].Y - 2, 4, 4));
}
}
/* 绘制X坐标轴
*/
protected override void _DrawXAxis(Graphics g, int width, int height)
{
Rectangle rect_grid = _GetGridRect(width, height);
Rectangle rect_axis = _GetXAxisRect(width, height);
if (XAxisCombined || _Curves.Count == 0)
{
_DrawSingleXAxis(g, rect_axis, rect_grid, _AxesPen);
string name_unit = XAxisName + (string.IsNullOrEmpty(XAxisUnitName) ? "" : ("（" + XAxisUnitName + "）"));
if (XAxisIsAuto)
{
float x_axis_max = 0.0f, x_axis_min = 0.0f;
bool first = true;
for (int i = 0; i < _Curves.Count; ++i)
{
ChartCurve2V cc = _Curves[i] as ChartCurve2V;
if (cc == null)
{
continue;
}
List <float> data = cc.XAxisData;
float f_max, f_min;
cc.GetXAxisDataMaxMinValueInSpan(0, data.Count, out f_max, out f_min);
if (first)
{
first = false;
x_axis_max = f_max;
x_axis_min = f_min;
}
else
{
if (x_axis_max < f_max)
{
x_axis_max = f_max;
}
if (x_axis_min > f_min)
{
x_axis_min = f_min;
}
}
}
float abs_max = Math.Abs(x_axis_max) > Math.Abs(x_axis_min) ? Math.Abs(x_axis_max) : Math.Abs(x_axis_min);
Int64 y_axis_range = ChartCurve1V.GetAxisRange(abs_max);
_XAxisMaxValueUsed = (float)y_axis_range / (float)1E6;
_XAxisMinValueUsed = -_XAxisMaxValueUsed;
}
else
{
_XAxisMaxValueUsed = XAxisMaxValue;
_XAxisMinValueUsed = XAxisMinValue;
}
_DrawSingleXAxisVal(g, rect_axis, rect_grid, name_unit, _AxesFont, _AxesBrush, _XAxisMinValueUsed, _XAxisMaxValueUsed, XAxisKdFormat);
}
else
{
int single_axis_height = (int)Math.Round((double)rect_axis.Height / (double)_Curves.Count);
for (int i = 0; i < _Curves.Count; ++i)
{
ChartCurve2V cc = _Curves[i] as ChartCurve2V;
if (cc == null)
{
continue;
}
Rectangle rect_axis_single;
if (i == 0)
{
rect_axis_single = new Rectangle(rect_axis.Left, rect_axis.Top, rect_axis.Width, single_axis_height);
}
else if (i == _Curves.Count - 1)
{
rect_axis_single = new Rectangle(rect_axis.Left, rect_axis.Bottom - single_axis_height, rect_axis.Width, single_axis_height);
}
else
{
rect_axis_single = new Rectangle(rect_axis.Left, rect_axis.Top + i * single_axis_height, rect_axis.Width, single_axis_height);
}
_DrawSingleXAxis(g, rect_axis_single, rect_grid, cc.Pen);
string name_unit = cc.XAxisName + (string.IsNullOrEmpty(cc.XAxisUnitName) ? "" : ("（" + cc.XAxisUnitName + "）"));
if (cc.XAxisIsAuto)
{
float f_max, f_min;
cc.GetXAxisDataMaxMinValueInSpan(0, cc.XAxisData.Count, out f_max, out f_min);
float abs_max = Math.Abs(f_max) > Math.Abs(f_min) ? Math.Abs(f_max) : Math.Abs(f_min);
Int64 x_axis_range = ChartCurve1V.GetAxisRange(abs_max);
cc.XAxisMaxValueUsed = (float)x_axis_range / (float)1E6;
cc.XAxisMinValueUsed = -cc.XAxisMaxValueUsed;
}
else
{
cc.XAxisMaxValueUsed = cc.XAxisMaxValue;
cc.XAxisMinValueUsed = cc.XAxisMinValue;
}
_DrawSingleXAxisVal(g, rect_axis_single, rect_grid, name_unit, _AxesFont, cc.Brush, cc.XAxisMinValueUsed, cc.XAxisMaxValueUsed, cc.XAxisKdFormat);
}
}
}
