using System;
|
using System.Collections;
|
using HalconDotNet;
|
using System.ComponentModel;
|
|
namespace HalconTools
|
{
|
public delegate void MatchingDelegate(int value);
|
public delegate void AutoParamDelegate(string value);
|
public delegate void FindShapeModelDelegate(object sender,HImage image, MatchingResult result);
|
|
[DefaultEvent("SetImageDone")]
|
/// <summary>
|
/// This is a controller class, which receives the
|
/// GUI component changes made by the user and forwards
|
/// the actions according to the internal settings.
|
/// To notify the GUI about semantic changes, we use two delegates. One
|
/// notifies about changes regarding the display objects
|
/// (like a change of image or change in model or contour). It is also used
|
/// to forward errors to the user, which might occur during a processing step.
|
/// The second delegate notifies the GUI to correct its sliders and trackbars
|
/// according to the new parameter setting, computed along with the
|
/// 'auto'-mechanism.
|
/// </summary>
|
public class MatchingAssistant
|
{
|
/// <summary>
|
/// Constant indicating that the model contour display should be
|
/// updated.
|
/// </summary>
|
public const int UPDATE_XLD = 0;
|
/// <summary>
|
/// Constant indicating that the pyramid (display-)level should be
|
/// updated.
|
/// </summary>
|
public const int UPDATE_DISPLEVEL = 1;
|
/// <summary>
|
/// Constant indicating that the pyramid should be updated.
|
/// </summary>
|
public const int UPDATE_PYRAMID = 2;
|
/// <summary>
|
/// Constant indicating that the detection results should be updated.
|
/// </summary>
|
public const int UPDATE_DETECTION_RESULT= 3;
|
/// <summary>
|
/// Constant indicating that the test image display should be updated.
|
/// </summary>
|
public const int UPDATE_TESTVIEW = 4;
|
|
/// <summary>
|
/// Constant indicating an error if a wrong file extension is used for
|
/// a model file.
|
/// </summary>
|
public const int ERR_NO_VALID_FILE = 5;
|
/// <summary>
|
/// Constant indicating an error when writing a model file
|
/// </summary>
|
public const int ERR_WRITE_SHAPEMODEL = 6;
|
/// <summary>
|
/// Constant indicating an error when reading from model file
|
/// </summary>
|
public const int ERR_READ_SHAPEMODEL = 7;
|
/// <summary>
|
/// Constant indicating an error if operations are performed that
|
/// need a shape-based model, though no model has been created, yet
|
/// </summary>
|
public const int ERR_NO_MODEL_DEFINED = 8;
|
/// <summary>
|
/// Constant indicating an error if operations are performed that
|
/// need a model image, though no model image has been loaded, yet
|
/// </summary>
|
public const int ERR_NO_IMAGE = 9;
|
/// <summary>
|
/// Constant indicating an error if operations are performed that
|
/// need test images, though no test image has been loaded, yet
|
/// </summary>
|
public const int ERR_NO_TESTIMAGE = 10;
|
/// <summary>
|
/// Constant indicating an error when reading an image file.
|
/// </summary>
|
public const int ERR_READING_IMG = 11;
|
/// <summary>
|
/// ָʾ²éÕÒ´íÎó
|
/// </summary>
|
public const int ERR_FINDSHAPEMODEL = 12;
|
/// <summary>
|
/// ´íÎóµÄ²ÎÊý
|
/// </summary>
|
public const int ERR_PARAMSET = 13;
|
|
/// <summary>
|
/// Region of interest defined by the sum of
|
/// the positive and negative ROIs
|
/// </summary>
|
private HRegion mROIModel;
|
|
/// <summary>Training image with full domain</summary>
|
private HImage oImage;
|
|
/// <summary>
|
/// ¸øFindShapeModelʹÓÃ
|
/// </summary>
|
private HImage OriginalImage;
|
|
readonly object someEventLock;
|
|
/// <summary>
|
/// The model image is the training image with
|
/// a domain reduced by the region mROIModel
|
/// </summary>
|
public HImage mImage;
|
|
/// <summary>
|
/// Test image in which the model is searched.
|
/// </summary>
|
public HImage tImage;
|
|
/// <summary>List of test images</summary>
|
public Hashtable TestImages;
|
|
//matching parameters
|
public MatchingParam parameterSet;
|
|
public MatchingParam getParameterSet
|
{
|
get
|
{
|
return parameterSet;
|
}
|
//set;
|
}
|
|
//matching result
|
public MatchingResult tResult;
|
//model handle
|
private HShapeModel ModelID;
|
//model handle FindShapeModelʹÓÃ
|
private HShapeModel[] FindShapeModelID;
|
//
|
public MatchingResult findShapeResult { get; set; }
|
|
// flags to control processing
|
private bool findAlways;
|
private bool createNewModelID;
|
|
//flags to control the inspection and recognition process
|
public bool onExternalModelID;
|
public bool onTimer = false;
|
|
// display purposes
|
private int oWidth;
|
private int oHeight;
|
private double scaleW = 1.0;
|
private double scaleH = 1.0;
|
|
private HImage PyramidImages;
|
private HRegion PyramidROIs;
|
private int currentImgLevel = 1; //mNumLevel
|
private int maxPyramidLevel = 6;
|
private HHomMat2D homSc2D;
|
|
/// <summary>Stores exception message for display</summary>
|
public string exceptionText = "";
|
|
|
// upper and lower range
|
private int contrastLowB;
|
private int contrastUpB;
|
private double scaleStepLowB;
|
private double scaleStepUpB;
|
private double angleStepLowB;
|
private double angleStepUpB;
|
private int pyramLevLowB;
|
private int pyramLevUpB;
|
private int minContrastLowB;
|
private int minContrastUpB;
|
|
// auxiliary value table to store intermediate states
|
private int mCachedNumLevel;
|
private double mCachedStartAng;
|
private double mCachedAngExt;
|
private double mCachedAngStep;
|
private double mCachedMinScale;
|
private double mCachedMaxScale;
|
private double mCachedScaleStep;
|
private string mCachedMetric;
|
private int mCachedMinCont;
|
|
|
|
/// <summary>
|
/// Delegate to forward changes for the display, which means changes
|
/// in the model contour, image level etc.
|
/// </summary>
|
public MatchingDelegate NotifyIconObserver;
|
/// <summary>
|
/// Delegate to forward changes in the matching parameters determined
|
/// with the 'auto-' mechanism
|
/// </summary>
|
public AutoParamDelegate NotifyParamObserver;
|
|
private MatchingDelegate NotifyIconObserverMessage;
|
|
/// <summary>
|
/// ͼÏñÉ趨Íê³Éʼþ
|
/// </summary>
|
public event SetImageDelegate SetImageDone;
|
|
/// <summary>
|
/// Æ¥ÅäÍê³Éʼþ
|
/// </summary>
|
public event FindShapeModelDelegate FindShapeModelDone;
|
|
/// <summary>
|
/// Initializes flags, lists, and delegates to have a valid
|
/// starting point to start the assistant.
|
/// </summary>
|
public MatchingAssistant(MatchingParam parSet)
|
{
|
parameterSet = parSet;
|
NotifyIconObserver = new MatchingDelegate(dummy);
|
NotifyParamObserver = new AutoParamDelegate(dummyS);
|
homSc2D = new HHomMat2D();
|
TestImages = new Hashtable(10);
|
tResult = new MatchingResult();
|
|
contrastLowB = 0;
|
contrastUpB = 255;
|
scaleStepLowB = 0.0;
|
scaleStepUpB = (double)19.0/1000.0;
|
angleStepLowB = 0.0;
|
angleStepUpB = (double)(112.0/10.0)*Math.PI/180.0;
|
pyramLevLowB = 1;
|
pyramLevUpB = 6;
|
minContrastLowB = 0;
|
minContrastUpB = 30;
|
|
findAlways = false;
|
createNewModelID = true;
|
ModelID = new HShapeModel();
|
onExternalModelID = false;
|
}
|
|
public MatchingAssistant(int num)
|
{
|
someEventLock = new object();
|
FindShapeModelID = new HShapeModel[num];
|
NotifyIconObserverMessage = new MatchingDelegate(UpdateMessage);
|
|
initMatch();
|
}
|
|
public MatchingAssistant()
|
{
|
someEventLock = new object();
|
FindShapeModelID = new HShapeModel[1];
|
NotifyIconObserverMessage = new MatchingDelegate(UpdateMessage);
|
|
initMatch();
|
}
|
|
private void initMatch()
|
{
|
tResult = new MatchingResult();
|
ModelID = new HShapeModel();
|
}
|
|
public void UpdateMessage(int val)
|
{
|
switch (val)
|
{
|
case MatchingAssistant.ERR_NO_MODEL_DEFINED:
|
System.Windows.Forms.MessageBox.Show("Please define a Model!",
|
"Matching Wizard",
|
System.Windows.Forms.MessageBoxButtons.OK,
|
System.Windows.Forms.MessageBoxIcon.Information);
|
break;
|
case MatchingAssistant.ERR_NO_IMAGE:
|
System.Windows.Forms.MessageBox.Show("Please load an image",
|
"Matching Wizard",
|
System.Windows.Forms.MessageBoxButtons.OK,
|
System.Windows.Forms.MessageBoxIcon.Information);
|
break;
|
case MatchingAssistant.ERR_NO_VALID_FILE:
|
System.Windows.Forms.MessageBox.Show("Selected file is not a HALCON ShapeModel file .shm",
|
"Matching Wizard",
|
System.Windows.Forms.MessageBoxButtons.OK,
|
System.Windows.Forms.MessageBoxIcon.Information);
|
break;
|
case MatchingAssistant.ERR_FINDSHAPEMODEL:
|
System.Windows.Forms.MessageBox.Show("Ä£°åÆ¥Åäʧ°Ü",
|
"Matching Wizard",
|
System.Windows.Forms.MessageBoxButtons.OK,
|
System.Windows.Forms.MessageBoxIcon.Information);
|
break;
|
case MatchingAssistant.ERR_PARAMSET:
|
System.Windows.Forms.MessageBox.Show("´íÎóµÄ²ÎÊýÉèÖÃ",
|
"Matching Wizard",
|
System.Windows.Forms.MessageBoxButtons.OK,
|
System.Windows.Forms.MessageBoxIcon.Information);
|
break;
|
default:
|
break;
|
}
|
}
|
|
/// <summary>Sets <c>image</c> to be the training image <c>oImage</c> </summary>
|
public void setImage(HImage image)
|
{
|
string tmp;
|
image.GetImagePointer1(out tmp,
|
out oWidth,
|
out oHeight);
|
|
oImage = image;
|
reset();
|
}
|
|
/// <summary>
|
/// Loads the training image from the file supplied by <c>filename</c>
|
/// </summary>
|
public bool setImage(string filename)
|
{
|
HImage image;
|
|
try
|
{
|
image = new HImage(filename);
|
setImage(image);
|
}
|
catch(HOperatorException e)
|
{
|
exceptionText = e.Message;
|
NotifyIconObserver(MatchingAssistant.ERR_READING_IMG);
|
return false;
|
}
|
|
return true;
|
}
|
|
/// <summary>
|
/// Compute the model image and the model contour for the applied ROI.
|
/// </summary>
|
public void setModelROI(HRegion roi)
|
{
|
mROIModel = roi;
|
PyramidROIs = null;
|
createNewModelID = true;
|
|
if(mROIModel==null)
|
{
|
mImage = null;
|
return;
|
}
|
|
mImage = oImage.ReduceDomain(mROIModel);
|
|
determineStepRanges();
|
|
if(parameterSet.isOnAuto())
|
determineShapeParameter();
|
|
inspectShapeModel();
|
}
|
|
/********************************************************************/
|
/* methods for test image */
|
/********************************************************************/
|
|
/// <summary>
|
/// Loads and adds test image files to the list of test images
|
/// </summary>
|
public bool addTestImages(string fileKey)
|
{
|
if(TestImages.ContainsKey(fileKey))
|
return false;
|
|
try
|
{
|
HImage image = new HImage(fileKey);
|
TestImages.Add(fileKey, image);
|
}
|
catch(HOperatorException e)
|
{
|
exceptionText = e.Message;
|
NotifyIconObserver(MatchingAssistant.ERR_READING_IMG);
|
return false;
|
}
|
return true;
|
}
|
|
/// <summary>
|
/// Sets an image from the list of test images to be the current
|
/// test image. The filename is given by the value fileKey.
|
/// </summary>
|
public void setTestImage(string fileKey)
|
{
|
tImage = (HImage)TestImages[fileKey];
|
NotifyIconObserver(MatchingAssistant.UPDATE_TESTVIEW);
|
}
|
|
/// <summary>
|
/// Removes an image from the list of test images,
|
/// using the file name
|
/// </summary>
|
public void removeTestImage(string fileName)
|
{
|
if(TestImages.ContainsKey(fileName))
|
TestImages.Remove(fileName);
|
|
if(TestImages.Count==0)
|
tImage = null;
|
}
|
|
/// <summary>
|
/// Removes all images from the list of test images
|
/// </summary>
|
public void removeTestImage()
|
{
|
TestImages.Clear();
|
tImage = null;
|
}
|
|
/// <summary>
|
/// Sets the current test image to the image defined by
|
/// <c>fileName</c> and return it
|
/// </summary>
|
public HImage getTestImage(string fileName)
|
{
|
if((tImage == null) && (TestImages.ContainsKey(fileName)))
|
tImage = (HImage)TestImages[fileName];
|
|
return tImage;
|
}
|
|
/// <summary>
|
/// Returns the current test image
|
/// </summary>
|
public HImage getCurrTestImage()
|
{
|
return tImage;
|
}
|
|
|
/******************************************************************/
|
/* auto options */
|
/******************************************************************/
|
|
/// <summary>
|
/// Adds the parameter name given by <c>mode</c>
|
/// to the list of matching parameters that are
|
/// set to be determined automatically
|
/// </summary>
|
public void setAuto(string mode)
|
{
|
if(parameterSet.setAuto(mode))
|
determineShapeParameter();
|
}
|
|
/// <summary>
|
/// Removes the parameter name given by <c>mode</c> from the
|
/// list of matching parameters that are determined
|
/// automatically
|
/// </summary>
|
public bool removeAuto(string mode)
|
{
|
return parameterSet.removeAuto(mode);
|
}
|
|
|
/************************ set matching values ********************/
|
/******************************************************************/
|
|
/// <summary>
|
/// Sets Contrast to the input value <c>val</c>
|
/// and recreates the model.
|
/// </summary>
|
public void setContrast(int val)
|
{
|
parameterSet.setContrast(val);
|
minContrastUpB = (int)val;
|
|
inspectShapeModel();
|
|
if(parameterSet.isOnAuto())
|
determineShapeParameter();
|
|
createNewModelID = true;
|
}
|
|
/// <summary>
|
/// Sets ScaleStep to the input value <c>val</c>
|
/// </summary>
|
public void setScaleStep(double val)
|
{
|
parameterSet.setScaleStep(val);
|
|
if(parameterSet.isOnAuto())
|
determineShapeParameter();
|
|
createNewModelID = true;
|
}
|
|
/// <summary>
|
/// Sets AngleStep to the input value <c>val</c>
|
/// </summary>
|
public void setAngleStep(double val)
|
{
|
parameterSet.setAngleStep(val);
|
|
if(parameterSet.isOnAuto())
|
determineShapeParameter();
|
|
createNewModelID = true;
|
}
|
|
/// <summary>
|
/// Sets PyramidLevel to the input value <c>val</c>
|
/// </summary>
|
public void setPyramidLevel(double val)
|
{
|
parameterSet.setNumLevel(val);
|
|
if(parameterSet.isOnAuto())
|
determineShapeParameter();
|
|
createNewModelID = true;
|
}
|
|
/// <summary>
|
/// Sets Optimization to the input value <c>val</c>
|
/// </summary>
|
public void setOptimization(string val)
|
{
|
parameterSet.setOptimization(val);
|
|
if(parameterSet.isOnAuto())
|
determineShapeParameter();
|
|
createNewModelID = true;
|
}
|
|
/// <summary>
|
/// Sets MinContrast to the input value <c>val</c>
|
/// </summary>
|
public void setMinContrast(int val)
|
{
|
parameterSet.setMinContrast(val);
|
|
if(parameterSet.isOnAuto())
|
determineShapeParameter();
|
|
createNewModelID = true;
|
}
|
|
/*******************************************************/
|
|
/// <summary>
|
/// Sets Metric to the input value <c>val</c>
|
/// </summary>
|
public void setMetric(string val)
|
{
|
parameterSet.setMetric(val);
|
createNewModelID = true;
|
}
|
|
/// <summary>
|
/// Sets MinScale to the input value <c>val</c>
|
/// </summary>
|
public void setMinScale(double val)
|
{
|
parameterSet.setMinScale(val);
|
createNewModelID = true;
|
}
|
|
/// <summary>
|
/// Sets MaxScale to the input value <c>val</c>
|
/// </summary>
|
public void setMaxScale(double val)
|
{
|
parameterSet.setMaxScale(val);
|
createNewModelID = true;
|
}
|
|
/// <summary>
|
/// Sets StartingAngle to the input value <c>val</c>
|
/// </summary>
|
public void setStartingAngle(double val)
|
{
|
parameterSet.setStartingAngle(val);
|
createNewModelID = true;
|
}
|
|
/// <summary>
|
/// Sets AngleExtent to the input value <c>val</c>
|
/// </summary>
|
public void setAngleExtent(double val)
|
{
|
parameterSet.setAngleExtent(val);
|
createNewModelID = true;
|
}
|
|
/// <summary>
|
/// Changes the currentImgLevel to the input parameter
|
/// <c>val</c> and triggers an update in the GUI display
|
/// </summary>
|
public void setDispLevel(int val)
|
{
|
this.currentImgLevel = val;
|
NotifyIconObserver(MatchingAssistant.UPDATE_DISPLEVEL);
|
}
|
|
/****************** set findmodel parameters *****************/
|
/**************************************************************/
|
/// <summary>
|
/// Sets MinScore to the input value and starts model detection
|
/// if the flag <c>findAlways</c> is checked
|
/// </summary>
|
public void setMinScore(double val)
|
{
|
parameterSet.setMinScore(val);
|
|
if(findAlways)
|
detectShapeModel();
|
}
|
|
/// <summary>
|
/// Sets NumMatches to the input value and starts model detection
|
/// if the flag <c>findAlways</c> is checked
|
/// </summary>
|
public void setNumMatches(int val)
|
{
|
parameterSet.setNumMatches(val);
|
|
if(findAlways)
|
detectShapeModel();
|
}
|
|
/// <summary>
|
/// Sets Greediness to the input value and starts model detection
|
/// if the flag <c>findAlways</c> is checked
|
/// </summary>
|
public void setGreediness(double val)
|
{
|
parameterSet.setGreediness(val);
|
|
if(findAlways)
|
detectShapeModel();
|
}
|
|
/// <summary>
|
/// Sets MaxOverlap to the input value and starts model detection
|
/// if the flag <c>findAlways</c> is checked
|
/// </summary>
|
public void setMaxOverlap(double val)
|
{
|
parameterSet.setMaxOverlap(val);
|
|
if(findAlways)
|
detectShapeModel();
|
}
|
|
/// <summary>
|
/// Sets SubPixel to the input value and starts model detection
|
/// if the flag <c>findAlways</c> is checked
|
/// </summary>
|
public void setSubPixel(string val)
|
{
|
parameterSet.setSubPixel(val);
|
|
if(findAlways)
|
detectShapeModel();
|
}
|
|
/// <summary>
|
/// Sets LastPyramLevel to the input value and starts model detection
|
/// if the flag <c>findAlways</c> is checked
|
/// </summary>
|
public void setLastPyramLevel(int val)
|
{
|
parameterSet.setLastPyramLevel(val);
|
|
if(findAlways)
|
detectShapeModel();
|
}
|
|
/// <summary>
|
/// Sets the flag <c>findAlways</c> to the input value <c>flag</c>
|
/// </summary>
|
public void setFindAlways(bool flag)
|
{
|
findAlways = flag;
|
|
if(findAlways && tImage != null)
|
detectShapeModel();
|
}
|
|
/// <summary>
|
/// Triggers model detection, if a test image is defined
|
/// </summary>
|
public bool applyFindModel()
|
{
|
bool success = false;
|
|
if(tImage != null)
|
success = detectShapeModel();
|
else
|
NotifyIconObserver(MatchingAssistant.ERR_NO_TESTIMAGE);
|
|
return success;
|
}
|
|
/// <summary>
|
/// Gets detected model contours
|
/// </summary>
|
public HXLD getDetectionResults()
|
{
|
return tResult.getDetectionResults();
|
}
|
|
/// <summary>
|
/// Gets matching results
|
/// </summary>
|
public MatchingResult getMatchingResults()
|
{
|
return tResult;
|
}
|
|
/******************** optimize recognition speed *****************/
|
/******************************************************************/
|
|
/// <summary>
|
/// Sets the RecognitionRateOption to the input
|
/// value <c>idx</c>
|
/// </summary>
|
public void setRecogRateOption(int idx)
|
{
|
parameterSet.setRecogRateOption(idx);
|
}
|
|
/// <summary>
|
/// Sets the RecognitionRate to the input value <c>val</c>
|
/// </summary>
|
public void setRecogitionRate(int val)
|
{
|
parameterSet.setRecogitionRate(val);
|
}
|
|
/// <summary>
|
/// Sets the RecognitionSpeedMode to the input
|
/// value <c>val</c>
|
/// </summary>
|
public void setRecogSpeedMode(string val)
|
{
|
parameterSet.setRecogSpeedMode(val);
|
}
|
|
/// <summary>
|
/// Sets the RecognitionManualSelection to the input .
|
/// value <c>val</c>
|
/// </summary>
|
public void setRecogManualSelection(int val)
|
{
|
parameterSet.setRecogManualSelection(val);
|
}
|
|
|
/********************************************************************/
|
/* getter methods */
|
/********************************************************************/
|
|
/// <summary>
|
/// Gets the model for the current image level
|
/// </summary>
|
public HXLD getModelContour()
|
{
|
if(PyramidROIs==null)
|
return null;
|
|
homSc2D.HomMat2dIdentity();
|
homSc2D = homSc2D.HomMat2dScaleLocal(scaleW, scaleH);
|
|
return ((PyramidROIs.SelectObj(currentImgLevel)).
|
GenContourRegionXld("center")).
|
AffineTransContourXld(homSc2D);
|
}
|
|
/// <summary>
|
/// Gets the model supplied by a loaded shapebased model file (.shm)
|
/// </summary>
|
public HXLD getLoadedModelContour()
|
{
|
HTuple row1, col1, row2, col2, row, col;
|
HHomMat2D homMat2D = new HHomMat2D();
|
|
try
|
{
|
tResult.mContour.SmallestRectangle1Xld(out row1, out col1, out row2, out col2);
|
row2 = row1.TupleMin();
|
col2 = col1.TupleMin();
|
row = row2.TupleFloor()-5;
|
col = col2.TupleFloor()-5;
|
homMat2D.HomMat2dIdentity();
|
homMat2D = homMat2D.HomMat2dTranslate(-row,-col);
|
|
return homMat2D.AffineTransContourXld(tResult.mContour);
|
}
|
catch(HOperatorException e)
|
{
|
exceptionText = e.Message;
|
NotifyIconObserver(MatchingAssistant.ERR_READ_SHAPEMODEL);
|
return null;
|
}
|
}
|
|
/// <summary>
|
/// Gets the model region for the current image level.
|
/// </summary>
|
public HRegion getModelRegion()
|
{
|
if(PyramidROIs==null)
|
return null;
|
|
HRegion reg = PyramidROIs.SelectObj(currentImgLevel);
|
return reg.ZoomRegion(scaleW, scaleH);
|
}
|
|
/// <summary>
|
/// Gets the model image for the current image level.
|
/// </summary>
|
public HImage getDispImage()
|
{
|
int fW, fH;
|
string tmp;
|
|
if (PyramidImages ==null)
|
return oImage;
|
|
HImage img = PyramidImages.SelectObj(currentImgLevel);
|
img.GetImagePointer1(out tmp, out fW, out fH);
|
|
scaleW = (double)oWidth/fW;
|
scaleH = (double)oHeight/fH;
|
|
return img.ZoomImageFactor(scaleW, scaleH, "nearest_neighbor");
|
}
|
|
/// <summary>
|
/// Clears all model creation and detection results
|
/// and resets flags to their initial values.
|
/// </summary>
|
public void reset()
|
{
|
mROIModel = null;
|
currentImgLevel = 1;
|
PyramidROIs = null;
|
PyramidImages = null;
|
mImage = null;
|
scaleH = 1;
|
scaleW = 1;
|
createNewModelID = true;
|
|
tResult.reset();
|
NotifyIconObserver(MatchingAssistant.UPDATE_XLD);
|
}
|
|
|
/********************************************************************/
|
/********************************************************************/
|
|
/// <summary>
|
/// Writes model to the file specified by <c>fileName</c>.
|
/// </summary>
|
public void saveShapeModel(string fileName)
|
{
|
if(mImage == null)
|
{
|
NotifyIconObserver(MatchingAssistant.ERR_NO_MODEL_DEFINED);
|
return;
|
}
|
|
if (createNewModelID)
|
if (!createShapeModel())
|
return;
|
try
|
{
|
ModelID.WriteShapeModel(fileName);
|
}
|
catch(HOperatorException e)
|
{
|
exceptionText = e.Message;
|
NotifyIconObserver(MatchingAssistant.ERR_WRITE_SHAPEMODEL);
|
}
|
}
|
|
/// <summary>
|
/// Loads model from the file specified by <c>fileName</c>
|
/// </summary>
|
public bool loadShapeModel(string fileName)
|
{
|
onExternalModelID = false;
|
|
try
|
{
|
ModelID.ReadShapeModel(fileName);
|
}
|
catch(HOperatorException e)
|
{
|
exceptionText = e.Message;
|
NotifyIconObserver(MatchingAssistant.ERR_READ_SHAPEMODEL);
|
return false;
|
}
|
|
onExternalModelID = true;
|
tResult.mContour = ModelID.GetShapeModelContours(1);
|
|
cacheModelParams();
|
|
parameterSet.mNumLevel = ModelID.GetShapeModelParams(out parameterSet.mStartingAngle,
|
out parameterSet.mAngleExtent,
|
out parameterSet.mAngleStep,
|
out parameterSet.mMinScale,
|
out parameterSet.mMaxScale,
|
out parameterSet.mScaleStep,
|
out parameterSet.mMetric,
|
out parameterSet.mMinContrast);
|
return true;
|
}
|
|
/***************************************************************/
|
/***************************************************************/
|
private void cacheModelParams()
|
{
|
mCachedNumLevel = parameterSet.mNumLevel;
|
mCachedStartAng = parameterSet.mStartingAngle;
|
mCachedAngExt = parameterSet.mAngleExtent;
|
mCachedAngStep = parameterSet.mAngleStep;
|
mCachedMinScale = parameterSet.mMinScale;
|
mCachedMaxScale = parameterSet.mMaxScale;
|
mCachedScaleStep = parameterSet.mScaleStep;
|
mCachedMetric = parameterSet.mMetric;
|
mCachedMinCont = parameterSet.mMinContrast;
|
}
|
|
|
public void resetCachedModelParams()
|
{
|
parameterSet.mNumLevel = mCachedNumLevel;
|
parameterSet.mStartingAngle = mCachedStartAng;
|
parameterSet.mAngleExtent = mCachedAngExt;
|
parameterSet.mAngleStep = mCachedAngStep;
|
parameterSet.mMinScale = mCachedMinScale;
|
parameterSet.mMaxScale = mCachedMaxScale;
|
parameterSet.mScaleStep = mCachedScaleStep;
|
parameterSet.mMetric = mCachedMetric;
|
parameterSet.mMinContrast = mCachedMinCont;
|
createNewModelID = true;
|
}
|
|
/// <summary>
|
/// Creates the shape-based model. If the region of interest
|
/// <c>mROIModel</c> is missing or not well defined using the
|
/// interactive ROIs, then an error message is returned.
|
/// </summary>
|
public bool createShapeModel()
|
{
|
if(mImage==null)
|
{
|
if(!onTimer)
|
NotifyIconObserver(MatchingAssistant.ERR_NO_MODEL_DEFINED);
|
return false;
|
}
|
|
try
|
{
|
ModelID = mImage.CreateScaledShapeModel(parameterSet.mNumLevel,
|
parameterSet.mStartingAngle,
|
parameterSet.mAngleExtent,
|
parameterSet.mAngleStep,
|
parameterSet.mMinScale,
|
parameterSet.mMaxScale,
|
parameterSet.mScaleStep,
|
parameterSet.mOptimization,
|
parameterSet.mMetric,
|
parameterSet.mContrast,
|
parameterSet.mMinContrast);
|
}
|
catch(HOperatorException e)
|
{
|
|
if(!onTimer)
|
{
|
exceptionText = e.Message;
|
NotifyParamObserver(MatchingParam.H_ERR_MESSAGE);
|
}
|
return false;
|
}
|
|
tResult.mContour = ModelID.GetShapeModelContours(1);
|
|
createNewModelID = false;
|
return true;
|
}
|
|
/// <summary>
|
/// Finds the model in the test image. If the model
|
/// hasn't been created or needs to be recreated (due to
|
/// user changes made to the GUI components),
|
/// then the model is created first.
|
/// </summary>
|
public bool detectShapeModel()
|
{
|
HTuple levels, rtmp;
|
rtmp = new HTuple();
|
double t2, t1;
|
|
if(tImage == null)
|
return false;
|
|
if(createNewModelID && !onExternalModelID)
|
if(!createShapeModel())
|
return false;
|
|
try
|
{
|
levels = new HTuple(new int [] {parameterSet.mNumLevel,
|
parameterSet.mLastPyramidLevel});
|
t1 = HSystem.CountSeconds();
|
tImage.FindScaledShapeModel(ModelID,
|
parameterSet.mStartingAngle,
|
parameterSet.mAngleExtent,
|
parameterSet.mMinScale,
|
parameterSet.mMaxScale,
|
parameterSet.mMinScore,
|
parameterSet.mNumMatches,
|
parameterSet.mMaxOverlap,
|
new HTuple(parameterSet.mSubpixel),
|
levels,
|
parameterSet.mGreediness,
|
out tResult.mRow,
|
out tResult.mCol,
|
out tResult.mAngle,
|
out tResult.mScaleRow,
|
out tResult.mScore);
|
t2 = HSystem.CountSeconds();
|
tResult.mTime = 1000.0 * (t2 - t1);
|
tResult.count = tResult.mRow.Length;
|
tResult.mScaleCol = tResult.mScaleRow;
|
}
|
catch(HOperatorException e)
|
{
|
if(!onTimer)
|
{
|
exceptionText = e.Message;
|
NotifyParamObserver(MatchingParam.H_ERR_MESSAGE);
|
}
|
|
return false;
|
}
|
|
if (NotifyIconObserver != null) NotifyIconObserver(MatchingAssistant.UPDATE_DETECTION_RESULT);
|
if (FindShapeModelDone != null)FindShapeModelDone(this, tImage, tResult);
|
|
return true;
|
}
|
|
/// <summary>
|
/// É趨ͼÏñ,ºóÐøFindShapeModelʹÓÃ
|
/// </summary>
|
/// <param name="image"></param>
|
/// <returns></returns>
|
public bool SetImage_FindShapeModel(HImage image)
|
{
|
lock (someEventLock)
|
{
|
if (image != null)
|
{
|
OriginalImage = image;
|
|
if (SetImageDone != null)
|
{
|
SetImageDone(this,OriginalImage);
|
}
|
|
return OriginalImage.IsInitialized();
|
}
|
else
|
{
|
NotifyIconObserver(MatchingAssistant.ERR_NO_IMAGE);
|
return false;
|
}
|
}
|
}
|
|
/// <summary>
|
/// ʹÓÃÖ¸¶¨µÄÄ£°åIDÔÚSetImage_FindShapeModelÉ趨µÄͼÏñÖвéÕÒÄ¿±ê
|
/// </summary>
|
/// <param name="IDindext">Ö¸¶¨Ä£°åID±àºÅ</param>
|
/// <param name="parameterSet">²ÎÊý</param>
|
/// <returns></returns>
|
public MatchingResult FindShapeModel(int IDindext, MatchingParamSave parameterSet)
|
{
|
HTuple levels;
|
double t2, t1;
|
MatchingResult result = new MatchingResult();
|
|
if (OriginalImage == null)
|
{
|
if (NotifyIconObserverMessage != null)
|
{
|
NotifyIconObserverMessage(MatchingAssistant.ERR_NO_IMAGE);
|
}
|
|
if (NotifyIconObserver != null)
|
{
|
NotifyIconObserver(MatchingAssistant.ERR_NO_IMAGE);
|
}
|
|
return result;
|
}
|
|
if (parameterSet == null)
|
{
|
if (NotifyIconObserverMessage != null)
|
{
|
NotifyIconObserverMessage(MatchingAssistant.ERR_PARAMSET);
|
}
|
|
if (NotifyIconObserver != null)
|
{
|
NotifyIconObserver(MatchingAssistant.ERR_PARAMSET);
|
}
|
return result;
|
}
|
|
if (FindShapeModelID[IDindext] == null)
|
{
|
if (NotifyIconObserverMessage != null)
|
{
|
NotifyIconObserverMessage(MatchingAssistant.ERR_NO_MODEL_DEFINED);
|
}
|
|
if (NotifyIconObserver != null)
|
{
|
NotifyIconObserver(MatchingAssistant.ERR_NO_MODEL_DEFINED);
|
}
|
|
return result;
|
}
|
|
try
|
{
|
lock (someEventLock)
|
{
|
result.mContour = FindShapeModelID[IDindext].GetShapeModelContours(1);
|
|
levels = new HTuple(new int[] {parameterSet.NumLevel,
|
parameterSet.LastPyramidLevel});
|
t1 = HSystem.CountSeconds();
|
OriginalImage.FindScaledShapeModel(FindShapeModelID[IDindext],
|
parameterSet.StartingAngle,
|
parameterSet.AngleExtent,
|
parameterSet.MinScale,
|
parameterSet.MaxScale,
|
parameterSet.MinScore,
|
parameterSet.NumMatches,
|
parameterSet.MaxOverlap,
|
new HTuple(parameterSet.Subpixel),
|
levels,
|
parameterSet.Greediness,
|
out result.mRow,
|
out result.mCol,
|
out result.mAngle,
|
out result.mScaleRow,
|
out result.mScore);
|
|
t2 = HSystem.CountSeconds();
|
result.mTime = 1000.0 * (t2 - t1);
|
result.count = result.mRow.Length;
|
result.mScaleCol = result.mScaleRow;
|
}
|
|
if (FindShapeModelDone != null)
|
{
|
FindShapeModelDone(this, OriginalImage,result);
|
}
|
}
|
catch (HOperatorException e)
|
{
|
if (NotifyIconObserverMessage != null)
|
{
|
NotifyIconObserverMessage(MatchingAssistant.ERR_FINDSHAPEMODEL);
|
}
|
|
if (NotifyIconObserver != null)
|
{
|
NotifyIconObserver(MatchingAssistant.ERR_FINDSHAPEMODEL);
|
}
|
return result;
|
}
|
|
return result;
|
}
|
|
/// <summary>
|
/// ÔÚÖ¸¶¨´°ÌåÖÐÏÔʾƥÅäµ½µÄ½á¹û
|
/// </summary>
|
/// <param name="viewPort">ͼÏñÏÔʾ´°Ìå</param>
|
/// <param name="CurrentImg">ͼÏñ</param>
|
/// <param name="result">Æ¥Åä½á¹û</param>
|
public void FindModelGraphics(HalconDotNet.HWindowControl viewPort, HImage CurrentImg,MatchingResult result)
|
{
|
//Window control that manages visualization
|
HWndCtrl mView = new HWndCtrl(viewPort);
|
|
mView.resetAll();
|
mView.repaint();
|
|
mView.clearList();
|
mView.changeGraphicSettings(GraphicsContext.GC_LINESTYLE, new HTuple());
|
mView.addIconicVar(CurrentImg);
|
HXLD DetectionContour = result.getDetectionResults();
|
if (DetectionContour != null)
|
{
|
mView.changeGraphicSettings(GraphicsContext.GC_COLOR, "green");
|
mView.changeGraphicSettings(GraphicsContext.GC_LINEWIDTH, 2);
|
mView.addIconicVar(DetectionContour);
|
mView.repaint();
|
}
|
}
|
|
public void FindModelGraphics_1(HalconDotNet.HWindowControl hDisplayControl, HImage CurrentImg, MatchingResult result)
|
{
|
hDisplayControl.HalconWindow.ClearWindow();
|
|
hDisplayControl.HalconWindow.DispImage(CurrentImg);
|
|
HXLD DetectionContour = result.getDetectionResults();
|
if (DetectionContour != null)
|
{
|
hDisplayControl.HalconWindow.SetColor("green");
|
hDisplayControl.HalconWindow.SetLineWidth(1);
|
hDisplayControl.HalconWindow.DispXld(DetectionContour);
|
//hDisplayControl.HalconWindow.DispObj(DetectionContour);
|
}
|
|
|
//ViewROI.HWndCtrl mView = new HWndCtrl(viewPort);
|
|
//mView.resetAll();
|
//mView.repaint();
|
|
//mView.clearList();
|
//mView.changeGraphicSettings(GraphicsContext.GC_LINESTYLE, new HTuple());
|
//mView.addIconicVar(CurrentImg);
|
//HXLD DetectionContour = result.getDetectionResults();
|
//if (DetectionContour != null)
|
//{
|
// mView.changeGraphicSettings(GraphicsContext.GC_COLOR, "green");
|
// mView.changeGraphicSettings(GraphicsContext.GC_LINEWIDTH, 2);
|
// mView.addIconicVar(DetectionContour);
|
// mView.repaint();
|
//}
|
}
|
|
|
/// <summary>
|
/// ¶ÁÈ¡Ä£°åÎļþ
|
/// </summary>
|
/// <param name="indext">Ä£°å±àºÅ</param>
|
/// <param name="fileName">Ä£°åÎļþÍêÕû·¾¶</param>
|
/// <returns></returns>
|
public bool ReadShapeModel(int indext,string fileName)
|
{
|
FindShapeModelID[indext] = null;
|
try
|
{
|
FindShapeModelID[indext] = new HShapeModel();
|
FindShapeModelID[indext].ReadShapeModel(fileName);
|
}
|
catch (HOperatorException e)
|
{
|
if (NotifyIconObserverMessage != null)
|
{
|
NotifyIconObserverMessage(MatchingAssistant.ERR_READ_SHAPEMODEL);
|
}
|
|
if (NotifyIconObserver != null)
|
{
|
NotifyIconObserver(MatchingAssistant.ERR_READ_SHAPEMODEL);
|
}
|
|
return false;
|
}
|
|
return true;
|
}
|
|
|
/// <summary>
|
/// Creates the model contour.
|
/// </summary>
|
public void inspectShapeModel()
|
{
|
HRegion tmpReg;
|
HImage tmpImg;
|
|
if(mImage == null)
|
{
|
NotifyIconObserver(MatchingAssistant.ERR_NO_MODEL_DEFINED);
|
return;
|
}
|
|
PyramidImages = oImage.InspectShapeModel(out tmpReg,
|
(int)maxPyramidLevel,
|
parameterSet.mContrast);
|
tmpImg = mImage.InspectShapeModel(out PyramidROIs,
|
(int)maxPyramidLevel,
|
parameterSet.mContrast);
|
|
NotifyIconObserver(MatchingAssistant.UPDATE_XLD);
|
NotifyIconObserver(MatchingAssistant.UPDATE_PYRAMID);
|
}
|
|
/// <summary>
|
/// Adjusts the range of ScaleStep and AngleStep according to the
|
/// current set of matching parameters.
|
/// </summary>
|
public void determineStepRanges()
|
{
|
double vald = 0.0;
|
HTuple paramValue = new HTuple();
|
HTuple paramList = new HTuple();
|
string [] paramRange = {"scale_step", "angle_step"};
|
|
if(mImage == null)
|
{
|
NotifyIconObserver(MatchingAssistant.ERR_NO_MODEL_DEFINED);
|
return;
|
}
|
|
try
|
{
|
paramList = mImage.DetermineShapeModelParams(parameterSet.mNumLevel,
|
(double)parameterSet.mStartingAngle,
|
(double)parameterSet.mAngleExtent,
|
parameterSet.mMinScale,
|
parameterSet.mMaxScale,
|
parameterSet.mOptimization,
|
parameterSet.mMetric,
|
(int)parameterSet.mContrast,
|
(int)parameterSet.mMinContrast,
|
paramRange,
|
out paramValue);
|
}
|
catch(HOperatorException e)
|
{
|
exceptionText = e.Message;
|
NotifyParamObserver(MatchingParam.H_ERR_MESSAGE);
|
return;
|
}
|
|
for(int i =0; i<paramList.Length; i++)
|
{
|
switch ((string)paramList[i])
|
{
|
case MatchingParam.AUTO_ANGLE_STEP:
|
vald = (double)paramValue[i];
|
|
angleStepUpB = vald * 3.0;
|
angleStepLowB = vald / 3.0;
|
parameterSet.mAngleStep = vald;
|
NotifyParamObserver(MatchingParam.RANGE_ANGLE_STEP);
|
break;
|
case MatchingParam.AUTO_SCALE_STEP:
|
vald = (double)paramValue[i];
|
|
scaleStepUpB = vald * 3.0;
|
scaleStepLowB = vald / 3.0;
|
parameterSet.mScaleStep = vald;
|
NotifyParamObserver(MatchingParam.RANGE_SCALE_STEP);
|
break;
|
default:
|
break;
|
}//end of switch
|
}//end of for
|
}
|
|
|
/// <summary>
|
/// Determines the values for the matching parameters
|
/// contained in the auto-list automatically.
|
/// </summary>
|
public void determineShapeParameter()
|
{
|
double vald;
|
int vali, count;
|
HTuple paramValue = new HTuple();
|
HTuple paramList = new HTuple();
|
|
if(mImage == null)
|
{
|
NotifyIconObserver(MatchingAssistant.ERR_NO_MODEL_DEFINED);
|
return;
|
}
|
|
try
|
{
|
paramList = mImage.DetermineShapeModelParams(parameterSet.mNumLevel,
|
(double)parameterSet.mStartingAngle,
|
(double)parameterSet.mAngleExtent,
|
parameterSet.mMinScale,
|
parameterSet.mMaxScale,
|
parameterSet.mOptimization,
|
parameterSet.mMetric,
|
(int)parameterSet.mContrast,
|
(int)parameterSet.mMinContrast,
|
parameterSet.getAutoParList(),
|
out paramValue);
|
}
|
catch(HOperatorException e)
|
{
|
exceptionText = e.Message;
|
NotifyParamObserver(MatchingParam.H_ERR_MESSAGE);
|
return;
|
}
|
|
count = paramList.Length;
|
|
for(int i =0; i<count; i++)
|
{
|
switch ((string)paramList[i])
|
{
|
case MatchingParam.AUTO_ANGLE_STEP:
|
vald = (double)paramValue[i];
|
|
if(vald > angleStepUpB)
|
vald = angleStepUpB;
|
else if(vald < angleStepLowB)
|
vald = angleStepLowB;
|
|
parameterSet.mAngleStep = vald;
|
break;
|
case MatchingParam.AUTO_CONTRAST:
|
vali = (int)paramValue[i];
|
|
if(vali > contrastUpB)
|
vali = contrastUpB;
|
else if (vali < contrastLowB)
|
vali = contrastLowB;
|
|
minContrastUpB = vali;
|
parameterSet.mContrast= vali;
|
|
inspectShapeModel();
|
break;
|
case MatchingParam.AUTO_MIN_CONTRAST:
|
vali = (int)paramValue[i];
|
|
if(vali > minContrastUpB)
|
vali = minContrastUpB;
|
else if(vali < minContrastLowB)
|
vali = minContrastLowB;
|
|
parameterSet.mMinContrast = vali;
|
break;
|
case MatchingParam.AUTO_NUM_LEVEL:
|
vali = (int)paramValue[i];
|
|
if(vali > pyramLevUpB)
|
vali = pyramLevUpB;
|
else if(vali < pyramLevLowB)
|
vali = pyramLevLowB;
|
|
parameterSet.mNumLevel = vali;
|
break;
|
case MatchingParam.AUTO_OPTIMIZATION:
|
parameterSet.mOptimization = (string)paramValue[i];
|
break;
|
case MatchingParam.AUTO_SCALE_STEP:
|
vald = (double)paramValue[i];
|
|
if(vald > scaleStepUpB)
|
vald = scaleStepUpB;
|
else if (vald < scaleStepLowB)
|
vald = scaleStepLowB;
|
|
parameterSet.mScaleStep = vald;
|
break;
|
default:
|
break;
|
}
|
NotifyParamObserver((string)paramList[i]);
|
}//end of for
|
|
if (count!=0)
|
createNewModelID = true;
|
}
|
|
/// <summary>
|
/// Gets the range of either one of the parameters
|
/// AngleStep and ScaleStep, defined by <c>param</c>
|
/// </summary>
|
public int [] getStepRange(string param)
|
{
|
int [] range = new int[2];
|
|
switch (param)
|
{
|
case MatchingParam.RANGE_ANGLE_STEP:
|
range [0] = (int)(angleStepLowB * 10.0 *180.0/Math.PI); //low
|
range [1] = (int)(angleStepUpB * 10.0 *180.0/Math.PI); //up
|
break;
|
case MatchingParam.RANGE_SCALE_STEP:
|
range [0] = (int) (scaleStepLowB * 1000.0); //low
|
range [1] = (int) (scaleStepUpB * 1000.0); //up
|
break;
|
default:
|
break;
|
}
|
return range;
|
}
|
|
/********************************************************************/
|
/********************************************************************/
|
private void dummy(int val)
|
{
|
return;
|
}
|
private void dummyS(string val)
|
{
|
return;
|
}
|
|
public void LoadPara(string path)
|
{
|
MatchingParamSave paraSave = new MatchingParamSave();
|
paraSave = paraSave.Load(path);
|
this.parameterSet = paraSave.TranParam(paraSave);
|
}
|
|
}//end of class
|
}//end of namespace
|
