using System; using ViewWindow; using System.Collections; using HalconDotNet; using ViewROI.Config; using System.Collections.Generic; using System.Windows.Forms; using System.IO; namespace ViewWindow.Model { public delegate void IconicDelegate(int val); public delegate void FuncDelegate(); /// /// 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. /// public class HWndCtrl { /// No action is performed on mouse events public const int MODE_VIEW_NONE = 10; /// Zoom is performed on mouse events public const int MODE_VIEW_ZOOM = 11; /// Move is performed on mouse events public const int MODE_VIEW_MOVE = 12; /// Magnification is performed on mouse events public const int MODE_VIEW_ZOOMWINDOW = 13; public const int MODE_INCLUDE_ROI = 1; public const int MODE_EXCLUDE_ROI = 2; /// /// Constant describes delegate message to signal new image /// public const int EVENT_UPDATE_IMAGE = 31; /// /// Constant describes delegate message to signal error /// when reading an image from file /// public const int ERR_READING_IMG = 32; /// /// Constant describes delegate message to signal error /// when defining a graphical context /// public const int ERR_DEFINING_GC = 33; /// /// 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. /// private const int MAXNUMOBJLIST = 2;//ԭʼֵΪ50 ʵ¼ÊÉÏ2¶¼¿ÉÒÔ,ÒòÕâÀïÖ»ÊÇ´æ´¢±³¾°Í¼Æ¬ private int stateView; private bool mousePressed = false; private double startX,startY; /// HALCON window private HWindowControl viewPort; /// /// Instance of ROIController, which manages ROI interaction /// 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; /// /// Ëõ·Åʼþ¿ª¹Ø /// public bool drawModel = false; /* 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; /// Error message when an exception is thrown public string exceptionText = ""; /* Delegates to send notification messages to other classes */ /// /// Delegate to add information to the HALCON window after /// the paint routine has finished /// public FuncDelegate addInfoDelegate; /// /// Delegate to notify about failed tasks of the HWndCtrl instance /// public IconicDelegate NotifyIconObserver; private HWindow ZoomWindow; private double zoomWndFactor; private double zoomAddOn; private int zoomWndSize; /// /// 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. /// private ArrayList HObjImageList; /// /// 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. /// private GraphicsContext mGC; /// /// Initializes the image dimension, mouse delegation, and the /// graphical context setup of the instance. /// /// HALCON window protected internal 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.HMouseWheel += new HalconDotNet.HMouseEventHandler(this.HMouseWheel); viewPort.HMouseMove += new HalconDotNet.HMouseEventHandler(this.mouseMoved); addInfoDelegate = new FuncDelegate(dummyV); NotifyIconObserver = new IconicDelegate(dummy); // graphical stack HObjImageList = new ArrayList(20); mGC = new GraphicsContext(); mGC.gcNotification = new GCDelegate(exceptionGC); } private void HMouseWheel(object sender, HMouseEventArgs e) { //¹Ø±ÕËõ·Åʼþ if (drawModel) { return; } double scale; if (e.Delta > 0) scale = 0.9; else scale = 1 / 0.9; zoomImage(e.X, e.Y, scale); } /// /// Read dimensions of the image to adjust own window settings /// /// HALCON image private void setImagePart(HImage image) { string s; int w,h; image.GetImagePointer1(out s, out w, out h); setImagePart(0, 0, h, w); } /// /// Adjust window settings by the values supplied for the left /// upper corner and the right lower corner /// /// y coordinate of left upper corner /// x coordinate of left upper corner /// y coordinate of right lower corner /// x coordinate of right lower corner private 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; } /// /// Sets the view mode for mouse events in the HALCON window /// (zoom, move, magnify or none). /// /// One of the MODE_VIEW_* constants protected internal 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); } /// /// 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. /// public void setDispLevel(int mode) { dispROI = mode; } /****************************************************************************/ /* graphical element */ /****************************************************************************/ private void zoomImage(double x, double y, double scale) { //¹Ø±ÕËõ·Åʼþ if (drawModel) { return; } 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; double _zoomWndFactor = 1; _zoomWndFactor = scale * zoomWndFactor; if (zoomWndFactor < 0.01 && _zoomWndFactor < zoomWndFactor) { //³¬¹ýÒ»¶¨Ëõ·Å±ÈÀý¾Í²»ÔÚËõ·Å resetWindow(); return; } if (zoomWndFactor > 100 && _zoomWndFactor > zoomWndFactor) { //³¬¹ýÒ»¶¨Ëõ·Å±ÈÀý¾Í²»ÔÚËõ·Å resetWindow(); return; } zoomWndFactor = _zoomWndFactor; repaint(); } /// /// Scales the image in the HALCON window according to the /// value scaleFactor /// 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); } /// /// Scales the HALCON window according to the value scale /// 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); } /// /// 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. /// public void setZoomWndFactor() { zoomWndFactor = ((double)imageWidth / viewPort.Width); } /// /// Sets the image-window-factor to the value zoomF /// 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(); } /// /// Resets all parameters that concern the HALCON window display /// setup to their initial values and clears the ROI list. /// protected internal 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(); } protected internal 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; } /*************************************************************************/ /* Event handling for mouse */ /*************************************************************************/ private void mouseDown(object sender, HalconDotNet.HMouseEventArgs e) { //¹Ø±ÕËõ·Åʼþ if (drawModel) { return; } stateView = MODE_VIEW_MOVE; mousePressed = true; int activeROIidx = -1; if (roiManager != null && (dispROI == MODE_INCLUDE_ROI)) { activeROIidx = roiManager.mouseDownAction(e.X, e.Y); } if (activeROIidx == -1) { switch (stateView) { case MODE_VIEW_MOVE: startX = e.X; startY = e.Y; break; case MODE_VIEW_NONE: break; case MODE_VIEW_ZOOMWINDOW: activateZoomWindow((int)e.X, (int)e.Y); break; default: break; } } //end of if } /*******************************************************************/ 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"); } public void raiseMouseup() { 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 mouseUp(object sender, HalconDotNet.HMouseEventArgs e) { //¹Ø±ÕËõ·Åʼþ if (drawModel) { return; } 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) { //¹Ø±ÕËõ·Åʼþ if (drawModel) { return; } double motionX, motionY; double posX, posY; double zoomZone; 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); } } /// /// 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 /// public void setGUICompRangeX(int[] xRange, int Init) { int cRangeX; CompRangeX = xRange; cRangeX = xRange[1] - xRange[0]; prevCompX = Init; stepSizeX = ((double)imageWidth / cRangeX) * (imageWidth / windowWidth); } /// /// 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 /// public void setGUICompRangeY(int[] yRange, int Init) { int cRangeY; CompRangeY = yRange; cRangeY = yRange[1] - yRange[0]; prevCompY = Init; stepSizeY = ((double)imageHeight / cRangeY) * (imageHeight / windowHeight); } /// /// Resets to the starting value of the GUI component. /// public void resetGUIInitValues(int xVal, int yVal) { prevCompX = xVal; prevCompY = yVal; } /// /// Moves the image by the value valX supplied by the GUI component /// public void moveXByGUIHandle(int valX) { double motionX; motionX = (valX - prevCompX) * stepSizeX; if (motionX == 0) return; moveImage(motionX, 0.0); prevCompX = valX; } /// /// Moves the image by the value valY supplied by the GUI component /// public void moveYByGUIHandle(int valY) { double motionY; motionY = (valY - prevCompY) * stepSizeY; if (motionY == 0) return; moveImage(0.0, motionY); prevCompY = valY; } /// /// Zooms the image by the value valF supplied by the GUI component /// 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); } /// /// Triggers a repaint of the HALCON window /// public void repaint() { repaint(viewPort.HalconWindow); } /// /// Repaints the HALCON window 'window' /// public void repaint(HalconDotNet.HWindow window) { try { int count = HObjImageList.Count; HObjectEntry entry; HSystem.SetSystem("flush_graphic", "false"); window.ClearWindow(); mGC.stateOfSettings.Clear(); //ÏÔʾͼƬ for (int i=0; i < count; i++) { entry = ((HObjectEntry)HObjImageList[i]); mGC.applyContext(window, entry.gContext); window.DispObj(entry.HObj); } //ÏÔʾregion showHObjectList(); addInfoDelegate(); if (roiManager != null && (dispROI == MODE_INCLUDE_ROI)) roiManager.paintData(window); HSystem.SetSystem("flush_graphic", "true"); //×¢ÊÍÁËÏÂÃæÓï¾ä,»áµ¼Ö´°¿ÚÎÞ·¨ÊµÏÖËõ·ÅºÍÍ϶¯ window.SetColor("black"); window.DispLine(-100.0, -100.0, -101.0, -101.0); } catch (Exception) { } } /********************************************************************/ /* GRAPHICSSTACK */ /********************************************************************/ /// /// Adds an iconic object to the graphics stack similar to the way /// it is defined for the HDevelop graphics stack. /// /// Iconic object public void addIconicVar(HObject img) { //ÏȰÑHObjImageList¸øÈ«²¿ÊÍ·ÅÁË,Ô´´úÂë »á³öÏÖÄÚ´æÐ¹Â©ÎÊÌâ for (int i = 0; i < HObjImageList.Count; i++) { ((HObjectEntry)HObjImageList[i]).clear(); } HObjectEntry entry; if (img == null) return; HTuple classValue=null; HOperatorSet.GetObjClass(img, out classValue); if (!classValue.S.Equals("image")) { return; } HImage obj = new HImage(img); if (obj is HImage) { 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 (area == (w * h)) { clearList(); if ((h != imageHeight) || (w != imageWidth)) { imageHeight = h; imageWidth = w; zoomWndFactor = (double)imageWidth / viewPort.Width; setImagePart(0, 0, h, w); } }//if }//if entry = new HObjectEntry(obj, mGC.copyContextList()); HObjImageList.Add(entry); //ÿµ±´«Èë±³¾°Í¼µÄʱºò ¶¼Çå¿ÕHObjectList clearHObjectList(); if (HObjImageList.Count > MAXNUMOBJLIST) { //ÐèÒª×Ô¼ºÊÖ¶¯ÊÍ·Å ((HObjectEntry)HObjImageList[0]).clear(); HObjImageList.RemoveAt(1); } } /// /// Clears all entries from the graphics stack /// public void clearList() { HObjImageList.Clear(); } /// /// Returns the number of items on the graphics stack /// public int getListCount() { return HObjImageList.Count; } /// /// Changes the current graphical context by setting the specified mode /// (constant starting by GC_*) to the specified value. /// /// /// Constant that is provided by the class GraphicsContext /// and describes the mode that has to be changed, /// e.g., GraphicsContext.GC_COLOR /// /// /// Value, provided as a string, /// the mode is to be changed to, e.g., "blue" /// 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; } } /// /// Changes the current graphical context by setting the specified mode /// (constant starting by GC_*) to the specified value. /// /// /// Constant that is provided by the class GraphicsContext /// and describes the mode that has to be changed, /// e.g., GraphicsContext.GC_LINEWIDTH /// /// /// Value, provided as an integer, the mode is to be changed to, /// e.g., 5 /// 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; } } /// /// Changes the current graphical context by setting the specified mode /// (constant starting by GC_*) to the specified value. /// /// /// Constant that is provided by the class GraphicsContext /// and describes the mode that has to be changed, /// e.g., GraphicsContext.GC_LINESTYLE /// /// /// Value, provided as an HTuple instance, the mode is /// to be changed to, e.g., new HTuple(new int[]{2,2}) /// public void changeGraphicSettings(string mode, HTuple val) { switch (mode) { case GraphicsContext.GC_LINESTYLE: mGC.setLineStyleAttribute(val); break; default: break; } } /// /// Clears all entries from the graphical context list /// public void clearGraphicContext() { mGC.clear(); } /// /// Returns a clone of the graphical context list (hashtable) /// public Hashtable getGraphicContext() { return mGC.copyContextList(); } /// /// Registers an instance of an ROIController with this window /// controller (and vice versa). /// /// /// Controller that manages interactive ROIs for the HALCON window /// protected internal void setROIController(ROIController rC) { roiManager = rC; rC.setViewController(this); this.setViewState(HWndCtrl.MODE_VIEW_NONE); } /// /// Ìí¼ÓÉ趨ÏÔʾµÄͼÏñ /// /// protected internal void addImageShow(HObject image) { addIconicVar(image); } #region ÔÙ´ÎÏÔʾregionºÍ xld /// /// hObjectListÓÃÀ´´æ´¢´æÈëµÄHObject /// private List hObjectList = new List(); /// /// ĬÈϺìÑÕÉ«ÏÔʾ /// /// ´«ÈëµÄregion.xld,image public void DispObj(HObject hObj) { DispObj(hObj, null); } /// /// ÖØÐ¿ª±ÙÄÚ´æ±£´æ ·ÀÖ¹±»´«ÈëµÄHObjectÔÚÆäËûµØ·½disposeºó,²»ÄÜÖØÏÖ /// /// ´«ÈëµÄregion.xld,image /// ÑÕÉ« public void DispObj(HObject hObj, string color) { lock (this) { //ÏÔʾָ¶¨µÄÑÕÉ« if (color != null) { HOperatorSet.SetColor(viewPort.HalconWindow, color); } else { HOperatorSet.SetColor(viewPort.HalconWindow, "red"); } if (hObj != null && hObj.IsInitialized()) { // HObject temp = new HObject(hObj); // hObjectList.Add(new HObjectWithColor(temp, color)); viewPort.HalconWindow.DispObj(temp); } //»Ö¸´Ä¬ÈϵĺìÉ« HOperatorSet.SetColor(viewPort.HalconWindow, "red"); } } /// /// ÿ´Î´«Èëеı³¾°Imageʱ,Çå¿ÕhObjectList,±ÜÃâÄÚ´æÃ»Óб»ÊÍ·Å /// public void clearHObjectList() { foreach (HObjectWithColor hObjectWithColor in hObjectList) { hObjectWithColor.HObject.Dispose(); } hObjectList.Clear(); } /// /// ½«hObjectListÖеÄHObject,°´ÕÕÏȺó˳ÐòÏÔʾ³öÀ´ /// private void showHObjectList() { try { foreach (HObjectWithColor hObjectWithColor in hObjectList) { if (hObjectWithColor.Color != null) { HOperatorSet.SetColor(viewPort.HalconWindow, hObjectWithColor.Color); } else { HOperatorSet.SetColor(viewPort.HalconWindow, "red"); } if (hObjectWithColor != null && hObjectWithColor.HObject.IsInitialized()) { viewPort.HalconWindow.DispObj(hObjectWithColor.HObject); //»Ö¸´Ä¬ÈϵĺìÉ« HOperatorSet.SetColor(viewPort.HalconWindow, "red"); } } } catch (Exception e) { //ÓÐʱºòhobj±»disposeÁË,µ«ÊÇÆä±¾Éí²»Îªnull,´ËʱÔò±¨´í. ÒѾ­Ê¹ÓÃIsInitialized½â¾öÁË } } #endregion }//end of class }//end of namespace