using System;
|
using System.Drawing;
|
using System.Windows.Forms;
|
using HalconDotNet;
|
|
|
namespace PointGreyAndHalcon
|
{
|
/// <summary>
|
/// This class allows you to print a function into a Windows.Forms.Control.
|
/// The function must be supplied as an array of either double, float or
|
/// int values. When initializing the class you must provide the control that
|
/// actually draws the function plot. During the initialization you
|
/// can also decide whether the mouse event is used to return the (x,y)
|
/// coordinates of the plotted function. The scaling
|
/// of the x-y axis is performed automatically and depent on the length
|
/// of the function as well as the settings for the y-axis scaling:
|
/// * AXIS_RANGE_FIXED
|
/// * AXIS_RANGE_INCREASING
|
/// * AXIS_RANGE_ADAPTING
|
///
|
/// Constraints of the function plot class:
|
/// So far only functions containing a positive range of y-values can
|
/// be plotted correctly. Also only a positive and ascending x-range
|
/// can be plotted. The origin of the coordinate system is set to
|
/// be in the lower left corner of the control. Another definition
|
/// of the origin and hence the direction of the coordinate axis
|
/// is not implemented yet.
|
/// </summary>
|
public class FunctionPlot
|
{
|
// panels for display
|
private Graphics gPanel, backBuffer;
|
|
// graphical settings
|
private Pen pen, penCurve, penCursor;
|
private SolidBrush brushCS, brushFuncPanel;
|
private Font drawFont;
|
private StringFormat format;
|
private Bitmap functionMap;
|
|
// dimensions of panels
|
private float panelWidth;
|
private float panelHeight;
|
private float margin;
|
|
// origin
|
private float originX;
|
private float originY;
|
|
private PointF[] points;
|
private HFunction1D func;
|
|
// axis
|
private int axisAdaption;
|
private float axisXLength;
|
private float axisYLength;
|
private float scaleX, scaleY;
|
|
public const int AXIS_RANGE_FIXED = 3;
|
public const int AXIS_RANGE_INCREASING = 4;
|
public const int AXIS_RANGE_ADAPTING = 5;
|
|
int PreX, BorderRight, BorderTop;
|
|
|
/// <summary>
|
/// Initializes a FunctionPlot instance by providing a GUI control
|
/// and a flag specifying the mouse interaction mode.
|
/// The control is used to determine the available space to draw
|
/// the axes and to plot the supplied functions. Depending on the
|
/// available space, the values of the function as well as the axis
|
/// steps are adjusted (scaled) to fit into the visible part of the
|
/// control.
|
/// </summary>
|
/// <param name="panel">
|
/// An instance of the Windows.Forms.Control to plot the
|
/// supplied functions in
|
/// </param>
|
/// <param name="useMouseHandle">
|
/// Flag that specifies whether or not mouse interaction should
|
/// be used to create a navigation bar for the plotted function
|
/// </param>
|
public FunctionPlot(Control panel, bool useMouseHandle)
|
{
|
gPanel = panel.CreateGraphics();
|
|
panelWidth = panel.Size.Width - 32;
|
panelHeight = panel.Size.Height - 22;
|
|
originX = 32;
|
originY = panel.Size.Height - 22;
|
margin = 5.0f;
|
|
BorderRight = (int)(panelWidth + originX - margin);
|
BorderTop = (int)panelHeight;
|
|
PreX = 0;
|
scaleX = scaleY = 0.0f;
|
|
|
//default setting for axis scaling
|
axisAdaption = AXIS_RANGE_ADAPTING;
|
axisXLength = 10.0f;
|
axisYLength = 10.0f;
|
|
pen = new Pen(System.Drawing.Color.DarkGray, 1);
|
penCurve = new Pen(System.Drawing.Color.Blue, 1);
|
penCursor = new Pen(System.Drawing.Color.LightSteelBlue, 1);
|
penCursor.DashStyle = System.Drawing.Drawing2D.DashStyle.Dash;
|
|
brushCS = new SolidBrush(Color.Black);
|
brushFuncPanel = new SolidBrush(Color.White);
|
drawFont = new Font("Arial", 6);
|
format = new StringFormat();
|
format.Alignment = StringAlignment.Far;
|
|
functionMap = new Bitmap(panel.Size.Width, panel.Size.Height);
|
backBuffer = Graphics.FromImage(functionMap);
|
resetPlot();
|
|
panel.Paint += new System.Windows.Forms.PaintEventHandler(this.paint);
|
|
if (useMouseHandle)
|
panel.MouseMove += new System.Windows.Forms.MouseEventHandler(this.mouseMoved);
|
}
|
|
/// <summary>
|
/// Convenience method for constructor call. For this case the
|
/// useMouseHandle flag is set to false by default.
|
/// </summary>
|
/// <param name="panel">
|
/// An instance of the Windows.Forms.Control to plot the
|
/// supplied function in.
|
/// </param>
|
public FunctionPlot(Control panel)
|
: this(panel, false)
|
{
|
}
|
|
|
/// <summary>
|
/// Changes the origin of the coordinate system to be
|
/// at the control positions x and y.
|
/// </summary>
|
/// <param name="x">
|
/// X position within the control coordinate system
|
/// </param>
|
/// <param name="y">
|
/// Y position within the control coordinate system.
|
/// </param>
|
public void setOrigin(int x, int y)
|
{
|
float tmpX;
|
|
if (x < 1 || y < 1)
|
return;
|
|
tmpX = originX;
|
originX = x;
|
originY = y;
|
|
panelWidth = panelWidth + tmpX - originX;
|
panelHeight = originY;
|
BorderRight = (int)(panelWidth + originX - margin);
|
BorderTop = (int)panelHeight;
|
}
|
|
|
/// <summary>
|
/// Sets the type of scaling for the y-axis. If the
|
/// y-axis is defined to be of fixed size, then the upper
|
/// limit has to be provided with val. Otherwise,
|
/// an 8-bit image is assumed, so the fixed size is set
|
/// to be 255.
|
/// </summary>
|
/// <param name="mode">
|
/// Class constant starting with AXIS_RANGE_*
|
/// </param>
|
/// <param name="val">
|
/// For the mode AXIS_RANGE_FIXED the value
|
/// val must be positive, otherwise
|
/// it has no meaning.
|
/// </param>
|
public void setAxisAdaption(int mode, float val)
|
{
|
switch (mode)
|
{
|
case AXIS_RANGE_FIXED:
|
axisAdaption = mode;
|
axisYLength = (val > 0) ? val : 255.0f;
|
break;
|
default:
|
axisAdaption = mode;
|
break;
|
}
|
}
|
|
public void setAxisAdaption(int mode)
|
{
|
setAxisAdaption(mode, -1.0f);
|
}
|
|
|
/// <summary>
|
/// Plots a function of double values.
|
/// </summary>
|
/// <param name="grayValues">
|
/// Y-values defined as an array of doubles
|
/// </param>
|
public void plotFunction(double[] grayValues)
|
{
|
drawFunction(new HTuple(grayValues));
|
}
|
|
|
/// <summary>
|
/// Plots a function of float values.
|
/// </summary>
|
/// <param name="grayValues">
|
/// Y-values defined as an array of floats
|
/// </param>
|
public void plotFunction(float[] grayValues)
|
{
|
drawFunction(new HTuple(grayValues));
|
}
|
|
|
/// <summary>
|
/// Plots a function of integer values.
|
/// </summary>
|
/// <param name="grayValues">
|
/// Y-values defined as an array of integers
|
/// </param>
|
public void plotFunction(int[] grayValues)
|
{
|
drawFunction(new HTuple(grayValues));
|
}
|
|
|
/// <summary>Plots a function provided as an HTuple</summary>
|
private void drawFunction(HTuple tuple)
|
{
|
HTuple val;
|
int maxY,maxX;
|
float stepOffset;
|
|
if (tuple.Length == 0)
|
{
|
resetPlot();
|
return;
|
}
|
|
val = tuple.TupleSortIndex();
|
maxX = tuple.Length - 1;
|
maxY = (int)tuple[val[val.Length - 1].I].D;
|
|
axisXLength = maxX;
|
|
switch (axisAdaption)
|
{
|
case AXIS_RANGE_ADAPTING:
|
axisYLength = maxY;
|
break;
|
case AXIS_RANGE_INCREASING:
|
axisYLength = (maxY > axisYLength) ? maxY : axisYLength;
|
break;
|
}
|
|
backBuffer.Clear(System.Drawing.Color.WhiteSmoke);
|
backBuffer.FillRectangle(brushFuncPanel, originX, 0, panelWidth, panelHeight);
|
|
stepOffset = drawXYLabels();
|
drawLineCurve(tuple, stepOffset);
|
backBuffer.Flush();
|
|
gPanel.DrawImageUnscaled(functionMap, 0, 0);
|
gPanel.Flush();
|
}
|
|
|
/// <summary>
|
/// Clears the panel and displays only the coordinate axes.
|
/// </summary>
|
public void resetPlot()
|
{
|
backBuffer.Clear(System.Drawing.Color.WhiteSmoke);
|
backBuffer.FillRectangle(brushFuncPanel, originX, 0, panelWidth, panelHeight);
|
func = null;
|
drawXYLabels();
|
backBuffer.Flush();
|
repaint();
|
}
|
|
|
/// <summary>
|
/// Puts (=flushes) the current content of the graphics object on screen
|
/// again.
|
/// </summary>
|
private void repaint()
|
{
|
gPanel.DrawImageUnscaled(functionMap, 0, 0);
|
gPanel.Flush();
|
}
|
|
|
/// <summary>Plots the points of the function.</summary>
|
private void drawLineCurve(HTuple tuple, float stepOffset)
|
{
|
int length;
|
|
if (stepOffset > 1)
|
points = scaleDispValue(tuple);
|
else
|
points = scaleDispBlockValue(tuple);
|
|
length = points.Length;
|
|
func = new HFunction1D(tuple);
|
|
for (int i = 0; i < length - 1; i++)
|
backBuffer.DrawLine(penCurve, points[i], points[i + 1]);
|
|
}
|
|
|
/// <summary>
|
/// Scales the function to the dimension of the graphics object
|
/// (provided by the control).
|
/// </summary>
|
/// <param name="tup">
|
/// Function defined as a tuple of y-values
|
/// </param>
|
/// <returns>
|
/// Array of PointF values, containing the scaled function data
|
/// </returns>
|
private PointF[] scaleDispValue(HTuple tup)
|
{
|
PointF [] pVals;
|
float xMax, yMax, yV, x, y;
|
int length;
|
|
xMax = axisXLength;
|
yMax = axisYLength;
|
|
scaleX = (xMax != 0.0f) ? ((panelWidth - margin) / xMax) : 0.0f;
|
scaleY = (yMax != 0.0f) ? ((panelHeight - margin) / yMax) : 0.0f;
|
|
length = tup.Length;
|
pVals = new PointF[length];
|
|
for (int j=0; j < length; j++)
|
{
|
yV = (float)tup[j].D;
|
x = originX + (float)j * scaleX;
|
y = panelHeight - (yV * scaleY);
|
pVals[j] = new PointF(x, y);
|
}
|
|
return pVals;
|
}
|
|
|
/// <summary>
|
/// Scales the function to the dimension of the graphics object
|
/// (provided by the control). If the stepsize for the x-axis is
|
/// 1, the points are scaled in a block shape.
|
/// </summary>
|
/// <param name="tup">
|
/// Function defined as a tuple of y-values
|
/// </param>
|
/// <returns>
|
/// Array of PointF values, containing the scaled function data
|
/// </returns>
|
private PointF[] scaleDispBlockValue(HTuple tup)
|
{
|
PointF [] pVals;
|
float xMax, yMax, yV,x,y;
|
int length, idx;
|
|
xMax = axisXLength;
|
yMax = axisYLength;
|
|
scaleX = (xMax != 0.0f) ? ((panelWidth - margin) / xMax) : 0.0f;
|
scaleY = (yMax != 0.0f) ? ((panelHeight - margin) / yMax) : 0.0f;
|
|
length = tup.Length;
|
pVals = new PointF[length * 2];
|
|
y = 0;
|
idx = 0;
|
|
for (int j=0; j < length; j++)
|
{
|
yV = (float)tup[j].D;
|
x = originX + (float)j * scaleX - (scaleX / 2.0f);
|
y = panelHeight - (yV * scaleY);
|
pVals[idx] = new PointF(x, y);
|
idx++;
|
|
x = originX + (float)j * scaleX + (scaleX / 2.0f);
|
pVals[idx] = new PointF(x, y);
|
idx++;
|
}
|
|
//trim the end points of the curve
|
idx--;
|
x = originX + (float)(length - 1) * scaleX;
|
pVals[idx] = new PointF(x, y);
|
|
idx = 0;
|
yV = (float)tup[idx].D;
|
x = originX;
|
y = panelHeight - (yV * scaleY);
|
pVals[idx] = new PointF(x, y);
|
|
return pVals;
|
}
|
|
|
/// <summary>Draws x- and y-axis and its labels.</summary>
|
/// <returns>Step size used for the x-axis</returns>
|
private float drawXYLabels()
|
{
|
float pX,pY,length, XStart,YStart;
|
float YCoord, XCoord, XEnd, YEnd, offset, offsetString, offsetStep;
|
float scale = 0.0f;
|
|
offsetString = 5;
|
XStart = originX;
|
YStart = originY;
|
|
//prepare scale data for x-axis
|
pX = axisXLength;
|
if (pX != 0.0)
|
scale = (panelWidth - margin) / pX;
|
|
if (scale > 10.0)
|
offset = 1.0f;
|
else if (scale > 2)
|
offset = 10.0f;
|
else if (scale > 0.2)
|
offset = 100.0f;
|
else
|
offset = 1000.0f;
|
|
|
/*************** draw X-Axis ***************/
|
XCoord = 0.0f;
|
YCoord = YStart;
|
XEnd = (scale * pX);
|
|
backBuffer.DrawLine(pen, XStart, YStart, XStart + panelWidth - margin, YStart);
|
backBuffer.DrawLine(pen, XStart + XCoord, YCoord, XStart + XCoord, YCoord + 6);
|
backBuffer.DrawString(0 + "", drawFont, brushCS, XStart + XCoord + 4, YCoord + 8, format);
|
backBuffer.DrawLine(pen, XStart + XEnd, YCoord, XStart + XEnd, YCoord + 6);
|
backBuffer.DrawString(((int)pX + ""), drawFont, brushCS, XStart + XEnd + 4, YCoord + 8, format);
|
|
length = (int)(pX / offset);
|
length = (offset == 10) ? length - 1 : length;
|
for (int i=1; i <= length; i++)
|
{
|
XCoord = (float)(offset * i * scale);
|
|
if ((XEnd - XCoord) < 20)
|
continue;
|
|
backBuffer.DrawLine(pen, XStart + XCoord, YCoord, XStart + XCoord, YCoord + 6);
|
backBuffer.DrawString(((int)(i * offset) + ""), drawFont, brushCS, XStart + XCoord + 5, YCoord + 8, format);
|
}
|
|
offsetStep = offset;
|
|
//prepare scale data for y-axis
|
pY = axisYLength;
|
if (pY != 0.0)
|
scale = ((panelHeight - margin) / pY);
|
|
if (scale > 10.0)
|
offset = 1.0f;
|
else if (scale > 2)
|
offset = 10.0f;
|
else if (scale > 0.8)
|
offset = 50.0f;
|
else if (scale > 0.12)
|
offset = 100.0f;
|
else
|
offset = 1000.0f;
|
|
/*************** draw Y-Axis ***************/
|
XCoord = XStart;
|
YCoord = 5.0f;
|
YEnd = YStart - (scale * pY);
|
|
backBuffer.DrawLine(pen, XStart, YStart, XStart, YStart - (panelHeight - margin));
|
backBuffer.DrawLine(pen, XCoord, YStart, XCoord - 10, YStart);
|
backBuffer.DrawString(0 + "", drawFont, brushCS, XCoord - 12, YStart - offsetString, format);
|
backBuffer.DrawLine(pen, XCoord, YEnd, XCoord - 10, YEnd);
|
backBuffer.DrawString(pY + "", drawFont, brushCS, XCoord - 12, YEnd - offsetString, format);
|
|
length = (int)(pY / offset);
|
length = (offset == 10) ? length - 1 : length;
|
for (int i=1; i <= length; i++)
|
{
|
YCoord = (YStart - ((float)offset * i * scale));
|
|
if ((YCoord - YEnd) < 10)
|
continue;
|
|
backBuffer.DrawLine(pen, XCoord, YCoord, XCoord - 10, YCoord);
|
backBuffer.DrawString(((int)(i * offset) + ""), drawFont, brushCS, XCoord - 12, YCoord - offsetString, format);
|
}
|
|
return offsetStep;
|
}
|
|
|
/// <summary>
|
/// Action call for the Mouse-Move event. For the x-coordinate
|
/// supplied by the MouseEvent, the unscaled x and y coordinates
|
/// of the plotted function are determined and displayed
|
/// on the control.
|
/// </summary>
|
private void mouseMoved(object sender, MouseEventArgs e)
|
{
|
int Xh, Xc;
|
HTuple Ytup;
|
float Yh, Yc;
|
|
Xh = e.X;
|
|
if (PreX == Xh || Xh < originX || Xh > BorderRight || func == null)
|
return;
|
|
PreX = Xh;
|
|
Xc = (int)Math.Round((Xh - originX) / scaleX);
|
Ytup = func.GetYValueFunct1d(new HTuple(Xc), "zero");
|
|
Yc = (float)Ytup[0].D;
|
Yh = panelHeight - (Yc * scaleY);
|
|
gPanel.DrawImageUnscaled(functionMap, 0, 0);
|
gPanel.DrawLine(penCursor, Xh, 0, Xh, BorderTop);
|
gPanel.DrawLine(penCursor, originX, Yh, BorderRight + margin, Yh);
|
gPanel.DrawString(("X = " + Xc), drawFont, brushCS, panelWidth - margin, 10);
|
gPanel.DrawString(("Y = " + (int)Yc), drawFont, brushCS, panelWidth - margin, 20);
|
gPanel.Flush();
|
}
|
|
|
/// <summary>
|
/// Action call for the Paint event of the control to trigger the
|
/// repainting of the function plot.
|
/// </summary>
|
private void paint(object sender, System.Windows.Forms.PaintEventArgs e)
|
{
|
repaint();
|
}
|
|
}//end of class
|
}//end of namespace
|
