using Bro.UI.HalconDisplay.ViewROI;
|
using HalconDotNet;
|
using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using System.Threading;
|
|
namespace Bro.UI.HalconDisplay
|
{
|
public delegate void IconicDelegate(int val);
|
public delegate void FuncDelegate();
|
public delegate void OnIconicObjectMovedHandler(Object sender, double moveX, double moveY);
|
public delegate void OnIconicObjectZoomedHandler(Object sender, double zoomCenterX, double zoomCenterY, double scale);
|
|
/// <summary>
|
/// This class works as a wrapper class for the HALCON window
|
/// HWindow. HWndCtrl is in charge of the visualization.
|
/// You can move and zoom the visible image part by using GUI component
|
/// inputs or with the mouse. The class HWndCtrl uses a graphics stack
|
/// to manage the iconic objects for the display. Each object is linked
|
/// to a graphical context, which determines how the object is to be drawn.
|
/// The context can be changed by calling changeGraphicSettings().
|
/// The graphical "modes" are defined by the class GraphicsContext and
|
/// map most of the dev_set_* operators provided in HDevelop.
|
/// </summary>
|
public class HWndCtrl
|
{
|
/// <summary>No action is performed on mouse events</summary>
|
public const int MODE_VIEW_NONE = 10;
|
|
/// <summary>Zoom is performed on mouse events</summary>
|
public const int MODE_VIEW_ZOOM = 11;
|
|
/// <summary>Move is performed on mouse events</summary>
|
public const int MODE_VIEW_MOVE = 12;
|
|
/// <summary>Magnification is performed on mouse events</summary>
|
public const int MODE_VIEW_ZOOMWINDOW = 13;
|
|
|
public const int MODE_INCLUDE_ROI = 1;
|
|
public const int MODE_EXCLUDE_ROI = 2;
|
|
|
/// <summary>
|
/// Constant describes delegate message to signal new image
|
/// </summary>
|
public const int EVENT_UPDATE_IMAGE = 31;
|
/// <summary>
|
/// Constant describes delegate message to signal error
|
/// when reading an image from file
|
/// </summary>
|
public const int ERR_READING_IMG = 32;
|
/// <summary>
|
/// Constant describes delegate message to signal error
|
/// when defining a graphical context
|
/// </summary>
|
public const int ERR_DEFINING_GC = 33;
|
|
/// <summary>
|
/// Maximum number of HALCON objects that can be put on the graphics
|
/// stack without loss. For each additional object, the first entry
|
/// is removed from the stack again.
|
/// </summary>
|
private const int MAXNUMOBJLIST = 1000;
|
|
|
private int stateView;
|
private bool mousePressed = false;
|
private double startX, startY;
|
|
/// <summary>HALCON window</summary>
|
private HWindowControl viewPort;
|
|
/// <summary>
|
/// Instance of ROIController, which manages ROI interaction
|
/// </summary>
|
private ROIController roiManager;
|
|
/* dispROI is a flag to know when to add the ROI models to the
|
paint routine and whether or not to respond to mouse events for
|
ROI objects */
|
private int dispROI;
|
|
|
/* Basic parameters, like dimension of window and displayed image part */
|
private int windowWidth;
|
private int windowHeight;
|
private int imageWidth;
|
private int imageHeight;
|
|
private int[] CompRangeX;
|
private int[] CompRangeY;
|
|
|
private int prevCompX, prevCompY;
|
private double stepSizeX, stepSizeY;
|
|
|
/* Image coordinates, which describe the image part that is displayed
|
in the HALCON window */
|
private double ImgRow1, ImgCol1, ImgRow2, ImgCol2;
|
|
/// <summary>Error message when an exception is thrown</summary>
|
public string exceptionText = "";
|
|
|
/* Delegates to send notification messages to other classes */
|
/// <summary>
|
/// Delegate to add information to the HALCON window after
|
/// the paint routine has finished
|
/// </summary>
|
public FuncDelegate addInfoDelegate;
|
|
/// <summary>
|
/// Delegate to notify about failed tasks of the HWndCtrl instance
|
/// </summary>
|
public IconicDelegate NotifyIconObserver;
|
|
|
private HWindow ZoomWindow;
|
private double zoomWndFactor;
|
private double zoomAddOn;
|
private int zoomWndSize;
|
|
|
/// <summary>
|
/// List of HALCON objects to be drawn into the HALCON window.
|
/// The list shouldn't contain more than MAXNUMOBJLIST objects,
|
/// otherwise the first entry is removed from the list.
|
/// </summary>
|
public List<HObjectEntry> HObjList;
|
|
/// <summary>
|
/// Instance that describes the graphical context for the
|
/// HALCON window. According on the graphical settings
|
/// attached to each HALCON object, this graphical context list
|
/// is updated constantly.
|
/// </summary>
|
public GraphicsContext mGC;
|
|
|
/// <summary>
|
/// Initializes the image dimension, mouse delegation, and the
|
/// graphical context setup of the instance.
|
/// </summary>
|
/// <param name="view"> HALCON window </param>
|
public HWndCtrl(HWindowControl view)
|
{
|
//viewPort = view;
|
//stateView = MODE_VIEW_NONE;
|
//windowWidth = viewPort.Size.Width;
|
//windowHeight = viewPort.Size.Height;
|
|
//zoomWndFactor = (double)imageWidth / viewPort.Width;
|
//zoomAddOn = Math.Pow(0.9, 5);
|
//zoomWndSize = 150;
|
|
///*default*/
|
//CompRangeX = new int[] { 0, 100 };
|
//CompRangeY = new int[] { 0, 100 };
|
|
//prevCompX = prevCompY = 0;
|
|
//dispROI = MODE_INCLUDE_ROI;//1;
|
|
//viewPort.HMouseUp += new HalconDotNet.HMouseEventHandler(this.mouseUp);
|
//viewPort.HMouseDown += new HalconDotNet.HMouseEventHandler(this.mouseDown);
|
//viewPort.HMouseMove += new HalconDotNet.HMouseEventHandler(this.mouseMoved);
|
|
//addInfoDelegate = new FuncDelegate(dummyV);
|
//NotifyIconObserver = new IconicDelegate(dummy);
|
|
//// graphical stack
|
//HObjList = new ArrayList(20);
|
//mGC = new GraphicsContext();
|
//mGC.gcNotification = new GCDelegate(exceptionGC);
|
viewPort = view;
|
stateView = MODE_VIEW_NONE;
|
windowWidth = viewPort.Size.Width;
|
windowHeight = viewPort.Size.Height;
|
|
// initialize the image part to window size
|
initializeDisplayImagePart();
|
resetImagePart(widthImagePart, heightImagePart);
|
|
|
if (widthImagePart > 0)
|
zoomWndFactor = (double)widthImagePart / viewPort.Width;
|
else
|
zoomWndFactor = 1;
|
|
zoomAddOn = Math.Pow(0.9, 5);
|
zoomWndSize = 150;
|
|
/*Set the boundaries and steps for changes for the GUI elements*/
|
/*default*/
|
CompRangeX = new int[] { 0, 100 };
|
CompRangeY = new int[] { 0, 100 };
|
|
prevCompX = prevCompY = 0;
|
|
/* Initialize the values for value range, step for
|
* some GUI elements */
|
setGUICompRangeX(CompRangeX, prevCompX);
|
setGUICompRangeY(CompRangeY, prevCompY);
|
|
//displayMode = MODE_VIEW_NONE;
|
|
dispROI = MODE_INCLUDE_ROI;//1;
|
|
viewPort.HMouseUp += new HalconDotNet.HMouseEventHandler(this.mouseUp);
|
viewPort.HMouseDown += new HalconDotNet.HMouseEventHandler(this.mouseDown);
|
viewPort.HMouseMove += new HalconDotNet.HMouseEventHandler(this.mouseMoved);
|
viewPort.HMouseWheel += new HalconDotNet.HMouseEventHandler(this.mouseWheel);
|
|
addInfoDelegate = new FuncDelegate(dummyV);
|
NotifyIconObserver = new IconicDelegate(dummy);
|
|
|
|
//OnImageZoomed = new OnIconicObjectZoomedHandler(dummyZoomed);
|
//OnImageZoomed = new OnIconicObjectZoomedHandler(dummyZoomed);
|
// graphical stack
|
HObjList = new List<HObjectEntry>();
|
mGC = new GraphicsContext();
|
mGC.gcNotification = new GCDelegate(exceptionGC);
|
|
}
|
|
|
/// <summary>
|
/// Registers an instance of an ROIController with this window
|
/// controller (and vice versa).
|
/// </summary>
|
/// <param name="rC">
|
/// Controller that manages interactive ROIs for the HALCON window
|
/// </param>
|
public void useROIController(ROIController rC)
|
{
|
roiManager = rC;
|
rC.setViewController(this);
|
}
|
|
/// <summary>
|
/// Adjust window settings by the values supplied for the left
|
/// upper corner and the right lower corner
|
/// </summary>
|
/// <param name="r1">y coordinate of left upper corner</param>
|
/// <param name="c1">x coordinate of left upper corner</param>
|
/// <param name="r2">y coordinate of right lower corner</param>
|
/// <param name="c2">x coordinate of right lower corner</param>
|
public void setImagePart(int r1, int c1, int r2, int c2)
|
{
|
ImgRow1 = r1;
|
ImgCol1 = c1;
|
ImgRow2 = imageHeight = r2;
|
ImgCol2 = imageWidth = c2;
|
|
System.Drawing.Rectangle rect = viewPort.ImagePart;
|
rect.X = (int)ImgCol1;
|
rect.Y = (int)ImgRow1;
|
rect.Height = (int)imageHeight;
|
rect.Width = (int)imageWidth;
|
viewPort.ImagePart = rect;
|
}
|
|
|
/// <summary>
|
/// Sets the view mode for mouse events in the HALCON window
|
/// (zoom, move, magnify or none).
|
/// </summary>
|
/// <param name="mode">One of the MODE_VIEW_* constants</param>
|
public void setViewState(int mode)
|
{
|
stateView = mode;
|
|
if (roiManager != null)
|
roiManager.resetROI();
|
}
|
|
/********************************************************************/
|
private void dummy(int val)
|
{
|
|
}
|
|
private void dummyV()
|
{
|
|
}
|
|
/*******************************************************************/
|
private void exceptionGC(string message)
|
{
|
exceptionText = message;
|
NotifyIconObserver(ERR_DEFINING_GC);
|
}
|
|
/// <summary>
|
/// Paint or don't paint the ROIs into the HALCON window by
|
/// defining the parameter to be equal to 1 or not equal to 1.
|
/// </summary>
|
public void setDispLevel(int mode)
|
{
|
dispROI = mode;
|
}
|
|
/****************************************************************************/
|
/* graphical element */
|
/****************************************************************************/
|
private void zoomImage(double x, double y, double scale)
|
{
|
double lengthC, lengthR;
|
double percentC, percentR;
|
int lenC, lenR;
|
|
percentC = (x - ImgCol1) / (ImgCol2 - ImgCol1);
|
percentR = (y - ImgRow1) / (ImgRow2 - ImgRow1);
|
|
lengthC = (ImgCol2 - ImgCol1) * scale;
|
lengthR = (ImgRow2 - ImgRow1) * scale;
|
|
ImgCol1 = x - lengthC * percentC;
|
ImgCol2 = x + lengthC * (1 - percentC);
|
|
ImgRow1 = y - lengthR * percentR;
|
ImgRow2 = y + lengthR * (1 - percentR);
|
|
lenC = (int)Math.Round(lengthC);
|
lenR = (int)Math.Round(lengthR);
|
|
System.Drawing.Rectangle rect = viewPort.ImagePart;
|
rect.X = (int)Math.Round(ImgCol1);
|
rect.Y = (int)Math.Round(ImgRow1);
|
rect.Width = (lenC > 0) ? lenC : 1;
|
rect.Height = (lenR > 0) ? lenR : 1;
|
viewPort.ImagePart = rect;
|
|
zoomWndFactor *= scale;
|
repaint();
|
}
|
|
/// <summary>
|
/// Scales the image in the HALCON window according to the
|
/// value scaleFactor
|
/// </summary>
|
public void zoomImage(double scaleFactor)
|
{
|
double midPointX, midPointY;
|
|
if (((ImgRow2 - ImgRow1) == scaleFactor * imageHeight) &&
|
((ImgCol2 - ImgCol1) == scaleFactor * imageWidth))
|
{
|
repaint();
|
return;
|
}
|
|
ImgRow2 = ImgRow1 + imageHeight;
|
ImgCol2 = ImgCol1 + imageWidth;
|
|
midPointX = ImgCol1;
|
midPointY = ImgRow1;
|
|
zoomWndFactor = (double)imageWidth / viewPort.Width;
|
zoomImage(midPointX, midPointY, scaleFactor);
|
}
|
|
|
/// <summary>
|
/// Scales the HALCON window according to the value scale
|
/// </summary>
|
public void scaleWindow(double scale)
|
{
|
ImgRow1 = 0;
|
ImgCol1 = 0;
|
|
ImgRow2 = imageHeight;
|
ImgCol2 = imageWidth;
|
|
viewPort.Width = (int)(ImgCol2 * scale);
|
viewPort.Height = (int)(ImgRow2 * scale);
|
|
zoomWndFactor = ((double)imageWidth / viewPort.Width);
|
}
|
|
/// <summary>
|
/// Recalculates the image-window-factor, which needs to be added to
|
/// the scale factor for zooming an image. This way the zoom gets
|
/// adjusted to the window-image relation, expressed by the equation
|
/// imageWidth/viewPort.Width.
|
/// </summary>
|
public void setZoomWndFactor()
|
{
|
zoomWndFactor = ((double)imageWidth / viewPort.Width);
|
}
|
|
/// <summary>
|
/// Sets the image-window-factor to the value zoomF
|
/// </summary>
|
public void setZoomWndFactor(double zoomF)
|
{
|
zoomWndFactor = zoomF;
|
}
|
|
/*******************************************************************/
|
private void moveImage(double motionX, double motionY)
|
{
|
ImgRow1 += -motionY;
|
ImgRow2 += -motionY;
|
|
ImgCol1 += -motionX;
|
ImgCol2 += -motionX;
|
|
System.Drawing.Rectangle rect = viewPort.ImagePart;
|
rect.X = (int)Math.Round(ImgCol1);
|
rect.Y = (int)Math.Round(ImgRow1);
|
viewPort.ImagePart = rect;
|
|
repaint();
|
}
|
|
|
/// <summary>
|
/// Resets all parameters that concern the HALCON window display
|
/// setup to their initial values and clears the ROI list.
|
/// </summary>
|
public void resetAll()
|
{
|
ImgRow1 = 0;
|
ImgCol1 = 0;
|
ImgRow2 = imageHeight;
|
ImgCol2 = imageWidth;
|
|
zoomWndFactor = (double)imageWidth / viewPort.Width;
|
|
System.Drawing.Rectangle rect = viewPort.ImagePart;
|
rect.X = (int)ImgCol1;
|
rect.Y = (int)ImgRow1;
|
rect.Width = (int)imageWidth;
|
rect.Height = (int)imageHeight;
|
viewPort.ImagePart = rect;
|
|
|
if (roiManager != null)
|
roiManager.reset();
|
}
|
|
public void resetWindow()
|
{
|
ImgRow1 = 0;
|
ImgCol1 = 0;
|
ImgRow2 = imageHeight;
|
ImgCol2 = imageWidth;
|
|
zoomWndFactor = (double)imageWidth / viewPort.Width;
|
|
System.Drawing.Rectangle rect = viewPort.ImagePart;
|
rect.X = (int)ImgCol1;
|
rect.Y = (int)ImgRow1;
|
rect.Width = (int)imageWidth;
|
rect.Height = (int)imageHeight;
|
viewPort.ImagePart = rect;
|
}
|
|
|
public double CurX=0.0;
|
public double CurY = 0.0;
|
/*************************************************************************/
|
/* Event handling for mouse */
|
/*************************************************************************/
|
private void mouseDown(object sender, HMouseEventArgs e)
|
{
|
if (e.Button == System.Windows.Forms.MouseButtons.Left)
|
mousePressed = true;
|
int activeROIidx = -1;
|
double scale;
|
|
if (roiManager != null && (dispROI == MODE_INCLUDE_ROI))
|
{
|
activeROIidx = roiManager.mouseDownAction(e, e.X, e.Y);
|
}
|
|
if (activeROIidx == -1)
|
{
|
switch (stateView)
|
{
|
case MODE_VIEW_MOVE:
|
startX = e.X;
|
startY = e.Y;
|
break;
|
case MODE_VIEW_ZOOM:
|
if (e.Button == System.Windows.Forms.MouseButtons.Left)
|
scale = 0.9;
|
else
|
scale = 1 / 0.9;
|
zoomImage(e.X, e.Y, scale);
|
break;
|
case MODE_VIEW_NONE:
|
break;
|
case MODE_VIEW_ZOOMWINDOW:
|
activateZoomWindow((int)e.X, (int)e.Y);
|
break;
|
default:
|
break;
|
}
|
}
|
}
|
|
/*******************************************************************/
|
private void activateZoomWindow(int X, int Y)
|
{
|
double posX, posY;
|
int zoomZone;
|
|
if (ZoomWindow != null)
|
ZoomWindow.Dispose();
|
|
HOperatorSet.SetSystem("border_width", 10);
|
ZoomWindow = new HWindow();
|
|
posX = ((X - ImgCol1) / (ImgCol2 - ImgCol1)) * viewPort.Width;
|
posY = ((Y - ImgRow1) / (ImgRow2 - ImgRow1)) * viewPort.Height;
|
|
zoomZone = (int)((zoomWndSize / 2) * zoomWndFactor * zoomAddOn);
|
ZoomWindow.OpenWindow((int)posY - (zoomWndSize / 2), (int)posX - (zoomWndSize / 2),
|
zoomWndSize, zoomWndSize,
|
viewPort.HalconID, "visible", "");
|
ZoomWindow.SetPart(Y - zoomZone, X - zoomZone, Y + zoomZone, X + zoomZone);
|
repaint(ZoomWindow);
|
ZoomWindow.SetColor("black");
|
}
|
|
/*******************************************************************/
|
private void mouseUp(object sender, HalconDotNet.HMouseEventArgs e)
|
{
|
mousePressed = false;
|
|
if (roiManager != null
|
&& (roiManager.activeROIidx != -1)
|
&& (dispROI == MODE_INCLUDE_ROI))
|
{
|
roiManager.NotifyRCObserver(ROIController.EVENT_UPDATE_ROI);
|
}
|
else if (stateView == MODE_VIEW_ZOOMWINDOW)
|
{
|
ZoomWindow.Dispose();
|
}
|
}
|
|
/*******************************************************************/
|
private void mouseMoved(object sender, HalconDotNet.HMouseEventArgs e)
|
{
|
double motionX, motionY;
|
double posX, posY;
|
double zoomZone;
|
|
if ((e.X > 0) && (e.Y > 0))
|
{
|
CurX = e.X;
|
CurY = e.Y;
|
}
|
|
if (!mousePressed)
|
return;
|
|
if (roiManager != null && (roiManager.activeROIidx != -1) && (dispROI == MODE_INCLUDE_ROI))
|
{
|
roiManager.mouseMoveAction(e.X, e.Y);
|
}
|
else if (stateView == MODE_VIEW_MOVE)
|
{
|
motionX = ((e.X - startX));
|
motionY = ((e.Y - startY));
|
|
if (((int)motionX != 0) || ((int)motionY != 0))
|
{
|
moveImage(motionX, motionY);
|
startX = e.X - motionX;
|
startY = e.Y - motionY;
|
}
|
}
|
else if (stateView == MODE_VIEW_ZOOMWINDOW)
|
{
|
HSystem.SetSystem("flush_graphic", "false");
|
ZoomWindow.ClearWindow();
|
|
|
posX = ((e.X - ImgCol1) / (ImgCol2 - ImgCol1)) * viewPort.Width;
|
posY = ((e.Y - ImgRow1) / (ImgRow2 - ImgRow1)) * viewPort.Height;
|
zoomZone = (zoomWndSize / 2) * zoomWndFactor * zoomAddOn;
|
|
ZoomWindow.SetWindowExtents((int)posY - (zoomWndSize / 2),
|
(int)posX - (zoomWndSize / 2),
|
zoomWndSize, zoomWndSize);
|
ZoomWindow.SetPart((int)(e.Y - zoomZone), (int)(e.X - zoomZone),
|
(int)(e.Y + zoomZone), (int)(e.X + zoomZone));
|
repaint(ZoomWindow);
|
|
HSystem.SetSystem("flush_graphic", "true");
|
ZoomWindow.DispLine(-100.0, -100.0, -100.0, -100.0);
|
}
|
}
|
|
/// <summary>
|
/// To initialize the move function using a GUI component, the HWndCtrl
|
/// first needs to know the range supplied by the GUI component.
|
/// For the x direction it is specified by xRange, which is
|
/// calculated as follows: GuiComponentX.Max()-GuiComponentX.Min().
|
/// The starting value of the GUI component has to be supplied
|
/// by the parameter Init
|
/// </summary>
|
public void setGUICompRangeX(int[] xRange, int Init)
|
{
|
int cRangeX;
|
|
CompRangeX = xRange;
|
cRangeX = xRange[1] - xRange[0];
|
prevCompX = Init;
|
stepSizeX = ((double)imageWidth / cRangeX) * (imageWidth / windowWidth);
|
|
}
|
|
/// <summary>
|
/// To initialize the move function using a GUI component, the HWndCtrl
|
/// first needs to know the range supplied by the GUI component.
|
/// For the y direction it is specified by yRange, which is
|
/// calculated as follows: GuiComponentY.Max()-GuiComponentY.Min().
|
/// The starting value of the GUI component has to be supplied
|
/// by the parameter Init
|
/// </summary>
|
public void setGUICompRangeY(int[] yRange, int Init)
|
{
|
int cRangeY;
|
|
CompRangeY = yRange;
|
cRangeY = yRange[1] - yRange[0];
|
prevCompY = Init;
|
stepSizeY = ((double)imageHeight / cRangeY) * (imageHeight / windowHeight);
|
}
|
|
public void SetLineWidth(int value)
|
{
|
viewPort.HalconWindow.SetLineWidth(value);
|
}
|
|
/// <summary>
|
/// Resets to the starting value of the GUI component.
|
/// </summary>
|
public void resetGUIInitValues(int xVal, int yVal)
|
{
|
prevCompX = xVal;
|
prevCompY = yVal;
|
}
|
|
/// <summary>
|
/// Moves the image by the value valX supplied by the GUI component
|
/// </summary>
|
public void moveXByGUIHandle(int valX)
|
{
|
double motionX;
|
|
motionX = (valX - prevCompX) * stepSizeX;
|
|
if (motionX == 0)
|
return;
|
|
moveImage(motionX, 0.0);
|
prevCompX = valX;
|
}
|
|
|
/// <summary>
|
/// Moves the image by the value valY supplied by the GUI component
|
/// </summary>
|
public void moveYByGUIHandle(int valY)
|
{
|
double motionY;
|
|
motionY = (valY - prevCompY) * stepSizeY;
|
|
if (motionY == 0)
|
return;
|
|
moveImage(0.0, motionY);
|
prevCompY = valY;
|
}
|
|
/// <summary>
|
/// Zooms the image by the value valF supplied by the GUI component
|
/// </summary>
|
public void zoomByGUIHandle(double valF)
|
{
|
double x, y, scale;
|
double prevScaleC;
|
|
|
x = (ImgCol1 + (ImgCol2 - ImgCol1) / 2);
|
y = (ImgRow1 + (ImgRow2 - ImgRow1) / 2);
|
|
prevScaleC = (double)((ImgCol2 - ImgCol1) / imageWidth);
|
scale = ((double)1.0 / prevScaleC * (100.0 / valF));
|
|
zoomImage(x, y, scale);
|
}
|
|
/// <summary>
|
/// Triggers a repaint of the HALCON window
|
/// </summary>
|
public void repaint()
|
{
|
repaint(viewPort.HalconWindow);
|
}
|
|
/// <summary>
|
/// Repaints the HALCON window 'window'
|
/// </summary>
|
public void repaint(HWindow window)
|
{
|
window.SetColored(12);
|
int count = HObjList.Count;
|
HObjectEntry entry;
|
|
HSystem.SetSystem("flush_graphic", "false");
|
|
Thread.Sleep(10);
|
|
window.ClearWindow();
|
//mGC.stateOfSettings.Clear();
|
|
for (int i = 0; i < count; i++)
|
{
|
entry = ((HObjectEntry)HObjList[i]);
|
//mGC.applyContext(window, entry.gContext);
|
if (entry.Type == HobjType.REGION)
|
{
|
window.SetColor(entry.ColorCode);
|
}
|
|
if (entry.HObj.IsInitialized())
|
window.DispObj(entry.HObj);
|
}
|
|
addInfoDelegate();
|
|
if (roiManager != null && (dispROI == MODE_INCLUDE_ROI))
|
roiManager.paintData(window);
|
|
HSystem.SetSystem("flush_graphic", "true");
|
|
window.DispLine(-100.0, -100.0, -101.0, -101.0);
|
|
}
|
|
public void ClearHObjListindex(int X)
|
{
|
if (HObjList.Count > X)
|
HObjList.RemoveAt(X);
|
}
|
public void ClearHObjListExceptImage()
|
{
|
if (HObjList.Count > 1)
|
{
|
|
HObjList.RemoveRange(1, HObjList.Count - 1);
|
|
}
|
}
|
|
/// <summary>
|
/// Clears all entries from the graphics stack
|
/// </summary>
|
public void ClearHObjList()
|
{
|
HObjList.Clear();
|
}
|
|
/// <summary>
|
/// Returns the number of items on the graphics stack
|
/// </summary>
|
public int getListCount()
|
{
|
return HObjList.Count;
|
}
|
|
/// <summary>
|
/// Changes the current graphical context by setting the specified mode
|
/// (constant starting by GC_*) to the specified value.
|
/// </summary>
|
/// <param name="mode">
|
/// Constant that is provided by the class GraphicsContext
|
/// and describes the mode that has to be changed,
|
/// e.g., GraphicsContext.GC_COLOR
|
/// </param>
|
/// <param name="val">
|
/// Value, provided as a string,
|
/// the mode is to be changed to, e.g., "blue"
|
/// </param>
|
public void changeGraphicSettings(string mode, string val)
|
{
|
switch (mode)
|
{
|
case GraphicsContext.GC_COLOR:
|
mGC.setColorAttribute(val);
|
break;
|
case GraphicsContext.GC_DRAWMODE:
|
mGC.setDrawModeAttribute(val);
|
break;
|
case GraphicsContext.GC_LUT:
|
mGC.setLutAttribute(val);
|
break;
|
case GraphicsContext.GC_PAINT:
|
mGC.setPaintAttribute(val);
|
break;
|
case GraphicsContext.GC_SHAPE:
|
mGC.setShapeAttribute(val);
|
break;
|
default:
|
break;
|
}
|
}
|
|
/// <summary>
|
/// Changes the current graphical context by setting the specified mode
|
/// (constant starting by GC_*) to the specified value.
|
/// </summary>
|
/// <param name="mode">
|
/// Constant that is provided by the class GraphicsContext
|
/// and describes the mode that has to be changed,
|
/// e.g., GraphicsContext.GC_LINEWIDTH
|
/// </param>
|
/// <param name="val">
|
/// Value, provided as an integer, the mode is to be changed to,
|
/// e.g., 5
|
/// </param>
|
public void changeGraphicSettings(string mode, int val)
|
{
|
switch (mode)
|
{
|
case GraphicsContext.GC_COLORED:
|
mGC.setColoredAttribute(val);
|
break;
|
case GraphicsContext.GC_LINEWIDTH:
|
mGC.setLineWidthAttribute(val);
|
break;
|
default:
|
break;
|
}
|
}
|
|
/// <summary>
|
/// Changes the current graphical context by setting the specified mode
|
/// (constant starting by GC_*) to the specified value.
|
/// </summary>
|
/// <param name="mode">
|
/// Constant that is provided by the class GraphicsContext
|
/// and describes the mode that has to be changed,
|
/// e.g., GraphicsContext.GC_LINESTYLE
|
/// </param>
|
/// <param name="val">
|
/// Value, provided as an HTuple instance, the mode is
|
/// to be changed to, e.g., new HTuple(new int[]{2,2})
|
/// </param>
|
public void changeGraphicSettings(string mode, HTuple val)
|
{
|
switch (mode)
|
{
|
case GraphicsContext.GC_LINESTYLE:
|
mGC.setLineStyleAttribute(val);
|
break;
|
default:
|
break;
|
}
|
}
|
|
/// <summary>
|
/// Clears all entries from the graphical context list
|
/// </summary>
|
public void clearGraphicContext()
|
{
|
mGC.clear();
|
}
|
|
/// <summary>
|
/// Returns a clone of the graphical context list (hashtable)
|
/// </summary>
|
public Hashtable getGraphicContext()
|
{
|
return mGC.copyContextList();
|
}
|
|
private int widthImagePart;
|
private int heightImagePart;
|
// width and height of the current image, after applying
|
// manipulation (zooming)
|
private int widthDisplayedImage;
|
private int heightDisplayedImage;
|
// width and height of current image
|
|
/* Initial image coordinates, which describe the image part that is displayed
|
in the HALCON window by adding new image to graphic stack */
|
private double InitImgRow1, InitImgCol1, InitImgRow2, InitImgCol2;
|
|
|
/// <summary>
|
/// This event is fired, if the displayed iconic objects
|
/// were moved
|
/// </summary>
|
public event OnIconicObjectMovedHandler OnImageMoved;
|
|
/// <summary>
|
/// This event is fired, if the displayed iconic objects
|
/// was zoomed
|
/// </summary>
|
public event OnIconicObjectZoomedHandler OnImageZoomed;
|
|
/// <summary>
|
/// boolean variable set to false if image size shall not change with window size
|
/// </summary>
|
public bool adaptSize;
|
|
/// <summary>
|
/// initialize the variables, that are used for image part descriotion,
|
/// with the initial values of HWindowControl
|
/// </summary>
|
private void initializeDisplayImagePart()
|
{
|
System.Drawing.Rectangle rect = viewPort.ImagePart;
|
ImgCol1 = rect.X;
|
ImgRow1 = rect.Y;
|
ImgRow2 = rect.Height - 1;
|
ImgCol2 = rect.Width - 1;
|
|
widthImagePart = Convert.ToInt32(Math.Ceiling(ImgCol2 - ImgCol1));
|
heightImagePart = Convert.ToInt32(Math.Ceiling(ImgRow2 - ImgRow1));
|
}
|
|
|
/// <summary>
|
/// The Properties define the actual magnification value or diminution
|
/// factor of the image displayed in the graphic window in per cent [%]
|
/// </summary>
|
public double ZoomFactor
|
{
|
get
|
{
|
return (this.zoomWndFactor * 100.0);
|
}
|
}
|
|
public int ShowROI
|
{
|
get
|
{
|
return dispROI;
|
}
|
set
|
{
|
if ((value == MODE_INCLUDE_ROI) ||
|
(value == MODE_EXCLUDE_ROI))
|
dispROI = value;
|
}
|
}
|
|
// MODIFIED
|
/// <summary>
|
/// get window width
|
/// </summary>
|
public void getWindowSize()
|
{
|
windowWidth = viewPort.Size.Width;
|
windowHeight = viewPort.Size.Height;
|
}
|
|
public void setZoomWndFactor2(double imageWidth0)
|
{
|
zoomWndFactor = ((double)imageWidth0 / viewPort.Width);
|
}
|
|
/// <summary>
|
/// Move image according the displacement values given in
|
/// motionX and motionY
|
/// </summary>
|
public void moveImageFromInit(double motionX, double motionY)
|
{
|
ImgRow1 = InitImgRow1 - motionY;
|
ImgRow2 = InitImgRow2 - motionY;
|
|
ImgCol1 = InitImgCol1 - motionX;
|
ImgCol2 = InitImgCol2 - motionX;
|
|
System.Drawing.Rectangle rect = viewPort.ImagePart;
|
rect.X = (int)Math.Round(ImgCol1);
|
rect.Y = (int)Math.Round(ImgRow1);
|
viewPort.ImagePart = rect;
|
}
|
|
/// <summary>
|
/// Move image according the displacement and axis
|
/// </summary>
|
public void moveImageFromInit(double motion, string axis)
|
{
|
if (axis == "y")
|
{
|
ImgRow1 = InitImgRow1 - motion;
|
ImgRow2 = InitImgRow2 - motion;
|
}
|
else if (axis == "x")
|
{
|
ImgCol1 = InitImgCol1 - motion;
|
ImgCol2 = InitImgCol2 - motion;
|
}
|
else
|
throw new
|
ArgumentException("Invalid name of the parameter axis.",
|
"axis");
|
|
System.Drawing.Rectangle rect = viewPort.ImagePart;
|
rect.X = (int)Math.Round(ImgCol1);
|
rect.Y = (int)Math.Round(ImgRow1);
|
viewPort.ImagePart = rect;
|
}
|
|
public void mouseWheel(object sender, HalconDotNet.HMouseEventArgs e)
|
{
|
if (e.Delta > 0)
|
{
|
zoomImage(e.X, e.Y, 0.9);
|
if (OnImageZoomed != null)
|
{
|
OnImageZoomed(sender, e.X, e.Y, 0.9);
|
}
|
}
|
|
else
|
{
|
zoomImage(e.X, e.Y, 1.1);
|
if (OnImageZoomed != null)
|
{
|
OnImageZoomed(sender, e.X, e.Y, 1.1);
|
}
|
}
|
}
|
|
/// <summary>
|
/// Zooms the image by the value valF supplied by the GUI component
|
/// </summary>
|
public void zoomByGUIHandleInitial(double valF, double prevScaleC)
|
{
|
double x, y, scale;
|
//double prevScaleC;
|
|
|
x = (ImgCol1 + (ImgCol2 - ImgCol1) / 2);
|
y = (ImgRow1 + (ImgRow2 - ImgRow1) / 2);
|
|
//prevScaleC = (double)((ImgCol2 - ImgCol1) / imageWidth);
|
scale = ((double)1.0 / prevScaleC * (100.0 / valF));
|
|
zoomImage(x, y, scale);
|
}
|
|
/********************************************************************/
|
/* GRAPHICSSTACK -KEEP */
|
/********************************************************************/
|
/// <summary>
|
/// Adds an iconic object to the graphics stack similar to the way
|
/// it is defined for the HDevelop graphics stack.
|
/// </summary>
|
/// <param name="obj">Iconic object</param>
|
public void addIconicVarKeepSettings(HObject obj)
|
{
|
HObjectEntry entry;
|
|
if (obj == null)
|
return;
|
|
if ((obj is HImage) && (obj != null))
|
{
|
double r, c;
|
int h, w, area;
|
string s;
|
|
area = ((HImage)obj).GetDomain().AreaCenter(out r, out c);
|
((HImage)obj).GetImagePointer1(out s, out w, out h);
|
|
if (HObjList.Count == 0)
|
{
|
heightImagePart = h;
|
widthImagePart = w;
|
adaptSize = true;
|
|
zoomWndFactor = (double)widthDisplayedImage / viewPort.Width;
|
|
resetImagePart(widthImagePart, heightImagePart);
|
}
|
|
if (area == (w * h))
|
{
|
ClearHObjList();
|
|
if ((h != heightImagePart) || (w != widthImagePart))
|
{
|
heightImagePart = h;
|
widthImagePart = w;
|
|
if ((widthDisplayedImage != w) || (heightDisplayedImage != h))
|
resetImagePart(w, h);
|
|
zoomWndFactor = (double)widthDisplayedImage / viewPort.Width;
|
}
|
}//if
|
widthDisplayedImage = w;
|
heightDisplayedImage = h;
|
}//if
|
entry = new HObjectEntry(obj, mGC.copyContextList(),HobjType.IMAGE);
|
|
HObjList.Add(entry);
|
|
if (HObjList.Count > MAXNUMOBJLIST)
|
HObjList.RemoveAt(1);
|
}
|
|
|
/// <summary>
|
/// Set the displayed image part of the
|
/// </summary>
|
public void resetImagePart(int imageWidth0, int imageHeight0)
|
{
|
getWindowSize();
|
if (adaptSize == true)
|
{
|
setImagePartAdaptSize(imageWidth0, imageHeight0);
|
}
|
else
|
{
|
setImagePartConst(imageWidth0, imageHeight0);
|
}
|
}
|
|
// MODIFIED
|
|
/// <summary>
|
/// calculate and set image part according new dimensions of HalconWindow
|
/// (the image is displayed with correct aspect ratio and one side is scaled to the
|
/// corresponding window size)
|
/// </summary>
|
/// <param name="imageWidth0"></param>
|
/// <param name="imageHeight0"></param>
|
public void setImagePartAdaptSize(int imWidth, int imHeight)
|
{
|
//
|
// fit to best size with aspect ratio 1:1
|
//
|
int r1, r2, c1, c2;
|
|
// The image part is calculated, so the displayed image is adapted
|
// to the window size, but the aspect ratio of the image
|
// is kept.
|
// The following condition decides, if the height or width
|
// of the displayed image is adapted to window height/width and
|
// the value of width/height will be calculated and adapted
|
// so the image is displayed in correct aspect ratio.
|
if ((windowWidth == 0) || (windowHeight == 0))
|
return;
|
|
if (1.0 * imWidth / imHeight < 1.0 * windowWidth / windowHeight)
|
{
|
// scale imageHeight to windowHeight
|
c1 = (int)(-0.5 * (1.0 * imHeight * windowWidth / windowHeight - imWidth));
|
c2 = (int)(imWidth + Math.Abs(c1) - 1);
|
r1 = 0;
|
r2 = imHeight - 1;
|
}
|
else
|
{
|
// scale imageWidth to windowWidth
|
r1 = (int)(-0.5 * (1.0 * imWidth * windowHeight / windowWidth - imHeight));
|
r2 = (int)(imHeight + Math.Abs(r1) - 1);
|
c1 = 0;
|
c2 = imWidth - 1;
|
}
|
|
// Check, if the values of image part coordinates
|
// have valid values
|
if (c2 < c1)
|
{
|
c1 = 0;
|
c2 = imWidth;
|
}
|
if (r2 < r1)
|
{
|
r1 = 0;
|
r2 = imHeight;
|
}
|
|
// adapt the current image part to the
|
// new size of window
|
System.Drawing.Rectangle rect = viewPort.ImagePart;
|
|
rect.X = c1;
|
rect.Y = r1;
|
|
rect.Width = c2 - c1 + 1;
|
rect.Height = r2 - r1 + 1;
|
|
InitImgRow1 = ImgRow1 = rect.Y;
|
InitImgCol1 = ImgCol1 = rect.X;
|
InitImgRow2 = ImgRow2 = rect.Y + rect.Height;
|
InitImgCol2 = ImgCol2 = rect.X + rect.Width;
|
|
|
viewPort.ImagePart = rect;
|
|
heightImagePart = rect.Height;
|
widthImagePart = rect.Width;
|
|
zoomWndFactor = (double)widthImagePart / viewPort.Width;
|
|
}
|
|
// MODIFIED
|
|
/// <summary>
|
/// The image part is set so that the image size remains constant
|
/// independent from the window size (image is not scaled)
|
/// </summary>
|
/// <param name="imageWidth0"></param>
|
/// <param name="imageHeight0"></param>
|
public void setImagePartConst(int imWidth, int imHeight)
|
{
|
//
|
// fit to best size with aspect ratio 1:1
|
//
|
int r1, r2, c1, c2;
|
|
/*calculate the coordinates for displaying the image
|
* centered in the Halcon window*/
|
c1 = (int)(0.5 * (imWidth - windowWidth));
|
c2 = imWidth - c1;
|
r1 = (int)(0.5 * (imHeight - windowHeight));
|
r2 = imHeight - r1;
|
|
|
// Check, if the values of image part coordinates
|
// have valid values
|
if (c2 <= c1)
|
{
|
c1 = 0;
|
c2 = imWidth;
|
}
|
if (r2 <= r1)
|
{
|
r1 = 0;
|
r2 = imHeight;
|
}
|
|
|
/* Assign the calculated values to image part of Halcon window*/
|
System.Drawing.Rectangle rect = viewPort.ImagePart;
|
|
rect.X = c1;
|
rect.Y = r1;
|
rect.Width = c2 - c1;
|
rect.Height = r2 - r1 + 1;
|
|
// set the image part values to member variables
|
InitImgRow1 = ImgRow1 = rect.Y;
|
InitImgCol1 = ImgCol1 = rect.X;
|
InitImgRow2 = ImgRow2 = rect.Y + rect.Height;
|
InitImgCol2 = ImgCol2 = rect.X + rect.Width;
|
|
viewPort.ImagePart = rect;
|
|
heightImagePart = rect.Height;
|
widthImagePart = rect.Width;
|
|
zoomWndFactor = (double)widthImagePart / viewPort.Width;
|
}
|
|
}//end of class
|
}//end of namespace
|
