using System;
|
using HalconDotNet;
|
using System.Collections;
|
|
namespace HalconTools
|
{
|
public delegate void MeasureDelegate(int value);
|
|
/// <summary>
|
/// The controller class MeasureAssistant controls
|
/// the communication between the GUI and the model data that
|
/// is used to parameterize the measuring.
|
/// </summary>
|
public class MeasureAssistant
|
{
|
/// <summary>Index of the selected ROI.</summary>
|
public int mActRoiIdx;
|
|
/// <summary>Reference to the ROI controller instance.</summary>
|
private ROIController roiController;
|
|
/// <summary>List of measure handles created for the list of ROIs.</summary>
|
private ArrayList mMeasureList;
|
|
/// <summary>Reference to list of ROI instances.</summary>
|
private ArrayList mROIList;
|
|
/// <summary>HALCON image used for measuring.</summary>
|
public HImage mImage;
|
public int mWidth;
|
public int mHeight;
|
|
/// <summary>Flag indicating whether measurements are performed between
|
/// individual edges or edge pairs.</summary>
|
public bool mSelPair;
|
|
/// <summary>Minimum edge amplitude.</summary>
|
public double mThresh;
|
|
/// <summary>Sigma of Gaussian smoothing.</summary>
|
public double mSigma;
|
|
/// <summary>
|
/// Width of the measure ROI (circular ROI: radius (half width) of the
|
/// annulus; linear ROI: half height of the rectangle).
|
/// </summary>
|
public double mRoiWidth;
|
|
public double mRoiHeight;
|
|
/// <summary>Default value for the minimum edge amplitude.</summary>
|
public double mInitThresh;
|
|
/// <summary>Default value for the sigma of Gaussian smoothing.</summary>
|
public double mInitSigma;
|
|
/// <summary>Default value for the ROI width.</summary>
|
public double mInitRoiWidth;
|
|
/// <summary>
|
/// Type of gray-value transition; determines how edges are
|
/// selected (dark-light or light-dark transition).
|
/// </summary>
|
public string mTransition;
|
|
/// <summary>Position of edges to select.</summary>
|
public string mPosition;
|
|
/// <summary>Type of interpolation to be used.</summary>
|
public string mInterpolation;
|
|
/// <summary>
|
/// Length of the displayed edges.
|
/// </summary>
|
public int mDispEdgeLength;
|
|
/// <summary>Error messages for failed measure actions.</summary>
|
public HTuple exceptionText;
|
|
/// <summary>
|
/// Flag indicating whether files with internal camera parameters
|
/// and camera pose are present and valid.
|
/// </summary>
|
public bool mIsCalibValid;
|
|
/// <summary>
|
/// Flag indicating whether measure results should be transformed
|
/// into world coordinates.
|
/// </summary>
|
public bool mTransWorldCoord;
|
|
/// <summary>
|
/// Flag indicating whether the ROI width should be used for
|
/// displaying the extracted edges (instead of mDispEdgeLength).
|
/// </summary>
|
public bool mDispROIWidth;
|
|
/// <summary>
|
/// Flag to add position coordinates of the detected (and
|
/// selected) edges to the result table.
|
/// </summary>
|
public bool mDispPosition;
|
|
/// <summary>
|
/// Flag to add the pair width of the detected edge (and
|
/// selected) pairs to the result table.
|
/// </summary>
|
public bool mDispPairWidth;
|
|
/// <summary>
|
/// Flag to add the edge amplitude of the detected (and
|
/// selected) edge pairs to the result table.
|
/// </summary>
|
public bool mDispAmplitude;
|
|
/// <summary>
|
/// Flag to add the distance between consecutive detected (and
|
/// selected) edges to the result table.
|
/// </summary>
|
public bool mDispDistance;
|
|
/// <summary>File with internal camera parameters.</summary>
|
public HTuple mCamParameter;
|
|
/// <summary>Camera pose file.</summary>
|
public HTuple mCamPose;
|
|
/// <summary>Unit for transformation into world coordinates.</summary>
|
public string mUnit;
|
|
/// <summary>Constant indicating an update of measure instances.</summary>
|
public const int EVENT_UPDATE_MEASUREMENT = 2;
|
|
/// <summary>
|
/// Constant indicating the removal of measure instances from the
|
/// measure list mMeasureList.
|
/// </summary>
|
public const int EVENT_UPDATE_REMOVE = 3;
|
|
/// <summary>Constant indicating an update of measure results.</summary>
|
public const int EVENT_UPDATE_RESULT_XLD = 4;
|
|
/// <summary>Auxiliary constant.</summary>
|
public const int ALL_ROI =-1;
|
|
/// <summary>
|
/// Constant indicating an error while reading an image file.</summary>
|
public const int ERR_READING_FILE = 10;
|
|
|
public MeasureDelegate NotifyMeasureObserver;
|
|
|
/* To create the measure controller class the ROI
|
controller has to be provided for initialization */
|
public MeasureAssistant(ROIController CRoi)
|
{
|
exceptionText = "";
|
roiController = CRoi;
|
mROIList = roiController.getROIList();
|
mMeasureList = new ArrayList(15);
|
mIsCalibValid = false;
|
mActRoiIdx = -1;
|
}
|
|
/*********************************************************/
|
/* setter-methods */
|
/*********************************************************/
|
|
/// <summary>
|
/// Sets a flag to determine if measure detection is calculated
|
/// for edges or edge pairs
|
/// </summary>
|
public void setSelPair(bool mode)
|
{
|
mSelPair = mode;
|
UpdateMeasure();
|
mActRoiIdx = roiController.getActiveROIIdx();
|
}
|
|
/// <summary>
|
/// Sets the variable mThresh to the provided value and
|
/// triggers an update for the measure results
|
/// </summary>
|
public void setMinEdgeAmpl(double val)
|
{
|
mThresh = val;
|
UpdateExecute(ALL_ROI);
|
}
|
|
/// <summary>
|
/// Sets the variable mSigma to the provided value and
|
/// triggers an update for the measure results
|
/// </summary>
|
public void setSigma(double val)
|
{
|
mSigma = val;
|
UpdateExecute(ALL_ROI);
|
}
|
|
/// <summary>
|
/// Sets the variable mRoiWidth to the provided value and
|
/// triggers an update for the measure results
|
/// </summary>
|
public void setRoiWidth(double val)
|
{
|
mRoiWidth = val;
|
UpdateMeasure(ALL_ROI);
|
}
|
|
public void setRoiHeight(double val)
|
{
|
mRoiHeight = val;
|
UpdateMeasure(ALL_ROI);
|
}
|
|
/// <summary>
|
/// Sets the variable mInterpolation to the provided value and
|
/// triggers an update for the measure results
|
/// </summary>
|
public void setInterpolation(string mode)
|
{
|
mInterpolation = mode;
|
UpdateMeasure(ALL_ROI);
|
}
|
|
/// <summary>
|
/// Sets the variable mTransition to the provided value and
|
/// triggers an update for the measure results
|
/// </summary>
|
public void setTransition(string mode)
|
{
|
mTransition = mode;
|
UpdateExecute(ALL_ROI);
|
}
|
|
/// <summary>
|
/// Sets the position of edges to select to the provided value and
|
/// triggers an update od the measure results.
|
/// </summary>
|
public void setPosition(string mode)
|
{
|
mPosition = mode;
|
UpdateExecute(ALL_ROI);
|
}
|
|
/// <summary>
|
/// Sets the length of the displayed edges to the provided value
|
/// and triggers an update of the measure results.
|
/// </summary>
|
public void setDispEdgeLength(int val)
|
{
|
mDispEdgeLength = val;
|
UpdateXLD();
|
}
|
|
/// <summary>
|
/// Sets the width of the displayed ROI to the provided value
|
/// and triggers an update for the measure results
|
/// </summary>
|
public void setFlagDispROIWidth(bool mode)
|
{
|
mDispROIWidth = mode;
|
UpdateXLD();
|
}
|
|
/********************************************************/
|
/* determine list of result coordinates to be displayed */
|
/********************************************************/
|
|
/// <summary>
|
/// Sets a flag to determine if the edge positions of
|
/// measure results are added and displayed on the
|
/// measure result table
|
/// </summary>
|
public void showPosition(bool mode)
|
{
|
mDispPosition = mode;
|
}
|
|
/// <summary>
|
/// Sets a flag to determine if the intra distance for
|
/// measure edge pairs are added and displayed on the
|
/// measure result table
|
/// </summary>
|
public void showPairWidth(bool mode)
|
{
|
mDispPairWidth = mode;
|
}
|
|
/// <summary>
|
/// Sets a flag to determine if the edge amplitude of
|
/// measure results are added and displayed on the
|
/// measure result table
|
/// </summary>
|
public void showAmplitude(bool mode)
|
{
|
mDispAmplitude = mode;
|
}
|
|
/// <summary>
|
/// Sets a flag to determine if the edge distance of
|
/// measure results are added and displayed on the
|
/// measure result table
|
/// </summary>
|
public void showDistance(bool mode)
|
{
|
mDispDistance = mode;
|
}
|
|
/// <summary>
|
/// Sets the unit for world coordinate transformation to
|
/// the provided value and triggers an update of the
|
/// measure results
|
/// </summary>
|
public void setUnit(string val)
|
{
|
mUnit = val;
|
UpdateExecute(ALL_ROI);
|
}
|
|
/// <summary>
|
/// Sets the variable mTransWorldCoord to the provided
|
/// value and triggers an update for the measure results
|
/// </summary>
|
public void setTransWorldCoord(bool mode)
|
{
|
mTransWorldCoord = mode;
|
UpdateExecute(ALL_ROI);
|
}
|
|
/// <summary>
|
/// Load an HALCON image from the file filename and
|
/// delete the list of measure handles created for the
|
/// previous image setup
|
/// </summary>
|
/// <param name="filename">Location of image file</param>
|
/// <returns>Flag depicting success of the load process</returns>
|
public bool setImage(string filename)
|
{
|
string tmp;
|
|
RemoveAllMeasureObjects();
|
exceptionText = "";
|
try
|
{
|
mImage = new HImage(filename);
|
mImage.GetImagePointer1(out tmp, out mWidth, out mHeight);
|
}
|
catch (HOperatorException e)
|
{
|
mImage = null;
|
exceptionText = e.Message;
|
NotifyMeasureObserver(MeasureAssistant.ERR_READING_FILE);
|
return false;
|
}
|
return true;
|
}
|
|
/// <summary>
|
/// Sets the variable mImage to the HImage provided
|
/// </summary>
|
/// <param name="img">HALCON image instance</param>
|
public void setImage(HImage img)
|
{
|
string tmp;
|
|
RemoveAllMeasureObjects();
|
mImage = img;
|
|
if (mImage != null)
|
mImage.GetImagePointer1(out tmp, out mWidth, out mHeight);
|
|
}
|
|
/// <summary>
|
/// Returns the image currently used for measurement, described
|
/// by mImage
|
/// </summary>
|
public HImage getImage()
|
{
|
return mImage;
|
}
|
|
/// <summary>Load camera calibration data from file</summary>
|
/// <param name="file">Location of *.cal file</param>
|
public void LoadCamParFile(string file)
|
{
|
exceptionText = "";
|
try
|
{
|
mCamParameter = null;
|
mCamParameter = HMisc.ReadCamPar(file);
|
}
|
catch (HOperatorException e)
|
{
|
mIsCalibValid = false;
|
exceptionText = e.Message;
|
throw (e);
|
}
|
|
if (mCamParameter == null || !(mCamParameter.Length > 0) || mCamPose == null || !(mCamPose.Length > 0))
|
mIsCalibValid = false;
|
else
|
mIsCalibValid = true;
|
|
if (mIsCalibValid)
|
UpdateExecute(ALL_ROI);
|
}
|
|
/// <summary>Load camera pose data from file</summary>
|
/// <param name="file">Location of *.dat file</param>
|
public void LoadCamPoseFile(string file)
|
{
|
exceptionText = "";
|
try
|
{
|
HOperatorSet.ReadPose(new HTuple(file), out mCamPose);
|
}
|
catch (HOperatorException e)
|
{
|
mIsCalibValid = false;
|
exceptionText = e.Message;
|
throw (e);
|
}
|
|
if (mCamParameter == null || !(mCamParameter.Length > 0) || mCamPose == null || !(mCamPose.Length > 0))
|
mIsCalibValid = false;
|
else
|
mIsCalibValid = true;
|
|
|
if (mIsCalibValid)
|
UpdateExecute(ALL_ROI);
|
}
|
|
/// <summary>
|
/// Create a measure object for the new instance of an interactive
|
/// ROI at index mActRoiIdx
|
/// </summary>
|
public void AddMeasureObject()
|
{
|
mActRoiIdx = roiController.getActiveROIIdx();
|
|
if (mActRoiIdx != -1)
|
mMeasureList.Add(CreateMeasure((ROI)mROIList[mActRoiIdx], this));
|
|
NotifyMeasureObserver(EVENT_UPDATE_MEASUREMENT);
|
}
|
|
/// <summary>
|
/// Update measure object for the selected interactive ROI
|
/// at index or update measure handles for the
|
/// entire set of interactive ROIs
|
/// </summary>
|
public void UpdateMeasure(int index)
|
{
|
|
if (index == -1)
|
{
|
for (int i =0; i < mMeasureList.Count; i++)
|
((Measurement)mMeasureList[i]).UpdateROI();
|
}
|
else
|
{
|
((Measurement)mMeasureList[index]).UpdateROI();
|
}
|
|
NotifyMeasureObserver(EVENT_UPDATE_MEASUREMENT);
|
}
|
|
/// <summary>
|
/// Recreate the entire measure object list, if the
|
/// measure edge type changes from edge pose to
|
/// edge pairs or vice versa
|
/// </summary>
|
public void UpdateMeasure()
|
{
|
RemoveAllMeasureObjects();
|
for (int i =0; i < mROIList.Count; i++)
|
{
|
ROI roi = (ROI)mROIList[i];
|
mMeasureList.Add(CreateMeasure((ROI)mROIList[i], this));
|
}
|
NotifyMeasureObserver(EVENT_UPDATE_MEASUREMENT);
|
}
|
|
/// <summary>
|
/// Update measure results for a selected measure object instance
|
/// at index or the entire set of measure handles.
|
/// </summary>
|
public void UpdateExecute(int index)
|
{
|
if (index == -1)
|
{
|
for (int i =0; i < mMeasureList.Count; i++)
|
((Measurement)mMeasureList[i]).UpdateResults();
|
}
|
else
|
{
|
((Measurement)mMeasureList[index]).UpdateResults();
|
}
|
|
NotifyMeasureObserver(EVENT_UPDATE_MEASUREMENT);
|
}
|
|
/// <summary>
|
/// Update display objects of the measure results
|
/// for the entire set of measure handles
|
/// </summary>
|
public void UpdateXLD()
|
{
|
for (int i =0; i < mMeasureList.Count; i++)
|
((Measurement)mMeasureList[i]).UpdateXLD();
|
|
NotifyMeasureObserver(EVENT_UPDATE_RESULT_XLD);
|
}
|
|
/// <summary>
|
/// Clear the entire list of measure handles and
|
/// releases the resources used
|
/// </summary>
|
public void RemoveAllMeasureObjects()
|
{
|
int count = mMeasureList.Count;
|
for (int i=0; i < count; i++)
|
RemoveMeasureObjectIdx(0);
|
|
NotifyMeasureObserver(EVENT_UPDATE_REMOVE);
|
}
|
|
/// <summary>
|
/// Clear the measure object corresponding to the deleted
|
/// interactive ROI and release the resources used
|
/// </summary>
|
public void RemoveMeasureObjectActIdx()
|
{
|
int DelIdx = roiController.getDelROIIdx();
|
RemoveMeasureObjectIdx(DelIdx);
|
|
NotifyMeasureObserver(EVENT_UPDATE_REMOVE);
|
}
|
|
/// <summary>
|
/// Clear the measure object at the index DelIdx from
|
/// the measure object list and release the resources used
|
/// </summary>
|
private void RemoveMeasureObjectIdx(int DelIdx)
|
{
|
Measurement m = (Measurement)mMeasureList[DelIdx];
|
mMeasureList.RemoveAt(DelIdx);
|
m.ClearMeasurement();
|
mActRoiIdx = -1;
|
}
|
|
/// <summary>
|
/// Factory method to create measure objects
|
/// </summary>
|
/// <param name="roi">Interactive ROI</param>
|
/// <param name="parent">
|
/// Reference to measure controller class
|
/// </param>
|
/// <returns>New measure object</returns>
|
public static Measurement CreateMeasure(ROI roi, MeasureAssistant parent)
|
{
|
if (parent.mSelPair)
|
return new MeasurementPair(roi, parent);
|
else
|
return new MeasurementEdge(roi, parent);
|
}
|
|
/// <summary>
|
/// Composes set of HALCON iconic objects to display
|
/// measure edge results
|
/// </summary>
|
/// <returns>Detected measure edges</returns>
|
public HXLDCont getMeasureResults()
|
{
|
HXLDCont val;
|
HXLDCont obj = new HXLDCont();
|
obj.GenEmptyObj();
|
|
for (int i=0; i < mMeasureList.Count; i++)
|
{
|
val = ((Measurement)mMeasureList[i]).getMeasureResults();
|
if (val.IsInitialized())
|
obj = obj.ConcatObj(val);
|
}
|
return obj;
|
}
|
|
/// <summary>
|
/// Composes set of HALCON iconic objects to display
|
/// dimension of measure object
|
/// </summary>
|
/// <returns>Surrounding contour of measure object</returns>
|
public HObject getMeasureRegions()
|
{
|
HObject val;
|
HObject obj = new HObject();
|
obj.GenEmptyObj();
|
|
for (int i=0; i < mMeasureList.Count; i++)
|
{
|
val = ((Measurement)mMeasureList[i]).getMeasureRegion();
|
if (val.IsInitialized())
|
obj = obj.ConcatObj(val);
|
}
|
return obj;
|
}
|
|
/// <summary>Returns number of measure objects</summary>
|
/// <returns>Length of mMeasureList</returns>
|
public int getMeasureListCount()
|
{
|
return mMeasureList.Count;
|
}
|
|
/// <summary>Change index for selected interactive ROI</summary>
|
public void ClickedActiveROI()
|
{
|
mActRoiIdx = roiController.getActiveROIIdx();
|
}
|
|
/// <summary>
|
/// Compose set of measure result data to display in the result table
|
/// </summary>
|
/// <returns>Composition of measure result information</returns>
|
public ArrayList getMeasureTableData()
|
{
|
MeasureResult resultData;
|
ArrayList table = new ArrayList(10);
|
|
if (mMeasureList.Count == 0 || mActRoiIdx == -1)
|
return table;
|
|
resultData = ((Measurement)mMeasureList[mActRoiIdx]).getMeasureResultData();
|
|
if (mSelPair)
|
{
|
if (mDispPosition)
|
{
|
table.Add(((PairResult)resultData).rowEdgeFirst);
|
table.Add(((PairResult)resultData).colEdgeFirst);
|
table.Add(((PairResult)resultData).rowEdgeSecond);
|
table.Add(((PairResult)resultData).colEdgeSecond);
|
}
|
if (mDispAmplitude)
|
{
|
table.Add(((PairResult)resultData).amplitudeFirst);
|
table.Add(((PairResult)resultData).amplitudeSecond);
|
}
|
if (mDispDistance)
|
table.Add(((PairResult)resultData).interDistance);
|
|
if (mDispPairWidth)
|
table.Add(((PairResult)resultData).intraDistance);
|
}
|
else
|
{
|
if (mDispPosition)
|
{
|
table.Add(((EdgeResult)resultData).rowEdge);
|
table.Add(((EdgeResult)resultData).colEdge);
|
}
|
if (mDispAmplitude)
|
table.Add(((EdgeResult)resultData).amplitude);
|
if (mDispDistance)
|
table.Add(((EdgeResult)resultData).distance);
|
}
|
return table;
|
}
|
|
/// <summary>
|
/// Compose the set of measure result types to be displayed
|
/// in the result table. The types are determined by the user,
|
/// who can check the corresponding flags in the GUI frontend
|
/// </summary>
|
/// <returns>Composition of measure result types</returns>
|
public ArrayList getMeasureResultComposition()
|
{
|
ArrayList composition = new ArrayList(5);
|
|
if (mSelPair)
|
{
|
if (mDispPosition)
|
{
|
composition.Add("Row 1st");
|
composition.Add("Col 1st");
|
composition.Add("Row 2nd");
|
composition.Add("Col 2nd");
|
}
|
if (mDispAmplitude)
|
{
|
composition.Add("Amplitude 1st");
|
composition.Add("Amplitude 2nd");
|
}
|
if (mDispDistance)
|
composition.Add("Distance");
|
if (mDispPairWidth)
|
composition.Add("Width");
|
}
|
else
|
{
|
if (mDispPosition)
|
{
|
composition.Add("Row");
|
composition.Add("Column");
|
}
|
if (mDispAmplitude)
|
composition.Add("Amplitude");
|
if (mDispDistance)
|
composition.Add("Distance");
|
}
|
return composition;
|
}
|
|
/// <summary>
|
/// Determine the gray value projection for the measure object
|
/// corresponding to the interactive ROI currently selected.
|
/// If no ROI is selected then return a null-object.
|
/// </summary>
|
/// <returns>Gray value profile</returns>
|
public double[] getMeasureProjection()
|
{
|
if (mActRoiIdx == -1)
|
return null;
|
else
|
return ((Measurement)mMeasureList[mActRoiIdx]).getGrayValueProj();
|
}
|
|
}//end of class
|
}//end of namespace
|
