using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using HalconDotNet;

namespace HalconTools
{
    public delegate void CalibDelegate(int value);   

    public class CalibrationAssistant
    {
        /// <summary>
        /// Constant indicating the camera model to be of type 
        /// line scan camera.
        /// </summary>
        public const int CAMERA_TYP_LINE_SCAN = 3;
        /// <summary>
        /// Constant indicating the camera model to be of type 
        /// area scan camera with the division 
        /// model to describe the lens distortions
        /// </summary>
        public const int CAMERA_TYP_AREA_SCAN_DIV = 4;
        /// <summary>
        /// Constant indicating the camera model to be of type
        /// area scan camera with the polynomial 
        /// model to describe the lens distortions
        /// </summary>
        public const int CAMERA_TYP_AREA_SCAN_POLY = 5;

        /// <summary>
        /// Constant indicating a change in the set of 
        /// <c>CalibImage</c> instances regarding the parameters 
        /// marks and poses.
        /// </summary>
        public const int UPDATE_MARKS_POSE = 10;
        /// <summary>
        /// Constant indicating a change in the set of
        /// <c>CalibImage</c> instances regarding the 
        /// quality assessment.
        /// </summary>
        public const int UPDATE_QUALITY_TABLE = 12;
        /// <summary>
        /// Constant indicating a change in the evaluation grades 
        /// of the <c>CalibImage</c> set. The grades measure the results 
        /// of the calibration preparations prior to the calibration
        /// process itself.
        /// </summary>
        public const int UPDATE_CALTAB_STATUS = 13;
        /// <summary>
        /// Constant indicating an update of the calibration
        /// results.
        /// </summary>
        public const int UPDATE_CALIBRATION_RESULTS = 14;

        /// <summary>
        /// Constant indicating that the quality measurement
        /// includes all quality assessment operators for 
        /// evaluating the set of calibration images.
        /// </summary>
        public const int QUALITY_ISSUE_TEST_ALL = 0;
        /// <summary>
        /// Constant indicating that the quality measurement uses only the
        /// basic quality assessment operators for speedup purposes.
        /// </summary>
        public const int QUALITY_ISSUE_TEST_QUICK = 1;
        /// <summary>
        /// Constant indicating no quality measurement 
        /// for the set of calibration images.
        /// </summary>
        public const int QUALITY_ISSUE_TEST_NONE = 2;

        /// <summary>
        /// Constant indicating the image quality feature 'exposure'
        /// </summary>
        public const int QUALITY_ISSUE_IMG_EXPOSURE = 20;
        /// <summary>
        /// Constant indicating the image quality feature 'homogeneity'
        /// </summary>
        public const int QUALITY_ISSUE_IMG_HOMOGENEITY = 21;
        /// <summary>
        /// Constant indicating the image quality feature 'contrast'
        /// </summary>
        public const int QUALITY_ISSUE_IMG_CONTRAST = 22;
        /// <summary>
        /// Constant indicating the image quality feature 'sharpness'
        /// </summary>
        public const int QUALITY_ISSUE_IMG_FOCUS = 23;
        /// <summary>
        /// Constant indicating the size of the depicted  
        /// calibration plate in the calibration image, to evaluate
        /// the distance used to the camera
        /// </summary>
        public const int QUALITY_ISSUE_IMG_CALTAB_SIZE = 24;

        /// <summary>
        /// Constant indicating the coverage of the view field.
        /// This is assured only by a sufficient number of 
        /// calibration images and its correct distribution in the space.
        /// </summary>
        public const int QUALITY_ISSUE_SEQ_MARKS_DISTR = 25;
        /// <summary>
        /// Constant indicating the amount of distortions covered,
        /// described by the set of images showing tilted calibration
        /// plates
        /// </summary>
        public const int QUALITY_ISSUE_SEQ_CALTAB_TILT = 26;
        /// <summary>
        /// Constant indicating whether the number of provided calibration
        /// images is sufficient enough to obtain stable calibration results.
        /// </summary>
        public const int QUALITY_ISSUE_SEQ_NUMBER = 27;
        /// <summary>
        /// Constant indicating the all over quality performance,
        /// being best for a value close or equal to 1
        /// </summary>
        public const int QUALITY_ISSUE_SEQ_ALL_OVER = 28;
        /// <summary>
        /// Constant that indicates an error in the calibration
        /// preprocessing step, which has to perform well for the
        /// whole sequence of calibration images in order to start 
        /// the calibration process. 
        /// </summary>
        public const int QUALITY_ISSUE_SEQ_ERROR = 29;
        /// <summary>
        /// Constant indicating an error in the preprocessing step 
        /// for a single calibration image, i.e., that the
        /// marks and pose values might be missing or the region 
        /// plate couldn't be detected
        /// </summary>
        public const int QUALITY_ISSUE_FAILURE = 30;

        /// <summary>
        /// Constant describing an error while reading a 
        /// calibration image from file
        /// </summary>
        public const int ERR_READING_FILE = 31;
        /// <summary>
        /// Constant describing an error exception raised during
        /// the calibration process
        /// </summary>
        public const int ERR_IN_CALIBRATION = 32;
        /// <summary>
        /// Constant indicating an invalid reference index. The
        /// index is needed to define the reference image for
        /// the camera calibration.
        /// </summary>
        public const int ERR_REFINDEX_INVALID = 33;
        /// <summary>
        /// Constant describing an error exception raised 
        /// during quality assessment.
        /// </summary>
        public const int ERR_QUALITY_ISSUES = 34;
        /// <summary>
        /// Constant describing an error that occurred while
        /// writing the calibration parameters into file
        /// </summary>
        public const int ERR_WRITE_CALIB_RESULTS = 35;


        /// <summary>
        /// Constant indicating the result status of the 
        /// calibration preparation step:
        /// Plate region couldn't be detected in the 
        /// calibration image.
        /// </summary>
        public const string PS_NOT_FOUND = "Plate not found";
        /// <summary>
        /// Constant that describes the results of the 
        /// calibration preparation step:
        /// Plate region was detected, but the marks could not
        /// be extracted in the plate region.
        /// </summary>
        public const string PS_MARKS_FAILED = "Marks not found";
        /// <summary>
        /// Constant indicating the result status of the 
        /// calibration preparation step:
        /// Plate region and marks were detected, 
        /// but the quality assessment delivered bad scores.
        /// </summary>
        public const string PS_QUALITY_ISSUES = "Quality issues detected";
        /// <summary>
        /// Constant indicating the result status of the 
        /// calibration preparation step:
        /// The preprocessing step was successful.
        /// </summary>
        public const string PS_OK = "Ok";

        /// <summary>
        /// List of calibration images that are used 
        /// to perform the camera calibration. 
        /// </summary>
        private ArrayList CalibData;
        /// <summary>
        /// Index to the reference image that is used to
        /// determine the initial values for the internal camera 
        /// parameters for the camera calibration
        /// </summary>
        public int mReferenceIndex;

        private QualityProcedures procedure;


        // CALIBRATION RESULTS -----------------------------------------
        /// <summary>
        /// Flag indicating that the calibration was successful and
        /// the present calibration results are up to date
        /// </summary>
        public bool mCalibValid;
        /// <summary>
        /// The average error give an impression of the accuracy of the
        /// calibration. The error (deviations in x and y coordinates) are 
        /// measured in pixels
        /// </summary>
        public double mErrorMean;

        /// <summary>
        /// Ordered tuple with the external camera parameters for all
        /// calibration images, i.e., the position and orientation of the
        /// calibration plate in camera coordinates.
        /// </summary>
        public HTuple mPoses;
        /// <summary>
        /// Internal camera parameters
        /// </summary>
        public HTuple mCameraParams;
        /// <summary>
        /// Error contents that caused an exception 
        /// </summary>
        public string mErrorMessage;

        /// <summary>
        /// Calibration image at index <c>mReferenceIndex</c>
        /// </summary>
        public HImage mReferenceImage;
        /// <summary>
        /// Synthetic calibration images with calibrated camera 
        /// parameters to test the quality of the calibration 
        /// algorithm
        /// </summary>
        public HImage mSimulatedImage;
        /// <summary>
        ///  Reference world coordinate system, based on 
        ///  <c>mPose</c> and the calibrated camera parameters 
        /// </summary>
        public HObject mReferenceWCS;

        /// <summary>
        /// Flag describing whether all calibration images
        /// have a sufficient quality, i.e. whether  the region plate and
        /// marks have been detected in all calibration images,
        /// so that a camera calibration can be invoked
        /// </summary>
        public bool mCanCalib;
        /// <summary>
        /// Flag indicating that the origin of the reference world coordinate
        /// system <c>mReferenceWCS</c> is mapped to the origin of the image
        /// coordinate system.
        /// </summary>
        public bool mAtImgCoord;


        // FIRST TAB  -----------------------------------------------
        /// <summary>
        /// Name of the calibration plate description file to read
        /// the mark center points from
        /// </summary>
        public string mDescrFileName;
        /// <summary>
        /// Thickness of the calibration plate that was used in the 
        /// calibration images
        /// </summary>
        public double mThickness;
        /// <summary>
        /// Camera type, which can either be an area scan camera 
        /// (using the division or polynomial model) or a linescan camera
        /// </summary>
        public int mCameraType;
        /// <summary>
        /// Horizontal distance between two neighboring CCD 
        /// sensor cells 
        /// </summary>
        public double mCellWidth;    // Sx 
        /// <summary>
        /// Vertical distance between two neighboring CCD 
        /// sensor cells 
        /// </summary>
        public double mCellHeight;   // Sy 
        /// <summary>
        /// Nominal focal length of the camera lense
        /// </summary>
        public double mFocalLength;
        /// <summary>
        /// Parameter to model the radial distortion described by 
        /// the division model
        /// </summary>
        public double mKappa;
        /// <summary>
        /// First parameter to model the radial distortion described by 
        /// the polynomial model
        /// </summary>
        public double mK1;
        /// <summary>
        /// Second parameter to model the radial distortion described by 
        /// the polynomial model
        /// </summary>
        public double mK2;
        /// <summary>
        /// Third parameter to model the radial distortion described by 
        /// the polynomial model
        /// </summary>
        public double mK3;
        /// <summary>
        /// First parameter to model the decentering distortion described by 
        /// the polynomial model
        /// </summary>
        public double mP1;
        /// <summary>
        /// Second parameter to model the decentering distortion described by 
        /// the polynomial model
        /// </summary>
        public double mP2;
        /// <summary>
        /// Flag indicating the type of camera lense used:
        /// telecentric, which means a parallel projection with the focal 
        /// length equal to 0, or  a perspective projection
        /// </summary>
        public bool isTelecentric;

        /// <summary>
        /// X component of the motion vector, which describes the motion
        /// between the linescan camera and the object.
        /// </summary>
        public double mMotionVx;
        /// <summary>
        /// Y component of the motion vector, which describes the motion
        /// between the linescan camera and the object.
        /// </summary>
        public double mMotionVy;
        /// <summary>
        /// Z component of the motion vector, which describes the motion
        /// between the linescan camera and the object.
        /// </summary>
        public double mMotionVz;

        // SECOND TAB ---------------------------------------------
        private int mWarnLevel;
        private int mImageTests;
        private int mSequenceTests;

        /// <summary>
        /// List of quality assessment scores of the whole set of calibration
        /// images.
        /// </summary>
        public ArrayList mSeqQualityList;

        /// <summary>
        /// Size of the filter mask that is used to smooth the 
        /// image before determining the region plate in the
        /// calibration image
        /// </summary>
        public double mFilterSize;
        /// <summary>
        /// Threshold value for mark extraction
        /// </summary>
        public double mMarkThresh;
        /// <summary>
        /// Expected minimum diameter of the marks on the 
        /// calibration plate
        /// </summary>
        public double mMinMarkDiam;
        /// <summary>
        /// Initial threshold value for contour detection
        /// </summary>
        public double mInitThresh;
        /// <summary>
        /// Loop value for successive reduction of 
        /// the initial threshold <c>mInitThresh</c>
        /// </summary>
        public double mThreshDecr;
        /// <summary>
        /// Minimum threshold for contour detection
        /// </summary>
        public double mMinThresh;
        /// <summary>
        /// Filter parameter for contour detection
        /// </summary>
        public double mSmoothing;
        /// <summary>
        /// Minimum length of the contours of the marks
        /// </summary>
        public double mMinContLength;
        /// <summary>
        /// Maximum expected diameter of the marks
        /// </summary>
        public double mMaxMarkDiam;

        // reset vals 
        public int resetFilterSize = 9;
        public int resetMarkThresh = 180;
        public int resetMinMarkDiam = 5;
        public int resetInitThresh = 128;
        public int resetThreshDecr = 10;
        public int resetMinThresh = 18;
        public double resetSmoothing = 0.9; /* 90*0.01 */
        public int resetMinContL = 15;
        public int resetMaxMarkDiam = 500;

        /// <summary>
        /// Delegate to notify the GUI about changes in the data models
        /// </summary>
        public CalibDelegate NotifyCalibObserver;


        /* Constructor, in which all calibration parameters  
         * and  auxiliary variables, flags and lists are initilized */
        public CalibrationAssistant()
        {
            CalibData = new ArrayList(15);
            mReferenceIndex = -1;
            mDescrFileName = "caltab_10mm.descr";
            mCalibValid = false;
            mCanCalib = true;
            mAtImgCoord = false;

            mReferenceImage = new HImage();
            mSimulatedImage = new HImage();

            mFilterSize = resetFilterSize;
            mMarkThresh = resetMarkThresh;
            mMinMarkDiam = resetMinMarkDiam;
            mInitThresh = resetInitThresh;
            mThreshDecr = resetThreshDecr;
            mMinThresh = resetMinThresh;
            mSmoothing = resetSmoothing;
            mMinContLength = resetMinContL;
            mMaxMarkDiam = resetMaxMarkDiam;

            mWarnLevel = 70;
            mImageTests = QUALITY_ISSUE_TEST_ALL;
            mSequenceTests = QUALITY_ISSUE_TEST_ALL;
            mSeqQualityList = new ArrayList(15);
            procedure = new QualityProcedures();


            mThickness = 1.00;       // millimeter
            mCameraType = CAMERA_TYP_AREA_SCAN_DIV;
            mCellWidth = 8.300;         // micrometer
            mCellHeight = 8.300;        // micrometer
            mFocalLength = 8.000;          // millimeter
            isTelecentric = false;
            mKappa = 0.0;
            mK1 = 0.0;
            mK2 = 0.0;
            mK3 = 0.0;
            mP1 = 0.0;
            mP2 = 0.0;
            mMotionVx = 0.0;
            mMotionVy = 500.0;
            mMotionVz = 0.0;

            NotifyCalibObserver = new CalibDelegate(dummy);
        }

        /*******************************************/
        /**********         Tab.1       ************/
        /*******************************************/

        /// <summary>
        /// Sets the reference index to the supplied value
        /// </summary>
        public void setReferenceIdx(int val)
        {
            mReferenceIndex = val;
        }

        /*******************************************/

        /// <summary>
        /// Sets the file path for the description file to 
        /// the supplied value
        /// </summary>
        /// <param name="fileName">
        /// Absolute path to the description file
        /// </param>
        public void setDesrcFile(string fileName)
        {
            mDescrFileName = fileName;
            Update();
        }
        /// <summary>
        /// Gets the path to the description file used
        /// with the calibration
        /// </summary>
        public string getDesrcFile()
        {
            return mDescrFileName;
        }

        /*******************************************/

        /// <summary>
        /// Sets the thickness parameter to the supplied value
        /// </summary>
        public void setThickness(double val)
        {
            mThickness = val;
            UpdateResultVisualization();
        }
        /// <summary>
        /// Returns the current value for the thickness of the calibration
        /// plate.
        /// </summary>
        public double getThickness()
        {
            return mThickness;
        }

        /*******************************************/

        /// <summary>
        /// Sets the camera type to the supplied value and 
        /// invokes an update to adjust data for the calibration images.
        /// 
        /// </summary>
        public void setCameraType(int mode)
        {
            mCameraType = mode;
            Update(true);
        }
        /// <summary>
        /// Returns the current camera type.
        /// </summary>
        public int getCameraType()
        {
            return mCameraType;
        }

        /*******************************************/

        /// <summary>
        /// Sets the parameter for the CCD sensor cell width
        /// to the supplied value.
        /// </summary>
        public void setCellWidth(double val)
        {
            mCellWidth = val;
            Update();
        }
        /// <summary>
        /// Returns the value for the CCD sensor cell width
        /// </summary>
        public double getCellWidth()
        {
            return mCellWidth;
        }

        /*******************************************/

        /// <summary>
        /// Sets the parameter for the CCD sensor cell height
        /// to the supplied value.
        /// </summary>
        public void setCellHeight(double val)
        {
            mCellHeight = val;
            Update();
        }
        /// <summary>
        /// Returns the value for the CCD sensor cell height
        /// </summary>
        public double getCellHeight()
        {
            return mCellHeight;
        }

        /*******************************************/

        /// <summary>
        /// Sets the parameter for the focal length to the
        /// supplied value 
        /// </summary>
        public void setFocalLength(double val)
        {
            mFocalLength = val;
            Update();
        }
        /// <summary>
        /// Returns the current value for the focal length
        /// </summary>
        public double getFocalLength()
        {
            return mFocalLength;
        }

        /*******************************************/

        /// <summary>
        /// Sets the boolean flag to indicate the use of telecentric 
        /// lense
        /// </summary>
        public void setIsTelecentric(bool val)
        {
            isTelecentric = val;
            Update();
        }
        /// <summary>
        /// Returns whether the current camera lense is  defined to 
        /// be telecentric or not
        /// </summary>
        public bool IsTelecentric()
        {
            return isTelecentric;
        }

        /*******************************************/

        /// <summary>
        /// Sets the motion vector Vx to the supplied 
        /// value
        /// </summary>
        public void setMotionX(double val)
        {
            mMotionVx = val;
            Update();
        }
        /// <summary>
        /// Gets the current value for the motion vector Vx
        /// </summary>
        public double getMotionX()
        {
            return mMotionVx;
        }

        /*******************************************/

        /// <summary>
        /// Sets the motion vector Vy to the supplied 
        /// value 
        /// </summary>
        public void setMotionY(double val)
        {
            mMotionVy = val;
            Update();
        }
        /// <summary>
        /// Gets the current value for the motion vector Vy
        /// </summary>
        public double getMotionY()
        {
            return mMotionVy;
        }

        /*******************************************/

        /// <summary>
        /// Sets the motion vector Vz to the supplied 
        /// value 
        /// </summary>
        public void setMotionZ(double val)
        {
            mMotionVz = val;
            Update();
        }
        /// <summary>
        /// Gets the current value for the motion vector Vz
        /// </summary>
        public double getMotionZ()
        {
            return mMotionVz;
        }

        /*******************************************/
        /**********         Tab.2       ************/
        /*******************************************/
        /*******************************************/

        /// <summary>
        /// Sets the parameter for the warn level to 
        /// the supplied value.
        /// </summary>
        public void setWarnLevel(int val)
        {
            mWarnLevel = val;
            Update(true);
        }
        /// <summary>
        /// Gets the current value for the warn level
        /// </summary>
        public double getWarnLevel()
        {
            return mWarnLevel;
        }

        /*******************************************/

        /// <summary>
        /// Sets the parameter to define the mode (accuracy) of
        /// the quality assessment for single
        /// calibration images
        /// </summary>
        /// <param name="mode">
        /// mode (accuracy) of the quality assessment; one of the constants
        /// starting with QUALITY_ISSUE_TEST_*.
        /// </param>
        public void setImageTests(int mode)
        {
            mImageTests = mode;
            Update(true);
        }
        /// <summary>
        /// Gets the current value that describes the
        /// accuracy of the quality assessment
        /// </summary>
        public double getImageTests()
        {
            return mImageTests;
        }

        /*******************************************/

        /// <summary>
        /// Sets the parameter to define the mode (accuracy) of
        /// the quality assessment for the whole sequence
        /// of calibration images
        /// </summary>
        /// <param name="mode">
        /// mode (accuracy) of the quality assessment; one of the constants
        /// starting with QUALITY_ISSUE_TEST_*.
        /// </param>
        public void setSequenceTests(int mode)
        {
            mSequenceTests = mode;
            Update(true);
        }
        /// <summary>
        /// Gets the current value that describes the
        /// accuracy of the quality assessment
        /// </summary>
        public double getSequenceTests()
        {
            return mSequenceTests;
        }

        /*******************************************/

        /// <summary>
        /// Sets the parameter for the filter size to
        /// the supplied value.
        /// </summary>
        public void setFilterSize(double val)
        {
            mFilterSize = val;
            Update();
        }
        /// <summary>
        /// Gets the current value for the parameter 
        /// describing the filter size 
        /// </summary>
        public double getFilterSize()
        {
            return mFilterSize;
        }

        /*******************************************/

        /// <summary>
        /// Sets the parameter for mark threshold to
        /// the supplied value.
        /// </summary>
        public void setMarkThresh(double val)
        {
            mMarkThresh = val;
            Update();
        }
        /// <summary>
        /// Gets the current value for the parameter 
        /// describing the mark threshold
        /// </summary>
        public double getMarkThresh()
        {
            return mMarkThresh;
        }

        /*******************************************/

        /// <summary>
        /// Sets the parameter for the minimum mark
        /// diameter to the supplied value.
        /// </summary>
        public void setMinMarkDiam(double val)
        {
            mMinMarkDiam = val;
            Update();
        }
        /// <summary>
        /// Gets the current value for the parameter 
        /// describing the minimum mark diameter
        /// </summary>
        public double getMinMarkDiam()
        {
            return mMinMarkDiam;
        }

        /*******************************************/

        /// <summary>
        /// Sets the parameter for the start threshold
        /// to the supplied value.
        /// </summary>
        public void setInitThresh(double val)
        {
            mInitThresh = val;
            Update();
        }
        /// <summary>
        /// Gets the current value for the parameter 
        /// describing the start threshold
        /// </summary>
        public double getInitThresh()
        {
            return mInitThresh;
        }

        /*******************************************/

        /// <summary>
        /// Sets the parameter for the threshold 
        /// decrement to the supplied value.
        /// </summary>
        public void setThreshDecr(double val)
        {
            mThreshDecr = val;
            Update();
        }
        /// <summary>
        /// Gets the current value for the parameter 
        /// describing the threshold decrement
        /// </summary>
        public double getThreshDecr()
        {
            return mThreshDecr;
        }

        /*******************************************/

        /// <summary>
        /// Sets the parameter for the minimum 
        /// threshold to the supplied value.
        /// </summary>
        public void setMinThresh(double val)
        {
            mMinThresh = val;
            Update();
        }
        /// <summary>
        /// Gets the current value for the parameter 
        /// describing the minimum threshold
        /// </summary>
        public double getMinThresh()
        {
            return mMinThresh;
        }

        /*******************************************/

        /// <summary>
        /// Sets the parameter describing the smoothing
        /// factor to the supplied value.
        /// </summary>
        public void setSmoothing(double val)
        {
            mSmoothing = val;
            Update();
        }
        /// <summary>
        /// Gets the parameter describing the smoothing
        /// factor
        /// </summary>
        public double getSmoothing()
        {
            return mSmoothing;
        }

        /*******************************************/

        /// <summary>
        /// Sets the parameter describing the minimum
        /// contour length to the supplied value.
        /// </summary>
        public void setMinContLength(double val)
        {
            mMinContLength = val;
            Update();
        }
        /// <summary>
        /// Gets the parameter describing the minimum
        /// contour length
        /// </summary>
        public double getMinContLength()
        {
            return mMinContLength;
        }

        /*******************************************/

        /// <summary>
        /// Sets the parameter describing the maximum
        /// mark diameter to the supplied value.
        /// </summary>
        public void setMaxMarkDiam(double val)
        {
            mMaxMarkDiam = val;
            Update();
        }
        /// <summary>
        /// Gets the parameter describing the maximum
        /// mark diameter
        /// </summary>
        public double getMaxMarkDiam()
        {
            return mMaxMarkDiam;
        }

        /*******************************************/

        /// <summary>
        /// Sets the flag defining the origin of
        /// the reference world coordinate system
        /// to be in the image coordinate system
        /// </summary>
        public void setAtImgCoord(bool val)
        {
            mAtImgCoord = val;
            UpdateResultVisualization();

        }
        /// <summary>
        /// Gets the current value for the flag 
        /// </summary>
        public bool getAtImgCoord()
        {
            return mAtImgCoord;
        }


        public void dummy(int val) { }

        /*******************************************/
        /*******************************************/
        /*******************************************/
        /*******************************************/

        /// <summary>
        /// Gets the calibration image for the index <c>i</c>
        /// from the list <c>CalibData</c>
        /// </summary>
        public CalibImage getCalibDataAt(int i)
        {
            if (CalibData.Count > 0)
                return (CalibImage)CalibData[i];
            else
                return null;
        }

        public int getCalibDataLength()
        {
            return CalibData.Count;
        }

        /// <summary>
        /// Add a new calibration image to the list <c>CalibData</c>.
        /// The image is read from the location <c>filename</c>
        /// and a new calibration image instance is then 
        /// generated, embedding this image.
        /// As a preparation step prior to the calibration process, the 
        /// basic information for the calibration image are determined,
        /// in terms of: detection of the region plate and the marks
        /// and pose.
        /// </summary>
        /// <returns>
        /// Instance of a calibration image model created for 
        /// the calibration image, supplied by <c>filename</c>
        /// </returns>
        public CalibImage addImage(string filename)
        {
            HImage image = null;
            CalibImage data = null;

            try
            {
                image = new HImage(filename);
                data = new CalibImage(image, this);
                CalibData.Add(data);
                data.UpdateCaltab(true);
                mCanCalib = (mCanCalib && (data.mCanCalib == 0));
                mCalibValid = false;
            }
            catch (HOperatorException e)
            {
                mErrorMessage = e.Message;
                NotifyCalibObserver(CalibrationAssistant.ERR_READING_FILE);
            }

            return data;
        }

        /// <summary>
        /// Removes the instance of the calibration images
        /// at the index <c>index</c> from the list <c>CalibData</c>
        /// </summary>
        public void removeImage(int index)
        {
            ((CalibImage)CalibData[index]).Clear();
            CalibData.RemoveAt(index);
            mCalibValid = false;
            getCanCalibrate();
            NotifyCalibObserver(CalibrationAssistant.UPDATE_CALIBRATION_RESULTS);
        }

        /// <summary>
        /// Removes all instances of the calibration images
        /// from the list <c>CalibData</c>
        /// </summary>
        public void removeImage()
        {
            int count = CalibData.Count;
            for (int i = 0; i < count; i++)
                ((CalibImage)CalibData[i]).Clear();

            CalibData.Clear();
            mCalibValid = false;
            mCanCalib = false;
            NotifyCalibObserver(CalibrationAssistant.UPDATE_CALIBRATION_RESULTS);
        }

        /// <summary>
        /// Gets the HALCON image with the index <c>index</c> in the list of
        /// calibration images <c>CalibData</c>.
        /// </summary>
        public HImage getImageAt(int index)
        {
            if (CalibData.Count > 0)
                return ((CalibImage)CalibData[index]).getImage();
            return null;
        }

        /// <summary>
        /// Resets the flag <c>mCanCalib</c> to the boolean 'true'
        /// </summary>
        public void resetCanCalib()
        {
            mCanCalib = true;
        }

        /// <summary>
        /// Returns the reference image for the calibration process
        /// </summary>
        public HImage getRefImage()
        {
            return (HImage)mReferenceImage;
        }

        /// <summary>
        /// Returns the simulated image obtained from 
        /// the calibration process
        /// </summary>
        public HImage getSimulatedImage()
        {
            return mSimulatedImage;
        }

        /// <summary>
        /// Returns the reference world coordinate system
        /// obtained from the calibration process
        /// </summary>
        /// <returns></returns>
        public HObject getReferenceWCS()
        {
            return mReferenceWCS;
        }

        /*******************************************/

        /// <summary>
        /// Auxiliary method prior to the actual update 
        /// routine. Calls the actual update method 
        /// omitting the quality assessment for the 
        /// set of calibration image models.
        /// </summary>
        public void Update()
        {
            bool doQuality = false;
            Update(doQuality);
        }

        /// <summary>
        /// Updates the data of the calibration images
        /// if a change occurred in the calibration parameters.
        /// The quality assessment is performed if the 
        /// supplied value is positive; otherwise, it is omited.
        /// </summary>
        /// <param name="doQuality">
        /// If the flag is positive, an update of the 
        /// quality assessment is invoked, otherwise not.
        /// </param>
        public void Update(bool doQuality)
        {
            int count;

            if ((count = CalibData.Count) == 0)
                return;

            try
            {
                for (int i = 0; i < count; i++)
                    ((CalibImage)CalibData[i]).UpdateCaltab(doQuality);

                if (doQuality)
                    UpdateSequenceIssues();


                mCanCalib = getCanCalibrate();

                NotifyCalibObserver(CalibrationAssistant.UPDATE_CALTAB_STATUS);
                NotifyCalibObserver(CalibrationAssistant.UPDATE_MARKS_POSE);

                if (doQuality)
                    NotifyCalibObserver(CalibrationAssistant.UPDATE_QUALITY_TABLE);
            }
            catch (HOperatorException e)
            {
                mErrorMessage = (string)e.Message;
                mCanCalib = false;
                NotifyCalibObserver(CalibrationAssistant.ERR_QUALITY_ISSUES);
            }

            if (mCalibValid)
            {
                mCalibValid = false;
                NotifyCalibObserver(CalibrationAssistant.UPDATE_CALIBRATION_RESULTS);
            }
        }

        /*******************************************/

        /// <summary>
        /// Checks the whole set of calibration image models for
        /// the quality of the preprocessing step. If the basic
        /// information, i.e. the region plate and the marks
        /// and pose, was extracted in all images, then the
        /// flag <c>mCanCalib</c> is positive, which means
        /// the actual calibration process can be initiated 
        /// </summary>
        /// <returns>
        /// Flag indicating the feasibility of the calibration
        /// process
        /// </returns>
        public bool getCanCalibrate()
        {
            int count = CalibData.Count;
            int val = 0;

            for (int i = 0; i < count; i++)
                val += ((CalibImage)CalibData[i]).mCanCalib;

            if (val == 0 && count > 0)
                mCanCalib = true;
            else
                mCanCalib = false;

            return mCanCalib;
        }

        /// <summary>
        /// Gets the mark centers and the poses extracted from
        /// the set of calibration images 
        /// </summary>
        /// <param name="rows">
        /// Tuple of row coordinates of all marks from
        /// the entire set of calibration images
        /// </param>
        /// <param name="cols">
        /// Tuple of column coordinates of all marks from 
        /// the entire set of calibration images
        /// </param>
        /// <returns>
        /// Tuple of estimated poses for the entire set
        /// of calibration images
        /// </returns>
        public HTuple getCalibrationData(out HTuple rows, out HTuple cols)
        {
            int count = CalibData.Count;
            HTuple pose = new HTuple();
            rows = new HTuple();
            cols = new HTuple();
            CalibImage image;

            for (int i = 0; i < count; i++)
            {
                image = (CalibImage)CalibData[i];
                pose = pose.TupleConcat(image.getEstimatedPose());
                rows = rows.TupleConcat(image.getMarkCenterRows());
                cols = cols.TupleConcat(image.getMarkCenterColumns());
            }
            return pose;
        }

        /// <summary>
        /// Gets the camera parameters corresponding to
        /// the supplied calibration image.
        /// </summary>
        /// <returns>Camera parameters</returns>
        public HTuple getCameraParams(CalibImage image)
        {
            HTuple campar;
            int paramsListSize = 8;
            int offset = 0;
            bool areaScanPoly = false;

            if (mCameraType == CalibrationAssistant.CAMERA_TYP_AREA_SCAN_POLY)
            {
                paramsListSize = 12;
                offset = 4;
                areaScanPoly = true;
            }

            paramsListSize += (mCameraType == CalibrationAssistant.CAMERA_TYP_LINE_SCAN) ? 3 : 0;

            campar = new HTuple(paramsListSize);
            campar[0] = (isTelecentric ? 0.0 : ((double)mFocalLength / 1000.0));

            if (areaScanPoly)
            {
                campar[1] = mK1;
                campar[2] = mK2;
                campar[3] = mK3;
                campar[4] = mP1;
                campar[5] = mP2;
            }
            else
            {
                campar[1] = mKappa;
            }

            campar[2 + offset] = (double)mCellWidth / 1000000.0;   // Sx -width   -> * 10^ -6 
            campar[3 + offset] = (double)mCellHeight / 1000000.0;  // Sy -height  -> * 10^ -6 
            campar[4 + offset] = (double)image.mWidth * 0.5;                  // x -principal point 
            campar[5 + offset] = (double)image.mHeight * 0.5;                 // y -principal point 
            campar[6 + offset] = image.mWidth;                      // imagewidth 
            campar[7 + offset] = image.mHeight;                     // imageheight 

            if (paramsListSize == 11)
            {
                campar[8] = mMotionVx / 1000000.0;
                campar[9] = mMotionVy / 1000000.0;
                campar[10] = mMotionVz / 1000000.0;

                campar[5 + offset] = 0;     // y -principal point = 0 for line scan camera 
            }

            return campar;
        }

        /// <summary>
        /// Tests different quality features for the calibration image 
        /// <c>cImg</c>
        /// </summary>
        /// <returns>
        /// Returns a value indicating the success or failure
        /// of the quality assessment
        /// </returns>
        public bool testQualityIssues(CalibImage cImg)
        {
            ArrayList qList;

            HObject markContours;
            HObject plateRegion;
            HImage mImg;
            HTuple score, score2, contrast;
            int numRegions, numContours;
            bool qualityFailure;



            mImg = cImg.getImage();
            qList = cImg.getQualityIssueList();
            procedure = new QualityProcedures();
            contrast = new HTuple();
            qualityFailure = false;
            // DescriptionFileName = mDescrFileName;
            ;

            try
            {
                procedure.find_caltab_edges(mImg, out plateRegion,
                                            out markContours,
                                            new HTuple(mDescrFileName));
                numRegions = plateRegion.CountObj();
                numContours = markContours.CountObj();

                if (mImageTests < QUALITY_ISSUE_TEST_NONE)
                {
                    if (numRegions == 0)
                    {
                        qualityFailure = true;
                    }
                    else
                    {
                        procedure.eval_caltab_overexposure(mImg, plateRegion, out score);
                        addQualityIssue(qList, QUALITY_ISSUE_IMG_EXPOSURE, score.D);
                    }

                    if (numContours == 0)
                    {
                        qualityFailure = true;
                    }
                    else
                    {
                        procedure.eval_caltab_contrast_homogeneity(mImg, markContours, out contrast, out score, out score2);
                        addQualityIssue(qList, QUALITY_ISSUE_IMG_CONTRAST, score.D);
                        addQualityIssue(qList, QUALITY_ISSUE_IMG_HOMOGENEITY, score2.D);

                        procedure.eval_caltab_size(mImg, plateRegion, markContours, out score);
                        addQualityIssue(qList, QUALITY_ISSUE_IMG_CALTAB_SIZE, score.D);
                    }

                    if (mImageTests == QUALITY_ISSUE_TEST_ALL)
                    {
                        procedure.eval_caltab_focus(mImg, markContours, contrast, out score);
                        addQualityIssue(qList, QUALITY_ISSUE_IMG_FOCUS, score.D);
                    }
                }
            }
            catch (HOperatorException e)
            {
                throw (e);
            }

            return qualityFailure;
        }

        /// <summary>
        /// Tests for quality features concerning the performance 
        /// of the entire sequence of calibration images provided by
        /// the list <c>CalibData</c>
        /// </summary>
        public void UpdateSequenceIssues()
        {
            HTuple markRows, marksCols, startPose, width, height, hScore;
            bool hasIssue;
            bool hasError;
            double minScore, score;
            int count, countL;
            CalibImage imgC;
            ArrayList qList;

            mSeqQualityList.Clear();

            try
            {
                if (mSequenceTests < QUALITY_ISSUE_TEST_NONE)
                {
                    hasIssue = false;
                    hasError = false;
                    minScore = 1.0;

                    if ((count = CalibData.Count) == 0)
                        return;

                    for (int i = 0; i < count; i++)
                    {
                        imgC = (CalibImage)CalibData[i];

                        if (imgC.getPlateStatus() == PS_QUALITY_ISSUES)
                        {
                            hasIssue = true;
                            qList = imgC.getQualityIssueList();
                            countL = qList.Count;

                            for (int j = 0; j < countL; j++)
                            {
                                score = ((QualityIssue)qList[j]).getScore();

                                if (score < minScore)
                                    minScore = score;
                            }
                        }
                        else if (imgC.getPlateStatus() != PS_OK)
                        {
                            hasError = true;
                        }
                    }//for

                    if (hasError)
                    {
                        addQualityIssue(mSeqQualityList, QUALITY_ISSUE_SEQ_ERROR, 0.0);
                    }
                    else if (hasIssue)
                    {
                        addQualityIssue(mSeqQualityList, QUALITY_ISSUE_SEQ_ALL_OVER, minScore);
                    }

                    if (count < 20)
                    {
                        score = (count <= 10) ? 0.0 : (0.1 * ((double)count - 10.0));
                        addQualityIssue(mSeqQualityList, QUALITY_ISSUE_SEQ_NUMBER, score);
                    }

                    if (mSequenceTests == QUALITY_ISSUE_TEST_ALL && count > 0)
                    {
                        startPose = getCalibrationData(out markRows, out marksCols);
                        width = new HTuple(((CalibImage)CalibData[0]).mWidth);
                        height = new HTuple(((CalibImage)CalibData[0]).mHeight);

                        procedure.eval_marks_distribution(markRows, marksCols, width, height, out hScore);
                        addQualityIssue(mSeqQualityList, QUALITY_ISSUE_SEQ_MARKS_DISTR, hScore[0].D);

                        procedure.eval_caltab_tilt(startPose, out hScore);
                        addQualityIssue(mSeqQualityList, QUALITY_ISSUE_SEQ_CALTAB_TILT, hScore[0].D);
                    }
                }//if!=None
            }
            catch (HOperatorException e)
            {
                mErrorMessage = e.Message;
            }
        }

        /// <summary>
        /// Adds the calculated score <c>score</c> for the quality feature 
        /// <c>type</c> to the supplied feature list <c>qList</c>
        /// </summary>
        /// <param name="qList">
        /// Quality feature list
        /// </param>
        /// <param name="type">
        /// Constant starting with QUALITY_*, describing one of the quality 
        /// features
        /// </param>
        /// <param name="score">
        /// Score determined for the quality feature
        /// </param>
        public void addQualityIssue(ArrayList qList, int type, double score)
        {
            if ((int)(score * 100) <= mWarnLevel)
                qList.Add(new QualityIssue(type, score));
        }

        /// <summary>
        /// Calls the actual <c>addQualityIssue</c>
        /// method, with the feature list obtained from the
        /// calibration image <c>cImg</c>
        /// </summary>
        /// <param name="cImg">
        /// Calibration image model, which has been tested for
        /// the quality feature defined with <c>type</c>
        /// </param>
        /// <param name="type">
        /// Constant starting with QUALITY_* describing one of the quality 
        /// features
        /// </param>
        /// <param name="score">
        /// Score determined for the quality feature
        /// </param>
        public void addQualityIssue(CalibImage cImg, int type, double score)
        {
            ArrayList qList = cImg.getQualityIssueList();
            addQualityIssue(qList, type, score);
        }

        /// <summary>
        /// Applies the calibration on the set of calibration
        /// images <c>CalibData</c>
        /// </summary>
        public void applyCalibration()
        {
            HTuple x, y, z, marksR, marksC;
            HTuple error, startPoses, startCampar, parameters;
            CalibImage refImg;

            mCalibValid = false;
            mErrorMean = -1;

            if (mReferenceIndex >= 0)
            {
                try
                {
                    refImg = (CalibImage)CalibData[mReferenceIndex];
                    HOperatorSet.CaltabPoints(mDescrFileName, out x, out y, out z);
                    startPoses = getCalibrationData(out marksR, out marksC);
                    startCampar = getCameraParams(refImg);
                    parameters = new HTuple("all");

                    HOperatorSet.CameraCalibration(x, y, z,
                                                   marksR, marksC,
                                                   startCampar,
                                                   startPoses,
                                                   parameters,
                                                   out mCameraParams,
                                                   out mPoses,
                                                   out error);
                    mErrorMean = error[0].D;
                    mCalibValid = true;

                    UpdateResultVisualization();
                }
                catch (HOperatorException e)
                {
                    mErrorMessage = e.Message;
                    NotifyCalibObserver(CalibrationAssistant.ERR_IN_CALIBRATION);
                }
            }
            else
            {
                NotifyCalibObserver(CalibrationAssistant.ERR_REFINDEX_INVALID);
            }//if-else
        }

        /// <summary>
        /// Generates the iconic objects of the calibration results 
        /// for display
        /// </summary>
        public void UpdateResultVisualization()
        {
            HTuple refPose, correctedPose;
            double axisLen;
            HObject obj;

            if (!mCalibValid)
                return;

            mSimulatedImage.Dispose();

            mReferenceImage = ((CalibImage)CalibData[mReferenceIndex]).getImage();
            refPose = getCalibratedPose(false);

            HOperatorSet.SimCaltab(out obj, new HTuple(mDescrFileName),
                                   mCameraParams, refPose, new HTuple(128),
                                   new HTuple(224), new HTuple(80), new HTuple(1));

            mSimulatedImage = new HImage(obj);

            correctedPose = getCalibratedPose(true);
            axisLen = ((CalibImage)CalibData[mReferenceIndex]).getEstimatedPlateSize();

            procedure.get_3d_coord_system(mReferenceImage, out mReferenceWCS, mCameraParams,
                                          correctedPose, new HTuple(axisLen / 2));

            NotifyCalibObserver(CalibrationAssistant.UPDATE_CALIBRATION_RESULTS);
        }

        /// <summary>
        /// Saves the calibrated camera parameters in the file
        /// defined by <c>filename</c>
        /// </summary>
        public void saveCamParams(string filename)
        {
            if (mCalibValid)
            {
                try
                {
                    HOperatorSet.WriteCamPar(mCameraParams, new HTuple(filename));
                }
                catch (HOperatorException e)
                {
                    mErrorMessage = e.Message;
                    NotifyCalibObserver(CalibrationAssistant.ERR_WRITE_CALIB_RESULTS);
                }
            }
        }

        /// <summary>
        /// Saves the pose obtained from the camera calibration
        /// in the file, defined by <c>filename</c>
        /// </summary>
        public void saveCamPose(string filename)
        {
            HTuple Pose;
            if (mCalibValid)
            {
                try
                {
                    Pose = getCalibratedPose(true);
                    HOperatorSet.WritePose(Pose, new HTuple(filename));
                }
                catch (HOperatorException e)
                {
                    mErrorMessage = e.Message;
                    NotifyCalibObserver(CalibrationAssistant.ERR_WRITE_CALIB_RESULTS);
                }
            }
        }

        /// <summary>
        /// Returns calibration results
        /// </summary>
        /// <param name="camParams">
        /// Calibrated internal camera parameters 
        /// </param>
        /// <param name="refPose">
        /// Calibrated external camera parameters
        /// </param>
        public void getCalibrationResult(out HTuple camParams,
                                           out HTuple refPose)
        {
            camParams = new HTuple(mCameraParams);
            refPose = getCalibratedPose(true);
        }

        /// <summary>
        /// Returns the calibrated reference pose
        /// </summary>
        public HTuple getCalibratedPose(bool corrected)
        {
            HTuple tX, tY, tZ, correctedPose, refPose = null;

            if (!mCalibValid)
                return new HTuple(1.0, -1.0, 0.0);


            if (mPoses.Length >= 7 * (mReferenceIndex + 1))
                refPose = mPoses.TupleSelectRange(new HTuple(7 * mReferenceIndex),
                                                   new HTuple(7 * mReferenceIndex + 6));

            if (!corrected)
                return refPose;

            tX = new HTuple(0);
            tY = new HTuple(0);
            tZ = new HTuple(this.mThickness / 1000.0);

            if (mAtImgCoord)
            {
                HOperatorSet.ImagePointsToWorldPlane(mCameraParams, refPose,
                                                    new HTuple(0), new HTuple(0),
                                                    new HTuple("mm"), out tX, out tY);
            }
            HOperatorSet.SetOriginPose(refPose, tX, tY, tZ, out correctedPose);

            return correctedPose;
        }

        /// <summary>Loads camera parameters from file</summary>
        /// <param name="camParFile">File name</param>
        /// <returns>Success or failure of load process</returns>
        public bool importCamParams(string camParFile)
        {
            HTuple campar;
            int offset = 0;
            bool areaScanPoly = false;


            try
            {
                HOperatorSet.ReadCamPar(new HTuple(camParFile), out campar);

                // -- load camera parameters --
                switch (campar.Length)
                {
                    case 8:
                        mCameraType = CAMERA_TYP_AREA_SCAN_DIV;
                        break;
                    case 11:
                        mCameraType = CAMERA_TYP_LINE_SCAN;
                        break;
                    case 12:
                        mCameraType = CAMERA_TYP_AREA_SCAN_POLY;
                        offset = 4;
                        areaScanPoly = true;
                        break;
                    default:
                        mCameraType = -1;
                        break;
                }

                mFocalLength = campar[0] * 1000.0;

                if (mFocalLength == 0.0)
                    isTelecentric = true;
                else
                    isTelecentric = false;

                if (areaScanPoly)
                {
                    mK1 = campar[1];
                    mK2 = campar[2];
                    mK3 = campar[3];
                    mP1 = campar[4];
                    mP2 = campar[5];
                }
                else
                {
                    mKappa = campar[1];
                }

                mCellWidth = campar[2 + offset] * 1000000.0;
                mCellHeight = campar[3 + offset] * 1000000.0;

                // line scan camera
                if (campar.Length == 11)
                {
                    mMotionVx = campar[8].D * 1000000.0;
                    mMotionVy = campar[9].D * 1000000.0;
                    mMotionVz = campar[10].D * 1000000.0;
                }

                Update(true);
            }
            catch (HOperatorException e)
            {
                mErrorMessage = e.Message;
                NotifyCalibObserver(CalibrationAssistant.ERR_READING_FILE);
                return false;
            }

            return true;
        }

        /// <summary>
        /// Resets the camera parameters to the default settings.
        /// </summary>
        /// <param name="camTyp">
        /// Flag to change camera type to the default as well
        /// </param>
        public void resetCameraSetup(bool camTyp)
        {
            if (camTyp)
                mCameraType = CAMERA_TYP_AREA_SCAN_DIV;

            mThickness = 1.00;
            mCellWidth = 8.300;
            mCellHeight = 8.300;
            mFocalLength = 8.000;
            isTelecentric = false;
            mKappa = 0.0;
            mK1 = 0.0;
            mK2 = 0.0;
            mK3 = 0.0;
            mP1 = 0.0;
            mP2 = 0.0;
            mMotionVx = 0.0;
            mMotionVy = 500.0;
            mMotionVz = 0.0;

            Update(true);
        }

    }
}